[occt.git] / src / BRepCheck / BRepCheck_Analyzer.cxx

// Created on: 1995-12-08
// Created by: Jacques GOUSSARD
// Copyright (c) 1995-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 <BRepCheck_Analyzer.ixx>

#include <BRepCheck_Vertex.hxx>
#include <BRepCheck_Edge.hxx>
#include <BRepCheck_Wire.hxx>
#include <BRepCheck_Face.hxx>
#include <BRepCheck_Shell.hxx>
#include <BRepCheck_ListIteratorOfListOfStatus.hxx>

#include <TopoDS_Iterator.hxx>
#include <TopExp_Explorer.hxx>

#include <TopTools_MapOfShape.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>

#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>

//=======================================================================
//function : Init
//purpose  : 
//=======================================================================

void BRepCheck_Analyzer::Init(const TopoDS_Shape& S,
			      const Standard_Boolean B)
{
  if (S.IsNull()) {
    Standard_NullObject::Raise();
  }
  myShape = S;
  myMap.Clear();
  Put(S,B);
  Perform(S);
}


//=======================================================================
//function : Put
//purpose  : 
//=======================================================================

void BRepCheck_Analyzer::Put(const TopoDS_Shape& S,
			     const Standard_Boolean B)
{
  if (!myMap.IsBound(S)) {
    Handle(BRepCheck_Result) HR;
    switch (S.ShapeType()) {
    case TopAbs_VERTEX:
      HR = new BRepCheck_Vertex(TopoDS::Vertex(S));
      break;
    case TopAbs_EDGE:
      HR = new BRepCheck_Edge(TopoDS::Edge(S));
      Handle(BRepCheck_Edge)::DownCast(HR)->GeometricControls(B);
      break;
    case TopAbs_WIRE:
      HR = new BRepCheck_Wire(TopoDS::Wire(S));
      Handle(BRepCheck_Wire)::DownCast(HR)->GeometricControls(B);
      break;
    case TopAbs_FACE:
      HR = new BRepCheck_Face(TopoDS::Face(S));
      Handle(BRepCheck_Face)::DownCast(HR)->GeometricControls(B);
      break;
    case TopAbs_SHELL:
      HR = new BRepCheck_Shell(TopoDS::Shell(S));
      break;
    case TopAbs_SOLID:
    case TopAbs_COMPSOLID:
    case TopAbs_COMPOUND:
      break;
    default:
      break;
    }
    myMap.Bind(S,HR);
    for(TopoDS_Iterator theIterator(S);theIterator.More();theIterator.Next()) {
      Put(theIterator.Value(),B); // performs minimum on each shape
    }
  }
}


//=======================================================================
//function : Perform
//purpose  : 
//=======================================================================

void BRepCheck_Analyzer::Perform(const TopoDS_Shape& S)
{
  for(TopoDS_Iterator theIterator(S);theIterator.More();theIterator.Next()) {
    Perform(theIterator.Value());
  }
  //
  TopAbs_ShapeEnum styp;
  TopExp_Explorer exp;
  //
  styp = S.ShapeType();
  switch (styp) {
  case TopAbs_VERTEX: 
    // modified by NIZHNY-MKK  Wed May 19 16:56:16 2004.BEGIN
    // There is no need to check anything.
    //       if (myShape.IsSame(S)) {
    // 	myMap(S)->Blind();
    //       }
    // modified by NIZHNY-MKK  Wed May 19 16:56:23 2004.END
  
    break;
  case TopAbs_EDGE:    {
    //  Modified by skv - Tue Apr 27 11:38:08 2004 Begin
    // There is no need to check anything except vertices on single edge.
    //       if (myShape.IsSame(S)) {
    // 	myMap(S)->Blind();
    //       }
    //  Modified by skv - Tue Apr 27 11:38:09 2004 End
    TopTools_MapOfShape MapS;
    
    for (exp.Init(S,TopAbs_VERTEX);exp.More(); exp.Next()) {
      const TopoDS_Shape& aVertex = exp.Current();
      try {
	OCC_CATCH_SIGNALS
	if (MapS.Add(aVertex)) {
	  myMap(aVertex)->InContext(S);
	}
      }
      catch(Standard_Failure) {
#ifdef DEB
	cout<<"BRepCheck_Analyzer : ";
	Standard_Failure::Caught()->Print(cout);  
	cout<<endl;
#endif
	if ( ! myMap(S).IsNull() ) {
	  myMap(S)->SetFailStatus(S);
	}
	Handle(BRepCheck_Result) aRes = myMap(aVertex);
	if ( ! aRes.IsNull() ) {
	  aRes->SetFailStatus(aVertex);
	  aRes->SetFailStatus(S);
	}
      }
    }
    }
    break;
  case TopAbs_WIRE:
    //  Modified by Sergey KHROMOV - Mon May  6 15:53:39 2002 Begin
    // There is no need to check the orientation of a single wire 
    // (not in context of face).
    //     {
    //       if (myShape.IsSame(S)) {
    // 	Handle(BRepCheck_Wire)::DownCast(myMap(S))->Orientation(TopoDS_Face(),
    // 								Standard_True);
    //       }
    //     }
    //  Modified by Sergey KHROMOV - Mon May  6 15:53:40 2002 End
    break;
  case TopAbs_FACE:
    {
      TopTools_MapOfShape MapS;
      for (exp.Init(S,TopAbs_VERTEX);exp.More(); exp.Next()) {
	try {
	  OCC_CATCH_SIGNALS
	  if (MapS.Add(exp.Current())) {
	    myMap(exp.Current())->InContext(S);
	  }
	}
	catch(Standard_Failure) {
#ifdef DEB
	  cout<<"BRepCheck_Analyzer : ";
	  Standard_Failure::Caught()->Print(cout);  
	  cout<<endl;
#endif
	  if ( ! myMap(S).IsNull() ) {
	    myMap(S)->SetFailStatus(S);
	  }
	  Handle(BRepCheck_Result) aRes = myMap(exp.Current());

	  if ( ! aRes.IsNull() ) {
	    aRes->SetFailStatus(exp.Current());
	    aRes->SetFailStatus(S);
	  }
	}
      }
      Standard_Boolean performwire = Standard_True;
      MapS.Clear();
      for (exp.Init(S,TopAbs_EDGE);exp.More(); exp.Next()) {
	try {
	  OCC_CATCH_SIGNALS
	  if (MapS.Add(exp.Current())) {
	    Handle(BRepCheck_Result)& res = myMap(exp.Current());
	    res->InContext(S);
	    if (performwire) {
	      for (res->InitContextIterator();
		   res->MoreShapeInContext();
		   res->NextShapeInContext()) {
		if(res->ContextualShape().IsSame(S)) {
		  break;
		}
	      }
	      BRepCheck_ListIteratorOfListOfStatus itl(res->StatusOnShape());
	      for (; itl.More(); itl.Next()) {
		BRepCheck_Status ste = itl.Value();
		if (ste == BRepCheck_NoCurveOnSurface  ||
		    ste == BRepCheck_InvalidCurveOnSurface ||
		    ste == BRepCheck_InvalidRange ||
		    ste == BRepCheck_InvalidCurveOnClosedSurface) {
		  performwire = Standard_False;
		  break;
		}
	      }
	    }
	  }
	}
	catch(Standard_Failure) {
#ifdef DEB
	  cout<<"BRepCheck_Analyzer : ";
	  Standard_Failure::Caught()->Print(cout);  
	  cout<<endl;
#endif

	  if ( ! myMap(S).IsNull() ) {
	    myMap(S)->SetFailStatus(S);
	  }
	  Handle(BRepCheck_Result) aRes = myMap(exp.Current());

	  if ( ! aRes.IsNull() ) {
	    aRes->SetFailStatus(exp.Current());
	    aRes->SetFailStatus(S);
	  }
	}
      }
      Standard_Boolean orientofwires = performwire;
      for (exp.Init(S,TopAbs_WIRE);exp.More(); exp.Next()) {
	try {
	  OCC_CATCH_SIGNALS
	  Handle(BRepCheck_Result)& res = myMap(exp.Current());
	  res->InContext(S);
	  if (orientofwires) {
	    for (res->InitContextIterator();
		 res->MoreShapeInContext();
		 res->NextShapeInContext()) {
	      if(res->ContextualShape().IsSame(S)) {
		break;
	      }
	    }
	    BRepCheck_ListIteratorOfListOfStatus itl(res->StatusOnShape());
	    for (; itl.More(); itl.Next()) {
	      BRepCheck_Status ste = itl.Value();
	      if (ste != BRepCheck_NoError) {
		orientofwires = Standard_False;
		break;
	      }
	    }
	  }	  
	}
	catch(Standard_Failure) {
#ifdef DEB
	  cout<<"BRepCheck_Analyzer : ";
	  Standard_Failure::Caught()->Print(cout);  
	  cout<<endl;
#endif
	  if ( ! myMap(S).IsNull() ) {
	    myMap(S)->SetFailStatus(S);
	  }
	  Handle(BRepCheck_Result) aRes = myMap(exp.Current());

	  if ( ! aRes.IsNull() ) {
	    aRes->SetFailStatus(exp.Current());
	    aRes->SetFailStatus(S);
	  }
	}
      }
      
      try {
        OCC_CATCH_SIGNALS
	if (performwire) {
	  if (orientofwires) {
	    Handle(BRepCheck_Face)::DownCast(myMap(S))->
	      OrientationOfWires(Standard_True);// on enregistre
	  }
	  //	else {
	  //	   Handle(BRepCheck_Face)::DownCast(myMap(S))->
	  //	      IntersectWires(Standard_True); // on enregistre
	  //      }
	  else {
	    Handle(BRepCheck_Face)::DownCast(myMap(S))->SetUnorientable();
	  }
	}
	else {
	  Handle(BRepCheck_Face)::DownCast(myMap(S))->SetUnorientable();
	}
      }
      catch(Standard_Failure) {
#ifdef DEB
	  cout<<"BRepCheck_Analyzer : ";
	  Standard_Failure::Caught()->Print(cout);  
	  cout<<endl;
#endif

	if ( ! myMap(S).IsNull() ) {
	  myMap(S)->SetFailStatus(S);
	}
	
	for (exp.Init(S,TopAbs_WIRE);exp.More(); exp.Next()) {
	  Handle(BRepCheck_Result) aRes = myMap(exp.Current());

	  if ( ! aRes.IsNull() ) {
	    aRes->SetFailStatus(exp.Current());
	    aRes->SetFailStatus(S);
	    myMap(S)->SetFailStatus(exp.Current());
	  }
	}
      }
    }
    break;
    
  case TopAbs_SHELL:   
    //modified by NIZNHY-PKV Mon Oct 13 14:23:53 2008f
    /* {
    Standard_Boolean VerifyOrientation, bFlag;
    //
    VerifyOrientation = Standard_True;
    //
    exp.Init(S,TopAbs_FACE);
    for (; exp.More(); exp.Next()) {
      const TopoDS_Shape& aF=exp.Current();
      try {
	OCC_CATCH_SIGNALS
	bFlag=  !(Handle(BRepCheck_Face)::DownCast(myMap(aF))->IsUnorientable());
	VerifyOrientation = (VerifyOrientation && bFlag);
      }
      catch(Standard_Failure) {
#ifdef DEB
	cout<<"BRepCheck_Analyzer : ";
	Standard_Failure::Caught()->Print(cout);  
	cout<<endl;
#endif
	
	if ( ! myMap(S).IsNull() ) {
	  myMap(S)->SetFailStatus(S);
	}
	Handle(BRepCheck_Result) aRes = myMap(exp.Current());
	
	if ( ! aRes.IsNull() ) {
	  aRes->SetFailStatus(exp.Current());
	  aRes->SetFailStatus(S);
	}
      }
    } // 
    try {
      OCC_CATCH_SIGNALS
      if (VerifyOrientation) {
	Handle(BRepCheck_Shell)::DownCast(myMap(S))->Orientation(Standard_True);
      }
      else {
	Handle(BRepCheck_Shell)::DownCast(myMap(S))->SetUnorientable();
      }
    }
    catch(Standard_Failure) {
#ifdef DEB
      cout<<"BRepCheck_Analyzer : ";
      Standard_Failure::Caught()->Print(cout);  
      cout<<endl;
#endif
      
      if ( ! myMap(S).IsNull() ) {
	myMap(S)->SetFailStatus(S);
      }
      exp.Init(S,TopAbs_FACE);
      for (; exp.More(); exp.Next()) {
	Handle(BRepCheck_Result) aRes = myMap(exp.Current());
	if ( ! aRes.IsNull() ) {
	  aRes->SetFailStatus(exp.Current());
	  aRes->SetFailStatus(S);
	  myMap(S)->SetFailStatus(exp.Current());
	}
      }
    }
  }
  */
    //modified by NIZNHY-PKV Mon Oct 13 14:24:04 2008t
    break;
    //
  case TopAbs_SOLID:    {
    exp.Init(S,TopAbs_SHELL);
    for (; exp.More(); exp.Next()) {
      const TopoDS_Shape& aShell=exp.Current();
      try {
	OCC_CATCH_SIGNALS
	myMap(aShell)->InContext(S);
      }
      catch(Standard_Failure) {
#ifdef DEB
	cout<<"BRepCheck_Analyzer : ";
	Standard_Failure::Caught()->Print(cout);  
	cout<<endl;
#endif
	if ( ! myMap(S).IsNull() ) {
	  myMap(S)->SetFailStatus(S);
	}
	//
	Handle(BRepCheck_Result) aRes = myMap(aShell);
	if (!aRes.IsNull() ) {
	  aRes->SetFailStatus(exp.Current());
	  aRes->SetFailStatus(S);
	}
      }
    }
  }
  break;//case TopAbs_SOLID
  default:
    break;
  }//switch (styp) {
}


//=======================================================================
//function : IsValid
//purpose  : 
//=======================================================================

Standard_Boolean BRepCheck_Analyzer::IsValid(const TopoDS_Shape& S) const
{
  if (!myMap(S).IsNull()) {
    BRepCheck_ListIteratorOfListOfStatus itl;
    itl.Initialize(myMap(S)->Status());
    if (itl.Value() != BRepCheck_NoError) { // a voir
      return Standard_False;
    }
  }

  for(TopoDS_Iterator theIterator(S);theIterator.More();theIterator.Next()) {
    if (!IsValid(theIterator.Value())) {
      return Standard_False;
    }
  }

  switch (S.ShapeType()) {
  case TopAbs_EDGE:
    {
      return ValidSub(S,TopAbs_VERTEX);
    }
//    break;
  case TopAbs_FACE:
    {
      Standard_Boolean valid = ValidSub(S,TopAbs_WIRE);
      valid = valid && ValidSub(S,TopAbs_EDGE);
      valid = valid && ValidSub(S,TopAbs_VERTEX);
      return valid;
    }

//    break;
  case TopAbs_SHELL:
//    return ValidSub(S,TopAbs_FACE);
    break;
  case TopAbs_SOLID:
//    return ValidSub(S,TopAbs_EDGE);
//    break;
    return ValidSub(S,TopAbs_SHELL);
    break;
  default:
    break;
  }

  return Standard_True;
}

//=======================================================================
//function : ValidSub
//purpose  : 
//=======================================================================

Standard_Boolean BRepCheck_Analyzer::ValidSub
   (const TopoDS_Shape& S,
    const TopAbs_ShapeEnum SubType) const
{
  BRepCheck_ListIteratorOfListOfStatus itl;
  TopExp_Explorer exp;
  for (exp.Init(S,SubType);exp.More(); exp.Next()) {
//  for (TopExp_Explorer exp(S,SubType);exp.More(); exp.Next()) {
    const Handle(BRepCheck_Result)& RV = myMap(exp.Current());
    for (RV->InitContextIterator();
	 RV->MoreShapeInContext(); 
	 RV->NextShapeInContext()) {
      if (RV->ContextualShape().IsSame(S)) {
	break;
      }
    }

    if(!RV->MoreShapeInContext()) break;

    for (itl.Initialize(RV->StatusOnShape()); itl.More(); itl.Next()) {
      if (itl.Value() != BRepCheck_NoError) {
	return Standard_False;
      }
    }
  }
  return Standard_True ;
}
Commit	Line	Data
b311480e	1	// Created on: 1995-12-08
	2	// Created by: Jacques GOUSSARD
	3	// Copyright (c) 1995-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
	17	#include <BRepCheck_Analyzer.ixx>
	18
	19	#include <BRepCheck_Vertex.hxx>
	20	#include <BRepCheck_Edge.hxx>
	21	#include <BRepCheck_Wire.hxx>
	22	#include <BRepCheck_Face.hxx>
	23	#include <BRepCheck_Shell.hxx>
	24	#include <BRepCheck_ListIteratorOfListOfStatus.hxx>
	25
	26	#include <TopoDS_Iterator.hxx>
	27	#include <TopExp_Explorer.hxx>
	28
	29	#include <TopTools_MapOfShape.hxx>
	30	#include <TopoDS.hxx>
	31	#include <TopoDS_Face.hxx>
	32
	33	#include <Standard_ErrorHandler.hxx>
	34	#include <Standard_Failure.hxx>
	35
	36	//=======================================================================
	37	//function : Init
	38	//purpose :
	39	//=======================================================================
	40
	41	void BRepCheck_Analyzer::Init(const TopoDS_Shape& S,
	42	const Standard_Boolean B)
	43	{
	44	if (S.IsNull()) {
	45	Standard_NullObject::Raise();
	46	}
	47	myShape = S;
	48	myMap.Clear();
	49	Put(S,B);
	50	Perform(S);
	51	}
	52
	53
	54
	55	//=======================================================================
	56	//function : Put
	57	//purpose :
	58	//=======================================================================
	59
	60	void BRepCheck_Analyzer::Put(const TopoDS_Shape& S,
	61	const Standard_Boolean B)
	62	{
	63	if (!myMap.IsBound(S)) {
	64	Handle(BRepCheck_Result) HR;
	65	switch (S.ShapeType()) {
	66	case TopAbs_VERTEX:
	67	HR = new BRepCheck_Vertex(TopoDS::Vertex(S));
	68	break;
	69	case TopAbs_EDGE:
	70	HR = new BRepCheck_Edge(TopoDS::Edge(S));
	71	Handle(BRepCheck_Edge)::DownCast(HR)->GeometricControls(B);
	72	break;
	73	case TopAbs_WIRE:
	74	HR = new BRepCheck_Wire(TopoDS::Wire(S));
	75	Handle(BRepCheck_Wire)::DownCast(HR)->GeometricControls(B);
	76	break;
	77	case TopAbs_FACE:
	78	HR = new BRepCheck_Face(TopoDS::Face(S));
	79	Handle(BRepCheck_Face)::DownCast(HR)->GeometricControls(B);
80	break;
81	case TopAbs_SHELL:
82	HR = new BRepCheck_Shell(TopoDS::Shell(S));
83	break;
84	case TopAbs_SOLID:
85	case TopAbs_COMPSOLID:
86	case TopAbs_COMPOUND:
87	break;
7fd59977	88	default:
7fd59977	89	break;
7fd59977	90	}
	91	myMap.Bind(S,HR);
	92	for(TopoDS_Iterator theIterator(S);theIterator.More();theIterator.Next()) {
	93	Put(theIterator.Value(),B); // performs minimum on each shape
	94	}
	95	}
	96	}
	97
	98
	99	//=======================================================================
	100	//function : Perform
	101	//purpose :
	102	//=======================================================================
	103
	104	void BRepCheck_Analyzer::Perform(const TopoDS_Shape& S)
	105	{
	106	for(TopoDS_Iterator theIterator(S);theIterator.More();theIterator.Next()) {
	107	Perform(theIterator.Value());
	108	}
	109	//
	110	TopAbs_ShapeEnum styp;
	111	TopExp_Explorer exp;
	112	//
	113	styp = S.ShapeType();
	114	switch (styp) {
	115	case TopAbs_VERTEX:
	116	// modified by NIZHNY-MKK Wed May 19 16:56:16 2004.BEGIN
	117	// There is no need to check anything.
	118	// if (myShape.IsSame(S)) {
	119	// myMap(S)->Blind();
	120	// }
	121	// modified by NIZHNY-MKK Wed May 19 16:56:23 2004.END
	122
	123	break;
	124	case TopAbs_EDGE: {
	125	// Modified by skv - Tue Apr 27 11:38:08 2004 Begin
	126	// There is no need to check anything except vertices on single edge.
	127	// if (myShape.IsSame(S)) {
	128	// myMap(S)->Blind();
	129	// }
	130	// Modified by skv - Tue Apr 27 11:38:09 2004 End
	131	TopTools_MapOfShape MapS;
	132
	133	for (exp.Init(S,TopAbs_VERTEX);exp.More(); exp.Next()) {
	134	const TopoDS_Shape& aVertex = exp.Current();
	135	try {
	136	OCC_CATCH_SIGNALS
	137	if (MapS.Add(aVertex)) {
	138	myMap(aVertex)->InContext(S);
	139	}
	140	}
	141	catch(Standard_Failure) {
	142	#ifdef DEB
	143	cout<<"BRepCheck_Analyzer : ";
	144	Standard_Failure::Caught()->Print(cout);
	145	cout<<endl;
	146	#endif
	147	if ( ! myMap(S).IsNull() ) {
	148	myMap(S)->SetFailStatus(S);
	149	}
	150	Handle(BRepCheck_Result) aRes = myMap(aVertex);
	151	if ( ! aRes.IsNull() ) {
	152	aRes->SetFailStatus(aVertex);
	153	aRes->SetFailStatus(S);
154	}
155	}
156	}
157	}
158	break;
159	case TopAbs_WIRE:
160	// Modified by Sergey KHROMOV - Mon May 6 15:53:39 2002 Begin
161	// There is no need to check the orientation of a single wire
162	// (not in context of face).
163	// {
164	// if (myShape.IsSame(S)) {
165	// Handle(BRepCheck_Wire)::DownCast(myMap(S))->Orientation(TopoDS_Face(),
166	// Standard_True);
167	// }
168	// }
169	// Modified by Sergey KHROMOV - Mon May 6 15:53:40 2002 End
170	break;
171	case TopAbs_FACE:
172	{
173	TopTools_MapOfShape MapS;
174	for (exp.Init(S,TopAbs_VERTEX);exp.More(); exp.Next()) {
175	try {
176	OCC_CATCH_SIGNALS
177	if (MapS.Add(exp.Current())) {
178	myMap(exp.Current())->InContext(S);
179	}
180	}
181	catch(Standard_Failure) {
182	#ifdef DEB
183	cout<<"BRepCheck_Analyzer : ";
184	Standard_Failure::Caught()->Print(cout);
185	cout<<endl;
186	#endif
187	if ( ! myMap(S).IsNull() ) {
188	myMap(S)->SetFailStatus(S);
189	}
190	Handle(BRepCheck_Result) aRes = myMap(exp.Current());
191
192	if ( ! aRes.IsNull() ) {
193	aRes->SetFailStatus(exp.Current());
194	aRes->SetFailStatus(S);
195	}
196	}
197	}
198	Standard_Boolean performwire = Standard_True;
199	MapS.Clear();
200	for (exp.Init(S,TopAbs_EDGE);exp.More(); exp.Next()) {
201	try {
202	OCC_CATCH_SIGNALS
203	if (MapS.Add(exp.Current())) {
204	Handle(BRepCheck_Result)& res = myMap(exp.Current());
205	res->InContext(S);
206	if (performwire) {
207	for (res->InitContextIterator();
208	res->MoreShapeInContext();
209	res->NextShapeInContext()) {
210	if(res->ContextualShape().IsSame(S)) {
211	break;
212	}
213	}
214	BRepCheck_ListIteratorOfListOfStatus itl(res->StatusOnShape());
215	for (; itl.More(); itl.Next()) {
216	BRepCheck_Status ste = itl.Value();
217	if (ste == BRepCheck_NoCurveOnSurface \|\|
218	ste == BRepCheck_InvalidCurveOnSurface \|\|
219	ste == BRepCheck_InvalidRange \|\|
220	ste == BRepCheck_InvalidCurveOnClosedSurface) {
221	performwire = Standard_False;
222	break;
223	}
224	}
225	}
226	}
227	}
228	catch(Standard_Failure) {
229	#ifdef DEB
230	cout<<"BRepCheck_Analyzer : ";
231	Standard_Failure::Caught()->Print(cout);
232	cout<<endl;
233	#endif
234
235	if ( ! myMap(S).IsNull() ) {
236	myMap(S)->SetFailStatus(S);
237	}
238	Handle(BRepCheck_Result) aRes = myMap(exp.Current());
239
240	if ( ! aRes.IsNull() ) {
241	aRes->SetFailStatus(exp.Current());
242	aRes->SetFailStatus(S);
243	}
244	}
245	}
246	Standard_Boolean orientofwires = performwire;
247	for (exp.Init(S,TopAbs_WIRE);exp.More(); exp.Next()) {
248	try {
249	OCC_CATCH_SIGNALS
250	Handle(BRepCheck_Result)& res = myMap(exp.Current());
251	res->InContext(S);
252	if (orientofwires) {
253	for (res->InitContextIterator();
254	res->MoreShapeInContext();
255	res->NextShapeInContext()) {
256	if(res->ContextualShape().IsSame(S)) {
257	break;
258	}
259	}
260	BRepCheck_ListIteratorOfListOfStatus itl(res->StatusOnShape());
261	for (; itl.More(); itl.Next()) {
262	BRepCheck_Status ste = itl.Value();
263	if (ste != BRepCheck_NoError) {
264	orientofwires = Standard_False;
265	break;
266	}
267	}
268	}
269	}
270	catch(Standard_Failure) {
271	#ifdef DEB
272	cout<<"BRepCheck_Analyzer : ";
273	Standard_Failure::Caught()->Print(cout);
274	cout<<endl;
275	#endif
276	if ( ! myMap(S).IsNull() ) {
277	myMap(S)->SetFailStatus(S);
278	}
279	Handle(BRepCheck_Result) aRes = myMap(exp.Current());
280
281	if ( ! aRes.IsNull() ) {
282	aRes->SetFailStatus(exp.Current());
283	aRes->SetFailStatus(S);
284	}
285	}
286	}
287
288	try {
289	OCC_CATCH_SIGNALS
290	if (performwire) {
291	if (orientofwires) {
292	Handle(BRepCheck_Face)::DownCast(myMap(S))->
293	OrientationOfWires(Standard_True);// on enregistre
294	}
295	// else {
296	// Handle(BRepCheck_Face)::DownCast(myMap(S))->
297	// IntersectWires(Standard_True); // on enregistre
298	// }
299	else {
300	Handle(BRepCheck_Face)::DownCast(myMap(S))->SetUnorientable();
301	}
302	}
303	else {
304	Handle(BRepCheck_Face)::DownCast(myMap(S))->SetUnorientable();
305	}
306	}
307	catch(Standard_Failure) {
308	#ifdef DEB
309	cout<<"BRepCheck_Analyzer : ";
310	Standard_Failure::Caught()->Print(cout);
311	cout<<endl;
312	#endif
313
314	if ( ! myMap(S).IsNull() ) {
315	myMap(S)->SetFailStatus(S);
316	}
317
318	for (exp.Init(S,TopAbs_WIRE);exp.More(); exp.Next()) {
319	Handle(BRepCheck_Result) aRes = myMap(exp.Current());
320
321	if ( ! aRes.IsNull() ) {
322	aRes->SetFailStatus(exp.Current());
323	aRes->SetFailStatus(S);
324	myMap(S)->SetFailStatus(exp.Current());
325	}
326	}
327	}
328	}
329	break;
330
331	case TopAbs_SHELL:
332	//modified by NIZNHY-PKV Mon Oct 13 14:23:53 2008f
333	/* {
334	Standard_Boolean VerifyOrientation, bFlag;
335	//
336	VerifyOrientation = Standard_True;
337	//
338	exp.Init(S,TopAbs_FACE);
339	for (; exp.More(); exp.Next()) {
340	const TopoDS_Shape& aF=exp.Current();
341	try {
342	OCC_CATCH_SIGNALS
343	bFlag= !(Handle(BRepCheck_Face)::DownCast(myMap(aF))->IsUnorientable());
344	VerifyOrientation = (VerifyOrientation && bFlag);
345	}
346	catch(Standard_Failure) {
347	#ifdef DEB
348	cout<<"BRepCheck_Analyzer : ";
349	Standard_Failure::Caught()->Print(cout);
350	cout<<endl;
351	#endif
352
353	if ( ! myMap(S).IsNull() ) {
354	myMap(S)->SetFailStatus(S);
355	}
356	Handle(BRepCheck_Result) aRes = myMap(exp.Current());
357
358	if ( ! aRes.IsNull() ) {
359	aRes->SetFailStatus(exp.Current());
360	aRes->SetFailStatus(S);
361	}
362	}
363	} //
364	try {
365	OCC_CATCH_SIGNALS
366	if (VerifyOrientation) {
367	Handle(BRepCheck_Shell)::DownCast(myMap(S))->Orientation(Standard_True);
368	}
369	else {
370	Handle(BRepCheck_Shell)::DownCast(myMap(S))->SetUnorientable();
371	}
372	}
373	catch(Standard_Failure) {
374	#ifdef DEB
375	cout<<"BRepCheck_Analyzer : ";
376	Standard_Failure::Caught()->Print(cout);
377	cout<<endl;
378	#endif
379
380	if ( ! myMap(S).IsNull() ) {
381	myMap(S)->SetFailStatus(S);
382	}
383	exp.Init(S,TopAbs_FACE);
384	for (; exp.More(); exp.Next()) {
385	Handle(BRepCheck_Result) aRes = myMap(exp.Current());
386	if ( ! aRes.IsNull() ) {
387	aRes->SetFailStatus(exp.Current());
388	aRes->SetFailStatus(S);
389	myMap(S)->SetFailStatus(exp.Current());
390	}
391	}
392	}
393	}
394	*/
395	//modified by NIZNHY-PKV Mon Oct 13 14:24:04 2008t
396	break;
397	//
398	case TopAbs_SOLID: {
399	exp.Init(S,TopAbs_SHELL);
400	for (; exp.More(); exp.Next()) {
401	const TopoDS_Shape& aShell=exp.Current();
402	try {
403	OCC_CATCH_SIGNALS
404	myMap(aShell)->InContext(S);
405	}
406	catch(Standard_Failure) {
407	#ifdef DEB
408	cout<<"BRepCheck_Analyzer : ";
409	Standard_Failure::Caught()->Print(cout);
410	cout<<endl;
411	#endif
412	if ( ! myMap(S).IsNull() ) {
413	myMap(S)->SetFailStatus(S);
414	}
415	//
416	Handle(BRepCheck_Result) aRes = myMap(aShell);
417	if (!aRes.IsNull() ) {
418	aRes->SetFailStatus(exp.Current());
419	aRes->SetFailStatus(S);
420	}
421	}
422	}
423	}
424	break;//case TopAbs_SOLID
425	default:
426	break;
427	}//switch (styp) {
428	}
429
430
431	//=======================================================================
432	//function : IsValid
433	//purpose :
434	//=======================================================================
435
436	Standard_Boolean BRepCheck_Analyzer::IsValid(const TopoDS_Shape& S) const
437	{
438	if (!myMap(S).IsNull()) {
439	BRepCheck_ListIteratorOfListOfStatus itl;
440	itl.Initialize(myMap(S)->Status());
441	if (itl.Value() != BRepCheck_NoError) { // a voir
442	return Standard_False;
443	}
444	}
445
446	for(TopoDS_Iterator theIterator(S);theIterator.More();theIterator.Next()) {
447	if (!IsValid(theIterator.Value())) {
448	return Standard_False;
449	}
450	}
451
452	switch (S.ShapeType()) {
453	case TopAbs_EDGE:
454	{
455	return ValidSub(S,TopAbs_VERTEX);
456	}
457	// break;
458	case TopAbs_FACE:
459	{
460	Standard_Boolean valid = ValidSub(S,TopAbs_WIRE);
461	valid = valid && ValidSub(S,TopAbs_EDGE);
462	valid = valid && ValidSub(S,TopAbs_VERTEX);
463	return valid;
464	}
465
466	// break;
467	case TopAbs_SHELL:
468	// return ValidSub(S,TopAbs_FACE);
469	break;
470	case TopAbs_SOLID:
471	// return ValidSub(S,TopAbs_EDGE);
472	// break;
473	return ValidSub(S,TopAbs_SHELL);
474	break;
475	default:
476	break;
477	}
478
479	return Standard_True;
480	}
481
482	//=======================================================================
483	//function : ValidSub
484	//purpose :
485	//=======================================================================
486
487	Standard_Boolean BRepCheck_Analyzer::ValidSub
488	(const TopoDS_Shape& S,
489	const TopAbs_ShapeEnum SubType) const
490	{
491	BRepCheck_ListIteratorOfListOfStatus itl;
492	TopExp_Explorer exp;
493	for (exp.Init(S,SubType);exp.More(); exp.Next()) {
494	// for (TopExp_Explorer exp(S,SubType);exp.More(); exp.Next()) {
495	const Handle(BRepCheck_Result)& RV = myMap(exp.Current());
496	for (RV->InitContextIterator();
497	RV->MoreShapeInContext();
498	RV->NextShapeInContext()) {
499	if (RV->ContextualShape().IsSame(S)) {
500	break;
501	}
502	}
503
504	if(!RV->MoreShapeInContext()) break;
505
506	for (itl.Initialize(RV->StatusOnShape()); itl.More(); itl.Next()) {
507	if (itl.Value() != BRepCheck_NoError) {
508	return Standard_False;
509	}
510	}
511	}
512	return Standard_True ;
513	}