[occt.git] / src / TopOpeBRepDS / TopOpeBRepDS_Check.cxx

// Created on: 1997-04-10
// Created by: Prestataire Mary FABIEN
// Copyright (c) 1997-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.


#include <BRep_Tool.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopOpeBRepDS.hxx>
#include <TopOpeBRepDS_Check.hxx>
#include <TopOpeBRepDS_CheckStatus.hxx>
#include <TopOpeBRepDS_CurvePointInterference.hxx>
#include <TopOpeBRepDS_DataMapIteratorOfDataMapOfCheckStatus.hxx>
#include <TopOpeBRepDS_DataMapOfCheckStatus.hxx>
#include <TopOpeBRepDS_EdgeVertexInterference.hxx>
#include <TopOpeBRepDS_HDataStructure.hxx>
#include <TopOpeBRepDS_Interference.hxx>
#include <TopOpeBRepDS_InterferenceTool.hxx>
#include <TopOpeBRepDS_Kind.hxx>
#include <TopOpeBRepDS_ListIteratorOfListOfInterference.hxx>
#include <TopOpeBRepDS_ListOfInterference.hxx>
#include <TopOpeBRepDS_PointExplorer.hxx>
#include <TopOpeBRepTool_ShapeTool.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>

#include <string.h>
IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_Check,Standard_Transient)

//=======================================================================
//function : Create
//purpose  : 
//=======================================================================
TopOpeBRepDS_Check::TopOpeBRepDS_Check(const Handle(TopOpeBRepDS_HDataStructure)& HDS)
{
  myHDS = HDS;
  myMapSurfaceStatus.Clear();
  myMapCurveStatus.Clear();
  myMapPointStatus.Clear();
  myMapShapeStatus.Clear();
}

//=======================================================================
//function : Create
//purpose  : 
//=======================================================================

TopOpeBRepDS_Check::TopOpeBRepDS_Check()
{
    myMapSurfaceStatus.Clear();
    myMapCurveStatus.Clear();
    myMapPointStatus.Clear();
    myMapShapeStatus.Clear();
}

//=======================================================================
//function : ChkIntg
//purpose  : Check Integrity
//=======================================================================
Standard_Boolean CheckEdgeParameter(const Handle(TopOpeBRepDS_HDataStructure)& myHDS);
Standard_Boolean TopOpeBRepDS_Check::ChkIntg()
{
  const TopOpeBRepDS_DataStructure& DS = myHDS->DS();
  Standard_Boolean bI=Standard_False;
  // Check the integrity of the DS
  Standard_Integer i,nshape = DS.NbShapes();
  for (i = 1; i <= nshape; i++) {
    // Integrity of Interferences : Check support and geometry
    const TopOpeBRepDS_ListOfInterference& LI = DS.ShapeInterferences(i);
    bI = ChkIntgInterf(LI);
  }
  Standard_Integer nsurface = DS.NbSurfaces();
  for (i = 1; i <= nsurface; i++) {
    // Integrity of Interferences : Check support and geometry
    const TopOpeBRepDS_ListOfInterference& LI = DS.SurfaceInterferences(i);
    bI = bI && ChkIntgInterf(LI);
  }
  
  Standard_Integer ncurve = DS.NbCurves();
  for (i = 1; i <= ncurve; i++) {
    // Integrity of Interferences : Check support and geometry
    const TopOpeBRepDS_ListOfInterference& LI = DS.CurveInterferences(i);
    bI = bI && ChkIntgInterf(LI);
  }
  
  Standard_Integer npoint = DS.NbPoints();
  for (i = 1; i <= npoint; i++) {
    // Integrity of Interferences : Check support and geometry
    const TopOpeBRepDS_ListOfInterference& LI = DS.PointInterferences(i);
    bI = bI && ChkIntgInterf(LI);
  }

  //  CheckEdgeParameter();
  CheckEdgeParameter(myHDS);

  return bI;
}

//=======================================================================
//function : ChkIntgInterf
//purpose  : 
//=======================================================================

Standard_Boolean TopOpeBRepDS_Check::ChkIntgInterf
(const TopOpeBRepDS_ListOfInterference& LI)
{
  TopOpeBRepDS_ListIteratorOfListOfInterference it1;
  it1.Initialize(LI);
  Standard_Boolean IsOK = Standard_True;
  while (it1.More() ) {
    Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
    IsOK = IsOK && CheckDS(I1->Support(), I1->SupportType());
    IsOK = IsOK && CheckDS(I1->Geometry(), I1->GeometryType());
    it1.Next();
  }
  return IsOK;
} 

//=======================================================================
//function : CheckDS
//purpose  : 
//=======================================================================

Standard_Boolean TopOpeBRepDS_Check::CheckDS(const Standard_Integer I,
					     const TopOpeBRepDS_Kind K)
{
  // geometry
  switch(K) {
  case TopOpeBRepDS_SURFACE :
    {
      if(myHDS->NbSurfaces() < I) {
	if(myMapSurfaceStatus.IsBound(I))
	  myMapSurfaceStatus.UnBind(I);
	myMapSurfaceStatus.Bind(I, TopOpeBRepDS_NOK);
	return Standard_False;
      }
      if(!myMapSurfaceStatus.IsBound(I))
	myMapSurfaceStatus.Bind(I,TopOpeBRepDS_OK);
      return Standard_True;
    }
  case TopOpeBRepDS_CURVE :
    {
      if(myHDS->NbCurves() < I) {
	if(myMapCurveStatus.IsBound(I))
	  myMapCurveStatus.UnBind(I);
	myMapCurveStatus.Bind(I, TopOpeBRepDS_NOK);
	return Standard_False;
      }
      
      if(!myMapCurveStatus.IsBound(I))
	myMapCurveStatus.Bind(I,TopOpeBRepDS_OK);
      return Standard_True;
    }
  case TopOpeBRepDS_POINT :
    {
      if(myHDS->NbPoints() < I) {
	if(myMapPointStatus.IsBound(I))
	  myMapPointStatus.UnBind(I);
	myMapPointStatus.Bind(I, TopOpeBRepDS_NOK);
	return Standard_False;
      }
      if(!myMapPointStatus.IsBound(I))
	myMapPointStatus.Bind(I,TopOpeBRepDS_OK);
      return Standard_True;
    }
  default:
    break ;
  }
  

  // topology
  if(myHDS->NbShapes() < I) {
    if(myMapShapeStatus.IsBound(I))
      myMapShapeStatus.UnBind(I);
    myMapShapeStatus.Bind(I,TopOpeBRepDS_NOK);
    return Standard_False;
  }
  const TopoDS_Shape& S =myHDS->Shape(I);

  TopAbs_ShapeEnum se=TopAbs_COMPOUND;

  switch (K) {
  case TopOpeBRepDS_SOLID  : se = TopAbs_SOLID; break;
  case TopOpeBRepDS_SHELL  : se = TopAbs_SHELL; break;
  case TopOpeBRepDS_FACE   : se = TopAbs_FACE;  break;
  case TopOpeBRepDS_WIRE   : se = TopAbs_WIRE;  break;
  case TopOpeBRepDS_EDGE   : se = TopAbs_EDGE;  break;
  case TopOpeBRepDS_VERTEX : se = TopAbs_VERTEX;break;
  default:
    break ;
  }
  if(S.ShapeType() != se) {
    if(myMapShapeStatus.IsBound(I))
      myMapShapeStatus.UnBind(I);
    myMapShapeStatus.Bind(I,TopOpeBRepDS_NOK);
    return Standard_False;
  }
  if(!myMapShapeStatus.IsBound(I))
    myMapShapeStatus.Bind(I,TopOpeBRepDS_OK);
  return Standard_True;;
}

//=======================================================================
//function : ChkIntgSamDom
//purpose  : 
//=======================================================================

Standard_Boolean TopOpeBRepDS_Check::ChkIntgSamDom()
{
  Standard_Boolean b = Standard_True, bb = Standard_False;
  TopOpeBRepDS_DataStructure& BDS = myHDS->ChangeDS();
  Standard_Integer NbSh = myHDS->NbShapes(), i, Curr, Loc;
  for(i = 1;i <= NbSh; i++) {
    // Verifie que les Shapes de mySameDomaine existe bien dans la DS
    const TopoDS_Shape& Sind = myHDS->Shape(i);
    const TopTools_ListOfShape& losi = BDS.ShapeSameDomain(Sind);
    if(!CheckShapes(losi)) {
      b = Standard_False;
    }
    
    // Verification de SameDomaineRef
    Curr = BDS.SameDomainRef(i);
    Loc = BDS.SameDomainRef(Curr);
    if(Curr && (Curr != Loc)) {
      b = Standard_False;
    }
    
    if(Curr) {
      // Verification du type des differents Shapes SameDomain
      const TopoDS_Shape& Sref = myHDS->Shape(Curr);
      if(Sind.ShapeType() != Sref.ShapeType()) {
	b = Standard_False;
      }

      // Verifier que ShapeSameDomain(Sref) contient bien Sind
      // sauf si Sind == Sref
      if(i != Curr) {
	const TopTools_ListOfShape& losr = BDS.ShapeSameDomain(Sref);
	TopTools_ListIteratorOfListOfShape liolos;
	liolos.Initialize(losr);
	while (liolos.More() ) {
	  const TopoDS_Shape& Sh = liolos.Value();
	  Loc = myHDS->Shape(Sh);
	  if(Loc == i) {
	    bb = Standard_True;
	    break;
	  }
	  liolos.Next();
	}
	if(!bb) {
	  b = Standard_False;
	}
      }
    }
  }
  return b;
}

//=======================================================================
//function : CheckShapes
//purpose  : 
//=======================================================================

Standard_Boolean TopOpeBRepDS_Check::CheckShapes
(const TopTools_ListOfShape& LS ) const
{
  Standard_Integer index;
  TopTools_ListIteratorOfListOfShape it(LS);
  while (it.More()) {
    const TopoDS_Shape& itS = it.Value();
    index = myHDS->Shape(itS);
    if (!index) return Standard_False;
    it.Next();
  }
  return Standard_True;
}

//=======================================================================
//function : OneVertexOnPnt
//purpose  : 
//=======================================================================

Standard_Boolean TopOpeBRepDS_Check::OneVertexOnPnt(){
  Standard_Boolean b = Standard_True;
//  Standard_Integer i, j, k;
  Standard_Integer i, j;
  Standard_Integer Curr1, Curr2, sdr1, sdr2;
  Standard_Integer NbVe = 0, NbPo = myHDS->NbPoints();
//  Standard_Real tol, tol1, tol2, Dist;
  Standard_Real tol1, tol2, Dist;
  TColStd_IndexedMapOfInteger vert;
  vert.Clear();
  for(i = 1;i <= myHDS->NbShapes();i++) {
    const TopoDS_Shape& S = myHDS->Shape(i);
    if((S.ShapeType() == TopAbs_VERTEX) &&
       myHDS->HasShape(S))
      vert.Add(i);
  }
  NbVe = vert.Extent();
  for(i = 1;i <= NbVe; i++) {
    Curr1 = vert.FindKey(i);
    const TopoDS_Shape& S1 = myHDS->Shape(Curr1);
    sdr1 = myHDS->SameDomainReference(S1);
    for(j = i+1;j <= NbVe; j++) {
      Curr2 = vert.FindKey(j);
      const TopoDS_Shape& S2 = myHDS->Shape(Curr2);
      sdr2 = myHDS->SameDomainReference(S2);
      tol1 = TopOpeBRepTool_ShapeTool::Tolerance(S1);
      tol2 = TopOpeBRepTool_ShapeTool::Tolerance(S2);
      const gp_Pnt& P1 = TopOpeBRepTool_ShapeTool::Pnt(S1);
      const gp_Pnt& P2 = TopOpeBRepTool_ShapeTool::Pnt(S2);
      Dist = P1.Distance(P2);
      if(Dist <= tol1 + tol2) {
	if(sdr1 != sdr2) {
	  b = Standard_False;
	}
      }
      else if(sdr1 == sdr2) {
	b = Standard_False;
      }
    }
    TopOpeBRepDS_PointExplorer PE(myHDS->DS());
    for(;PE.More(); PE.Next()) {
      const TopOpeBRepDS_Point& dsPnt = PE.Point();
      const gp_Pnt& Pnt1 = dsPnt.Point();
      tol1 = dsPnt.Tolerance();
      tol2 = TopOpeBRepTool_ShapeTool::Tolerance(S1);
      const gp_Pnt& Pnt2 = TopOpeBRepTool_ShapeTool::Pnt(S1);
      Dist = Pnt1.Distance(Pnt2);
      if(Dist <= tol1 + tol2) {
	b = Standard_False;
      }
    }
  }
  for(i = 1;i <= NbPo; i++) {
    TopOpeBRepDS_PointExplorer PE(myHDS->DS());
    if(PE.IsPoint(i)) {
      const TopOpeBRepDS_Point& dsPnt1 = myHDS->Point(i);
      for(j = i+1;j < NbPo;j++) {
	const TopOpeBRepDS_Point& dsPnt2 = myHDS->Point(j);
	if(dsPnt1.IsEqual(dsPnt2)) {
	}
      }
    }
  }
  
  return b;
}

//=======================================================================
//function : CheckEdgeParameter
//purpose  : 
//=======================================================================

///Standard_Boolean TopOpeBRepDS_Check::CheckEdgeParameter() const
Standard_Boolean CheckEdgeParameter(const Handle(TopOpeBRepDS_HDataStructure)& myHDS)
{
  TopOpeBRepDS_ListIteratorOfListOfInterference it1;
  const TopOpeBRepDS_DataStructure& DS = myHDS->DS();
  Standard_Integer i,nshape = DS.NbShapes();
  Standard_Boolean IsOK = Standard_True;
  for (i = 1; i <= nshape; i++) {
    // Integrity of Interferences : Check parameter of EdgeInterferences
    const TopOpeBRepDS_ListOfInterference& LI = DS.ShapeInterferences(i);
    it1.Initialize(LI);
    while (it1.More() ) {
      Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
      Handle(TopOpeBRepDS_EdgeVertexInterference) EVI =
	Handle(TopOpeBRepDS_EdgeVertexInterference)::DownCast(I1);
      if(!EVI.IsNull()) {
	Standard_Integer Param = (Standard_Integer ) EVI->Parameter();
	if(Param > 1.e50) {
	  IsOK = Standard_False;
	}
      }
      it1.Next();
    }
  }
  
  Standard_Integer ncurve = DS.NbCurves();
  for (i = 1; i <= ncurve; i++) {
    // Integrity of Interferences : Check parameter of CurvesInterferences
    const TopOpeBRepDS_ListOfInterference& LI = DS.CurveInterferences(i);
    it1.Initialize(LI);
    while (it1.More() ) {
      const Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
      Handle(TopOpeBRepDS_CurvePointInterference) CPI (Handle(TopOpeBRepDS_CurvePointInterference)::DownCast(I1));
      if(!CPI.IsNull()) {
	Standard_Integer Param = 
	  (Standard_Integer ) TopOpeBRepDS_InterferenceTool::Parameter(CPI);
	if(Param > 1.e50) {
	  IsOK = Standard_False;
	}
      }
      it1.Next();
    }
    
  }
  return IsOK;
}

//=======================================================================
//function : PrintIntg
//purpose  : 
//=======================================================================
Standard_OStream& TopOpeBRepDS_Check::PrintIntg(Standard_OStream& OS)
{
  OS<<endl<<endl<<"************************************************"<<endl;
  OS<<"state of the DS : (only the tested elements)"<<endl<<endl;
  
  //Display of the geometry
  PrintMap(myMapSurfaceStatus, "Surface", OS);
  PrintMap(myMapCurveStatus,   "Curve",   OS);
  PrintMap(myMapPointStatus,   "Point",   OS);
  
  //display of the topology
  TopOpeBRepDS_DataMapIteratorOfDataMapOfCheckStatus DMI(myMapShapeStatus);
  TopOpeBRepDS_DataMapOfCheckStatus MapVertex, MapEdge, MapWire, MapFace, MapSolid;
  Standard_Integer i;
  // different Map keep their index of myMapShapeStatus
  for(DMI.Reset();DMI.More();DMI.Next()) {
    i = DMI.Key();
    const TopoDS_Shape& S =myHDS->Shape(i);
    switch(S.ShapeType()) {
    case TopAbs_VERTEX: MapVertex.Bind(i, DMI.Value()); break;
    case TopAbs_EDGE: MapEdge.Bind(i, DMI.Value()); break;
    case TopAbs_WIRE: MapWire.Bind(i, DMI.Value()); break;
    case TopAbs_FACE: MapFace.Bind(i, DMI.Value()); break;
    case TopAbs_SOLID: MapSolid.Bind(i, DMI.Value()); break;
    default:
      break ;
    }
  }
  
  PrintMap(MapVertex, "Vertex", OS);
  PrintMap(MapEdge, "Edge",   OS);
  PrintMap(MapWire, "Wire",   OS);
  PrintMap(MapFace, "Face",   OS);
  PrintMap(MapSolid, "Solid",  OS);
  
  OS<<endl<<endl;
  return OS;
}

//=======================================================================
//function : PrintMap
//purpose  : 
//=======================================================================

Standard_OStream& TopOpeBRepDS_Check::PrintMap(TopOpeBRepDS_DataMapOfCheckStatus& MapStat,
					       const Standard_CString eltstr,
					       Standard_OStream& OS)
{
  TopOpeBRepDS_DataMapIteratorOfDataMapOfCheckStatus DMI(MapStat);
  DMI.Initialize(MapStat);
  if(DMI.More()) {
    Standard_Boolean b = Standard_True;
    OS<<" "<<eltstr<<"\t(/"<<MapStat.Extent()<<")\tnumber ";
    
    PrintElts(MapStat, TopOpeBRepDS_OK,  b, OS);
    if(!b) OS<<" = OK"<<endl;
    PrintElts(MapStat, TopOpeBRepDS_NOK, b, OS);
    if(!b) OS<<" = NOK"<<endl;
  }    
  return OS;
}

//=======================================================================
//function : PrintElts
//purpose  : Print the elements in the state stat of MapStat
//=======================================================================
Standard_OStream& TopOpeBRepDS_Check::PrintElts(TopOpeBRepDS_DataMapOfCheckStatus& MapStat,
						const TopOpeBRepDS_CheckStatus Stat,
						Standard_Boolean& b,
						Standard_OStream& OS)
{
  TopOpeBRepDS_DataMapIteratorOfDataMapOfCheckStatus DMI(MapStat);
  Standard_Boolean bb = !b;
  b = Standard_True;
  Standard_Integer i;
  TopOpeBRepDS_CheckStatus s;
  for(DMI.Reset();DMI.More();DMI.Next()) {
    s = DMI.Value();
    i = DMI.Key();
    if(s == Stat) {
      if(b) b=!b; 
      if(bb){OS<<"\t\tnumber ";bb=!bb;}
      OS<<i<<" ";
    }
  }
  return OS;
}

//=======================================================================
//function : Print
//purpose  : 
//=======================================================================
Standard_OStream& TopOpeBRepDS_Check::Print
(const TopOpeBRepDS_CheckStatus stat,
 Standard_OStream& OS)
{
  switch(stat) {
  case TopOpeBRepDS_OK: OS<<"OK";break;
  case TopOpeBRepDS_NOK: OS<<"NOK";break;
  default : break;
  }
  return OS;
}

//=======================================================================
//function : PrintShape
//purpose  : 
//=======================================================================
Standard_OStream& TopOpeBRepDS_Check::PrintShape
(const TopAbs_ShapeEnum SE,
 Standard_OStream& OS)
{
  switch(SE) {
  case TopAbs_SOLID   : OS<<"Solid ";   break;
  case TopAbs_SHELL   : OS<<"Shell ";   break;
  case TopAbs_FACE    : OS<<"Face  ";    break;
  case TopAbs_WIRE    : OS<<"Wire  ";    break;
  case TopAbs_EDGE    : OS<<"Edge  ";    break;
  case TopAbs_VERTEX  : OS<<"Vertex";  break;
  default:
    break ;
  }
  return OS;
}

//=======================================================================
//function : PrintShape
//purpose  : 
//=======================================================================
Standard_OStream& TopOpeBRepDS_Check::PrintShape
(const Standard_Integer index,
 Standard_OStream& OS)
{
  if(myHDS->NbShapes() < index) { 
    OS<<"**PB**IN**TopOpeBRepDS_Check::PrintShape** ";
    return OS;
  }
  if(!myMapShapeStatus.IsBound(index)) {
    OS<<"NO CHECK HAS PROCESSING"<<endl;
    return OS;
  }
  OS<<" ";
  myHDS->Shape(index);

  return OS;
}

//=======================================================================
//function : HDS
//purpose  : 
//=======================================================================

const Handle(TopOpeBRepDS_HDataStructure)&  TopOpeBRepDS_Check::HDS()const 
{
  return myHDS;
}


//=======================================================================
//function : ChangeHDS
//purpose  : 
//=======================================================================

Handle(TopOpeBRepDS_HDataStructure)&  TopOpeBRepDS_Check::ChangeHDS()
{
  return myHDS;
}
Commit	Line	Data
b311480e	1	// Created on: 1997-04-10
	2	// Created by: Prestataire Mary FABIEN
	3	// Copyright (c) 1997-1999 Matra Datavision
973c2be1	4	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	//
973c2be1	6	// This file is part of Open CASCADE Technology software library.
b311480e	7	//
d5f74e42	8	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	9	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	10	// by the Free Software Foundation, with special exception defined in the file
	11	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	12	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	13	//
973c2be1	14	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	// commercial license or contractual agreement.
7fd59977	16
42cf5bc1	17
	18	#include <BRep_Tool.hxx>
	19	#include <gp_Pnt.hxx>
	20	#include <Standard_Type.hxx>
7fd59977	21	#include <TCollection_AsciiString.hxx>
7fd59977	22	#include <TColStd_IndexedMapOfInteger.hxx>
7fd59977	23	#include <TopoDS.hxx>
	24	#include <TopoDS_Shape.hxx>
	25	#include <TopoDS_Vertex.hxx>
42cf5bc1	26	#include <TopOpeBRepDS.hxx>
	27	#include <TopOpeBRepDS_Check.hxx>
	28	#include <TopOpeBRepDS_CheckStatus.hxx>
	29	#include <TopOpeBRepDS_CurvePointInterference.hxx>
7fd59977	30	#include <TopOpeBRepDS_DataMapIteratorOfDataMapOfCheckStatus.hxx>
42cf5bc1	31	#include <TopOpeBRepDS_DataMapOfCheckStatus.hxx>
	32	#include <TopOpeBRepDS_EdgeVertexInterference.hxx>
	33	#include <TopOpeBRepDS_HDataStructure.hxx>
	34	#include <TopOpeBRepDS_Interference.hxx>
	35	#include <TopOpeBRepDS_InterferenceTool.hxx>
	36	#include <TopOpeBRepDS_Kind.hxx>
	37	#include <TopOpeBRepDS_ListIteratorOfListOfInterference.hxx>
	38	#include <TopOpeBRepDS_ListOfInterference.hxx>
	39	#include <TopOpeBRepDS_PointExplorer.hxx>
	40	#include <TopOpeBRepTool_ShapeTool.hxx>
	41	#include <TopTools_ListIteratorOfListOfShape.hxx>
	42	#include <TopTools_ListOfShape.hxx>
7fd59977	43
42cf5bc1	44	#include <string.h>
25e59720	45	IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_Check,Standard_Transient)
92efcf78	46
7fd59977	47	//=======================================================================
	48	//function : Create
	49	//purpose :
	50	//=======================================================================
7fd59977	51	TopOpeBRepDS_Check::TopOpeBRepDS_Check(const Handle(TopOpeBRepDS_HDataStructure)& HDS)
7fd59977	52	{
	53	myHDS = HDS;
	54	myMapSurfaceStatus.Clear();
	55	myMapCurveStatus.Clear();
	56	myMapPointStatus.Clear();
	57	myMapShapeStatus.Clear();
	58	}
	59
	60	//=======================================================================
	61	//function : Create
	62	//purpose :
	63	//=======================================================================
	64
	65	TopOpeBRepDS_Check::TopOpeBRepDS_Check()
7fd59977	66	{
	67	myMapSurfaceStatus.Clear();
	68	myMapCurveStatus.Clear();
	69	myMapPointStatus.Clear();
	70	myMapShapeStatus.Clear();
	71	}
	72
	73	//=======================================================================
	74	//function : ChkIntg
	75	//purpose : Check Integrity
	76	//=======================================================================
	77	Standard_Boolean CheckEdgeParameter(const Handle(TopOpeBRepDS_HDataStructure)& myHDS);
	78	Standard_Boolean TopOpeBRepDS_Check::ChkIntg()
	79	{
	80	const TopOpeBRepDS_DataStructure& DS = myHDS->DS();
	81	Standard_Boolean bI=Standard_False;
	82	// Check the integrity of the DS
	83	Standard_Integer i,nshape = DS.NbShapes();
	84	for (i = 1; i <= nshape; i++) {
	85	// Integrity of Interferences : Check support and geometry
	86	const TopOpeBRepDS_ListOfInterference& LI = DS.ShapeInterferences(i);
	87	bI = ChkIntgInterf(LI);
	88	}
	89	Standard_Integer nsurface = DS.NbSurfaces();
	90	for (i = 1; i <= nsurface; i++) {
	91	// Integrity of Interferences : Check support and geometry
	92	const TopOpeBRepDS_ListOfInterference& LI = DS.SurfaceInterferences(i);
	93	bI = bI && ChkIntgInterf(LI);
	94	}
	95
	96	Standard_Integer ncurve = DS.NbCurves();
	97	for (i = 1; i <= ncurve; i++) {
	98	// Integrity of Interferences : Check support and geometry
	99	const TopOpeBRepDS_ListOfInterference& LI = DS.CurveInterferences(i);
	100	bI = bI && ChkIntgInterf(LI);
	101	}
	102
	103	Standard_Integer npoint = DS.NbPoints();
	104	for (i = 1; i <= npoint; i++) {
	105	// Integrity of Interferences : Check support and geometry
	106	const TopOpeBRepDS_ListOfInterference& LI = DS.PointInterferences(i);
	107	bI = bI && ChkIntgInterf(LI);
	108	}
536a3cb8	109
536a3cb8	110	// CheckEdgeParameter();
7fd59977	111	CheckEdgeParameter(myHDS);
	112
	113	return bI;
	114	}
	115
	116	//=======================================================================
	117	//function : ChkIntgInterf
	118	//purpose :
	119	//=======================================================================
	120
	121	Standard_Boolean TopOpeBRepDS_Check::ChkIntgInterf
	122	(const TopOpeBRepDS_ListOfInterference& LI)
	123	{
	124	TopOpeBRepDS_ListIteratorOfListOfInterference it1;
	125	it1.Initialize(LI);
	126	Standard_Boolean IsOK = Standard_True;
	127	while (it1.More() ) {
	128	Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
	129	IsOK = IsOK && CheckDS(I1->Support(), I1->SupportType());
	130	IsOK = IsOK && CheckDS(I1->Geometry(), I1->GeometryType());
	131	it1.Next();
	132	}
	133	return IsOK;
	134	}
	135
	136	//=======================================================================
	137	//function : CheckDS
	138	//purpose :
	139	//=======================================================================
	140
	141	Standard_Boolean TopOpeBRepDS_Check::CheckDS(const Standard_Integer I,
	142	const TopOpeBRepDS_Kind K)
	143	{
	144	// geometry
	145	switch(K) {
	146	case TopOpeBRepDS_SURFACE :
	147	{
	148	if(myHDS->NbSurfaces() < I) {
7fd59977	149	if(myMapSurfaceStatus.IsBound(I))
	150	myMapSurfaceStatus.UnBind(I);
	151	myMapSurfaceStatus.Bind(I, TopOpeBRepDS_NOK);
	152	return Standard_False;
	153	}
	154	if(!myMapSurfaceStatus.IsBound(I))
	155	myMapSurfaceStatus.Bind(I,TopOpeBRepDS_OK);
	156	return Standard_True;
	157	}
	158	case TopOpeBRepDS_CURVE :
	159	{
	160	if(myHDS->NbCurves() < I) {
7fd59977	161	if(myMapCurveStatus.IsBound(I))
	162	myMapCurveStatus.UnBind(I);
	163	myMapCurveStatus.Bind(I, TopOpeBRepDS_NOK);
	164	return Standard_False;
	165	}
	166
	167	if(!myMapCurveStatus.IsBound(I))
	168	myMapCurveStatus.Bind(I,TopOpeBRepDS_OK);
	169	return Standard_True;
	170	}
	171	case TopOpeBRepDS_POINT :
	172	{
	173	if(myHDS->NbPoints() < I) {
7fd59977	174	if(myMapPointStatus.IsBound(I))
	175	myMapPointStatus.UnBind(I);
	176	myMapPointStatus.Bind(I, TopOpeBRepDS_NOK);
	177	return Standard_False;
	178	}
	179	if(!myMapPointStatus.IsBound(I))
	180	myMapPointStatus.Bind(I,TopOpeBRepDS_OK);
	181	return Standard_True;
	182	}
	183	default:
	184	break ;
	185	}
	186
	187
	188	// topology
	189	if(myHDS->NbShapes() < I) {
7fd59977	190	if(myMapShapeStatus.IsBound(I))
	191	myMapShapeStatus.UnBind(I);
	192	myMapShapeStatus.Bind(I,TopOpeBRepDS_NOK);
	193	return Standard_False;
	194	}
	195	const TopoDS_Shape& S =myHDS->Shape(I);
1d47d8d0	196
7fd59977	197	TopAbs_ShapeEnum se=TopAbs_COMPOUND;
1d47d8d0	198
7fd59977	199	switch (K) {
	200	case TopOpeBRepDS_SOLID : se = TopAbs_SOLID; break;
	201	case TopOpeBRepDS_SHELL : se = TopAbs_SHELL; break;
	202	case TopOpeBRepDS_FACE : se = TopAbs_FACE; break;
	203	case TopOpeBRepDS_WIRE : se = TopAbs_WIRE; break;
	204	case TopOpeBRepDS_EDGE : se = TopAbs_EDGE; break;
	205	case TopOpeBRepDS_VERTEX : se = TopAbs_VERTEX;break;
	206	default:
	207	break ;
	208	}
	209	if(S.ShapeType() != se) {
7fd59977	210	if(myMapShapeStatus.IsBound(I))
	211	myMapShapeStatus.UnBind(I);
	212	myMapShapeStatus.Bind(I,TopOpeBRepDS_NOK);
	213	return Standard_False;
	214	}
	215	if(!myMapShapeStatus.IsBound(I))
	216	myMapShapeStatus.Bind(I,TopOpeBRepDS_OK);
	217	return Standard_True;;
	218	}
	219
	220	//=======================================================================
	221	//function : ChkIntgSamDom
	222	//purpose :
	223	//=======================================================================
	224
	225	Standard_Boolean TopOpeBRepDS_Check::ChkIntgSamDom()
	226	{
	227	Standard_Boolean b = Standard_True, bb = Standard_False;
	228	TopOpeBRepDS_DataStructure& BDS = myHDS->ChangeDS();
	229	Standard_Integer NbSh = myHDS->NbShapes(), i, Curr, Loc;
	230	for(i = 1;i <= NbSh; i++) {
	231	// Verifie que les Shapes de mySameDomaine existe bien dans la DS
	232	const TopoDS_Shape& Sind = myHDS->Shape(i);
	233	const TopTools_ListOfShape& losi = BDS.ShapeSameDomain(Sind);
	234	if(!CheckShapes(losi)) {
7fd59977	235	b = Standard_False;
	236	}
	237
	238	// Verification de SameDomaineRef
	239	Curr = BDS.SameDomainRef(i);
	240	Loc = BDS.SameDomainRef(Curr);
	241	if(Curr && (Curr != Loc)) {
7fd59977	242	b = Standard_False;
	243	}
	244
	245	if(Curr) {
	246	// Verification du type des differents Shapes SameDomain
	247	const TopoDS_Shape& Sref = myHDS->Shape(Curr);
	248	if(Sind.ShapeType() != Sref.ShapeType()) {
7fd59977	249	b = Standard_False;
	250	}
	251
	252	// Verifier que ShapeSameDomain(Sref) contient bien Sind
	253	// sauf si Sind == Sref
	254	if(i != Curr) {
	255	const TopTools_ListOfShape& losr = BDS.ShapeSameDomain(Sref);
	256	TopTools_ListIteratorOfListOfShape liolos;
	257	liolos.Initialize(losr);
	258	while (liolos.More() ) {
	259	const TopoDS_Shape& Sh = liolos.Value();
	260	Loc = myHDS->Shape(Sh);
	261	if(Loc == i) {
	262	bb = Standard_True;
	263	break;
	264	}
	265	liolos.Next();
	266	}
	267	if(!bb) {
7fd59977	268	b = Standard_False;
	269	}
	270	}
	271	}
	272	}
	273	return b;
	274	}
	275
	276	//=======================================================================
	277	//function : CheckShapes
	278	//purpose :
	279	//=======================================================================
	280
	281	Standard_Boolean TopOpeBRepDS_Check::CheckShapes
	282	(const TopTools_ListOfShape& LS ) const
	283	{
	284	Standard_Integer index;
	285	TopTools_ListIteratorOfListOfShape it(LS);
	286	while (it.More()) {
	287	const TopoDS_Shape& itS = it.Value();
	288	index = myHDS->Shape(itS);
	289	if (!index) return Standard_False;
	290	it.Next();
	291	}
	292	return Standard_True;
	293	}
	294
	295	//=======================================================================
	296	//function : OneVertexOnPnt
	297	//purpose :
	298	//=======================================================================
	299
	300	Standard_Boolean TopOpeBRepDS_Check::OneVertexOnPnt(){
	301	Standard_Boolean b = Standard_True;
	302	// Standard_Integer i, j, k;
	303	Standard_Integer i, j;
	304	Standard_Integer Curr1, Curr2, sdr1, sdr2;
	305	Standard_Integer NbVe = 0, NbPo = myHDS->NbPoints();
	306	// Standard_Real tol, tol1, tol2, Dist;
	307	Standard_Real tol1, tol2, Dist;
	308	TColStd_IndexedMapOfInteger vert;
	309	vert.Clear();
	310	for(i = 1;i <= myHDS->NbShapes();i++) {
	311	const TopoDS_Shape& S = myHDS->Shape(i);
	312	if((S.ShapeType() == TopAbs_VERTEX) &&
	313	myHDS->HasShape(S))
	314	vert.Add(i);
	315	}
	316	NbVe = vert.Extent();
	317	for(i = 1;i <= NbVe; i++) {
	318	Curr1 = vert.FindKey(i);
	319	const TopoDS_Shape& S1 = myHDS->Shape(Curr1);
	320	sdr1 = myHDS->SameDomainReference(S1);
	321	for(j = i+1;j <= NbVe; j++) {
	322	Curr2 = vert.FindKey(j);
	323	const TopoDS_Shape& S2 = myHDS->Shape(Curr2);
	324	sdr2 = myHDS->SameDomainReference(S2);
	325	tol1 = TopOpeBRepTool_ShapeTool::Tolerance(S1);
	326	tol2 = TopOpeBRepTool_ShapeTool::Tolerance(S2);
	327	const gp_Pnt& P1 = TopOpeBRepTool_ShapeTool::Pnt(S1);
	328	const gp_Pnt& P2 = TopOpeBRepTool_ShapeTool::Pnt(S2);
	329	Dist = P1.Distance(P2);
	330	if(Dist <= tol1 + tol2) {
	331	if(sdr1 != sdr2) {
7fd59977	332	b = Standard_False;
	333	}
	334	}
	335	else if(sdr1 == sdr2) {
7fd59977	336	b = Standard_False;
	337	}
	338	}
	339	TopOpeBRepDS_PointExplorer PE(myHDS->DS());
	340	for(;PE.More(); PE.Next()) {
	341	const TopOpeBRepDS_Point& dsPnt = PE.Point();
	342	const gp_Pnt& Pnt1 = dsPnt.Point();
	343	tol1 = dsPnt.Tolerance();
	344	tol2 = TopOpeBRepTool_ShapeTool::Tolerance(S1);
	345	const gp_Pnt& Pnt2 = TopOpeBRepTool_ShapeTool::Pnt(S1);
	346	Dist = Pnt1.Distance(Pnt2);
	347	if(Dist <= tol1 + tol2) {
7fd59977	348	b = Standard_False;
	349	}
	350	}
	351	}
	352	for(i = 1;i <= NbPo; i++) {
	353	TopOpeBRepDS_PointExplorer PE(myHDS->DS());
	354	if(PE.IsPoint(i)) {
	355	const TopOpeBRepDS_Point& dsPnt1 = myHDS->Point(i);
	356	for(j = i+1;j < NbPo;j++) {
	357	const TopOpeBRepDS_Point& dsPnt2 = myHDS->Point(j);
	358	if(dsPnt1.IsEqual(dsPnt2)) {
7fd59977	359	}
	360	}
	361	}
	362	}
	363
	364	return b;
	365	}
	366
	367	//=======================================================================
	368	//function : CheckEdgeParameter
	369	//purpose :
	370	//=======================================================================
	371
	372	///Standard_Boolean TopOpeBRepDS_Check::CheckEdgeParameter() const
	373	Standard_Boolean CheckEdgeParameter(const Handle(TopOpeBRepDS_HDataStructure)& myHDS)
	374	{
	375	TopOpeBRepDS_ListIteratorOfListOfInterference it1;
	376	const TopOpeBRepDS_DataStructure& DS = myHDS->DS();
	377	Standard_Integer i,nshape = DS.NbShapes();
	378	Standard_Boolean IsOK = Standard_True;
	379	for (i = 1; i <= nshape; i++) {
	380	// Integrity of Interferences : Check parameter of EdgeInterferences
	381	const TopOpeBRepDS_ListOfInterference& LI = DS.ShapeInterferences(i);
	382	it1.Initialize(LI);
	383	while (it1.More() ) {
	384	Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
	385	Handle(TopOpeBRepDS_EdgeVertexInterference) EVI =
	386	Handle(TopOpeBRepDS_EdgeVertexInterference)::DownCast(I1);
	387	if(!EVI.IsNull()) {
7fd59977	388	Standard_Integer Param = (Standard_Integer ) EVI->Parameter();
7fd59977	389	if(Param > 1.e50) {
7fd59977	390	IsOK = Standard_False;
	391	}
	392	}
	393	it1.Next();
	394	}
	395	}
	396
	397	Standard_Integer ncurve = DS.NbCurves();
	398	for (i = 1; i <= ncurve; i++) {
	399	// Integrity of Interferences : Check parameter of CurvesInterferences
	400	const TopOpeBRepDS_ListOfInterference& LI = DS.CurveInterferences(i);
	401	it1.Initialize(LI);
	402	while (it1.More() ) {
	403	const Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
c5f3a425	404	Handle(TopOpeBRepDS_CurvePointInterference) CPI (Handle(TopOpeBRepDS_CurvePointInterference)::DownCast(I1));
7fd59977	405	if(!CPI.IsNull()) {
7fd59977	406	Standard_Integer Param =
7fd59977	407	(Standard_Integer ) TopOpeBRepDS_InterferenceTool::Parameter(CPI);
7fd59977	408	if(Param > 1.e50) {
7fd59977	409	IsOK = Standard_False;
	410	}
	411	}
	412	it1.Next();
	413	}
	414
	415	}
	416	return IsOK;
	417	}
	418
	419	//=======================================================================
	420	//function : PrintIntg
	421	//purpose :
	422	//=======================================================================
	423	Standard_OStream& TopOpeBRepDS_Check::PrintIntg(Standard_OStream& OS)
	424	{
	425	OS<<endl<<endl<<"************************************************"<<endl;
	426	OS<<"state of the DS : (only the tested elements)"<<endl<<endl;
	427
	428	//Display of the geometry
	429	PrintMap(myMapSurfaceStatus, "Surface", OS);
	430	PrintMap(myMapCurveStatus, "Curve", OS);
	431	PrintMap(myMapPointStatus, "Point", OS);
	432
	433	//display of the topology
	434	TopOpeBRepDS_DataMapIteratorOfDataMapOfCheckStatus DMI(myMapShapeStatus);
	435	TopOpeBRepDS_DataMapOfCheckStatus MapVertex, MapEdge, MapWire, MapFace, MapSolid;
	436	Standard_Integer i;
	437	// different Map keep their index of myMapShapeStatus
	438	for(DMI.Reset();DMI.More();DMI.Next()) {
	439	i = DMI.Key();
	440	const TopoDS_Shape& S =myHDS->Shape(i);
	441	switch(S.ShapeType()) {
	442	case TopAbs_VERTEX: MapVertex.Bind(i, DMI.Value()); break;
	443	case TopAbs_EDGE: MapEdge.Bind(i, DMI.Value()); break;
	444	case TopAbs_WIRE: MapWire.Bind(i, DMI.Value()); break;
	445	case TopAbs_FACE: MapFace.Bind(i, DMI.Value()); break;
	446	case TopAbs_SOLID: MapSolid.Bind(i, DMI.Value()); break;
	447	default:
	448	break ;
	449	}
	450	}
	451
	452	PrintMap(MapVertex, "Vertex", OS);
	453	PrintMap(MapEdge, "Edge", OS);
	454	PrintMap(MapWire, "Wire", OS);
	455	PrintMap(MapFace, "Face", OS);
	456	PrintMap(MapSolid, "Solid", OS);
	457
	458	OS<<endl<<endl;
	459	return OS;
	460	}
	461
	462	//=======================================================================
	463	//function : PrintMap
	464	//purpose :
	465	//=======================================================================
	466
	467	Standard_OStream& TopOpeBRepDS_Check::PrintMap(TopOpeBRepDS_DataMapOfCheckStatus& MapStat,
	468	const Standard_CString eltstr,
	469	Standard_OStream& OS)
	470	{
	471	TopOpeBRepDS_DataMapIteratorOfDataMapOfCheckStatus DMI(MapStat);
	472	DMI.Initialize(MapStat);
473	if(DMI.More()) {
474	Standard_Boolean b = Standard_True;
586db386	475	OS<<" "<<eltstr<<"\t(/"<<MapStat.Extent()<<")\tnumber ";
7fd59977	476
	477	PrintElts(MapStat, TopOpeBRepDS_OK, b, OS);
	478	if(!b) OS<<" = OK"<<endl;
	479	PrintElts(MapStat, TopOpeBRepDS_NOK, b, OS);
	480	if(!b) OS<<" = NOK"<<endl;
	481	}
	482	return OS;
	483	}
	484
	485	//=======================================================================
	486	//function : PrintElts
	487	//purpose : Print the elements in the state stat of MapStat
	488	//=======================================================================
	489	Standard_OStream& TopOpeBRepDS_Check::PrintElts(TopOpeBRepDS_DataMapOfCheckStatus& MapStat,
	490	const TopOpeBRepDS_CheckStatus Stat,
	491	Standard_Boolean& b,
	492	Standard_OStream& OS)
	493	{
	494	TopOpeBRepDS_DataMapIteratorOfDataMapOfCheckStatus DMI(MapStat);
	495	Standard_Boolean bb = !b;
	496	b = Standard_True;
	497	Standard_Integer i;
	498	TopOpeBRepDS_CheckStatus s;
	499	for(DMI.Reset();DMI.More();DMI.Next()) {
	500	s = DMI.Value();
	501	i = DMI.Key();
	502	if(s == Stat) {
	503	if(b) b=!b;
	504	if(bb){OS<<"\t\tnumber ";bb=!bb;}
	505	OS<<i<<" ";
	506	}
	507	}
	508	return OS;
	509	}
	510
	511	//=======================================================================
	512	//function : Print
	513	//purpose :
	514	//=======================================================================
	515	Standard_OStream& TopOpeBRepDS_Check::Print
	516	(const TopOpeBRepDS_CheckStatus stat,
	517	Standard_OStream& OS)
	518	{
	519	switch(stat) {
	520	case TopOpeBRepDS_OK: OS<<"OK";break;
	521	case TopOpeBRepDS_NOK: OS<<"NOK";break;
	522	default : break;
	523	}
	524	return OS;
	525	}
	526
	527	//=======================================================================
	528	//function : PrintShape
	529	//purpose :
	530	//=======================================================================
	531	Standard_OStream& TopOpeBRepDS_Check::PrintShape
	532	(const TopAbs_ShapeEnum SE,
	533	Standard_OStream& OS)
	534	{
	535	switch(SE) {
	536	case TopAbs_SOLID : OS<<"Solid "; break;
	537	case TopAbs_SHELL : OS<<"Shell "; break;
	538	case TopAbs_FACE : OS<<"Face "; break;
	539	case TopAbs_WIRE : OS<<"Wire "; break;
540	case TopAbs_EDGE : OS<<"Edge "; break;
541	case TopAbs_VERTEX : OS<<"Vertex"; break;
542	default:
543	break ;
544	}
545	return OS;
546	}
547
548	//=======================================================================
549	//function : PrintShape
550	//purpose :
551	//=======================================================================
552	Standard_OStream& TopOpeBRepDS_Check::PrintShape
553	(const Standard_Integer index,
554	Standard_OStream& OS)
555	{
556	if(myHDS->NbShapes() < index) {
557	OS<<"PBINTopOpeBRepDS_Check::PrintShape ";
558	return OS;
559	}
560	if(!myMapShapeStatus.IsBound(index)) {
561	OS<<"NO CHECK HAS PROCESSING"<<endl;
562	return OS;
563	}
564	OS<<" ";
536a3cb8	565	myHDS->Shape(index);
536a3cb8	566
7fd59977	567	return OS;
	568	}
	569
	570	//=======================================================================
	571	//function : HDS
	572	//purpose :
	573	//=======================================================================
	574
	575	const Handle(TopOpeBRepDS_HDataStructure)& TopOpeBRepDS_Check::HDS()const
	576	{
	577	return myHDS;
	578	}
	579
	580
	581	//=======================================================================
	582	//function : ChangeHDS
	583	//purpose :
	584	//=======================================================================
	585
	586	Handle(TopOpeBRepDS_HDataStructure)& TopOpeBRepDS_Check::ChangeHDS()
	587	{
	588	return myHDS;
	589	}