Salome HOME
Fix for the issue #686: now compounds produced by the Boolean operations can be corre...
[modules/shaper.git] / src / Model / Model_ResultBody.cpp
index 7b7e3c3be3a8eab1722a97f0a049137e33274161..8cecd4a92d837d8ed336dba3218e673456270b35 100644 (file)
 #include <ModelAPI_AttributeIntArray.h>
 #include <TNaming_Builder.hxx>
 #include <TNaming_NamedShape.hxx>
+#include <TNaming_Iterator.hxx>
 #include <TDataStd_Name.hxx>
+#include <TDataStd_Integer.hxx>
 #include <TopoDS.hxx>
-#include <TopoDS_Shape.hxx>
 #include <TopoDS_Face.hxx>
 #include <TDF_ChildIterator.hxx>
 #include <TopTools_MapOfShape.hxx>
 //#include <TDF_Tool.hxx>
 //#define DEB_IMPORT 1
 
-#define RESULT_BODY_COLOR "#E0A01B"
-
 Model_ResultBody::Model_ResultBody()
 {
+  myIsDisabled = true; // by default it is not initialized and false to be after created
   setIsConcealed(false);
 }
 
 void Model_ResultBody::initAttributes()
 {
-  // append the color attribute
+  // append the color attribute. It is empty, the attribute will be filled by a request
   DataPtr aData = data();
-  aData->addAttribute(COLOR_ID(), ModelAPI_AttributeIntArray::type());
-  AttributeIntArrayPtr aColorAttr = aData->intArray(COLOR_ID());
-  std::vector<int> aRGB;
-  aRGB = Config_PropManager::color("Visualization", "result_body_color", RESULT_BODY_COLOR);
-  aColorAttr->setSize(3);
-  aColorAttr->setValue(0, aRGB[0]);
-  aColorAttr->setValue(1, aRGB[1]);
-  aColorAttr->setValue(2, aRGB[2]);
+  aData->addAttribute(COLOR_ID(), ModelAPI_AttributeIntArray::typeId());
+}
+
+void Model_ResultBody::colorConfigInfo(std::string& theSection, std::string& theName,
+  std::string& theDefault)
+{
+  theSection = "Visualization";
+  theName = "result_body_color";
+  theDefault = DEFAULT_COLOR();
+}
+
+// Converts evolution of naming shape to selection evelution and back to avoid
+// naming support on the disabled results. Deeply in the labels tree, recursively.
+static void EvolutionToSelection(TDF_Label theLab, const bool theFlag) {
+  std::list<std::pair<TopoDS_Shape, TopoDS_Shape> > aShapePairs; // to store old and new shapes
+  Handle(TNaming_NamedShape) aName;
+  int anEvolution = -1;
+  if (theLab.FindAttribute(TNaming_NamedShape::GetID(), aName)) {
+    TNaming_Evolution aNSEvol = aName->Evolution();
+    if ((aNSEvol == TNaming_SELECTED && theFlag) ||
+        (aNSEvol != TNaming_SELECTED && !theFlag)) { // nothing to do, it is already correct
+      return;
+    }
+    anEvolution = (int)(aNSEvol);
+    if (!theFlag) {
+      Handle(TDataStd_Integer) anAttrEvol;
+      if (theLab.FindAttribute(TDataStd_Integer::GetID(), anAttrEvol)) {
+        anEvolution = anAttrEvol->Get();
+      }
+    } else {
+      TDataStd_Integer::Set(theLab, anEvolution);
+    }
+
+    for(TNaming_Iterator anIter(aName); anIter.More(); anIter.Next()) {
+      aShapePairs.push_back(std::pair<TopoDS_Shape, TopoDS_Shape>
+        (anIter.OldShape(), anIter.NewShape()));
+    }
+  }
+  // create new
+  TNaming_Builder aBuilder(theLab);
+  TNaming_Evolution anEvol = (TNaming_Evolution)(anEvolution);
+  std::list<std::pair<TopoDS_Shape, TopoDS_Shape> >::iterator aPairsIter = aShapePairs.begin();
+  for(; aPairsIter != aShapePairs.end(); aPairsIter++) {
+    if (theFlag) { // disabled => make selection
+      aBuilder.Select(aPairsIter->first, aPairsIter->second);
+    } else if (anEvol == TNaming_GENERATED) {
+      aBuilder.Generated(aPairsIter->first, aPairsIter->second);
+    } else if (anEvol == TNaming_MODIFY) {
+      aBuilder.Modify(aPairsIter->first, aPairsIter->second);
+    } else if (anEvol == TNaming_DELETE) {
+      aBuilder.Delete(aPairsIter->first);
+    } else if (anEvol == TNaming_PRIMITIVE) {
+      aBuilder.Generated(aPairsIter->second);
+    }
+  }
+  // recursive call for all sub-labels
+  TDF_ChildIterator anIter(theLab, Standard_False);
+  for(; anIter.More(); anIter.Next()) {
+    EvolutionToSelection(anIter.Value(), theFlag);
+  }
+}
+
+bool Model_ResultBody::setDisabled(std::shared_ptr<ModelAPI_Result> theThis, const bool theFlag)
+{
+  bool aChanged = ModelAPI_ResultBody::setDisabled(theThis, theFlag);
+  if (aChanged) { // state is changed, so modifications are needed
+    std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
+    if (!aData) // unknown case
+      return aChanged;
+    TDF_Label& aShapeLab = aData->shapeLab();
+    EvolutionToSelection(aShapeLab, theFlag);
+  }
+  return aChanged;
 }
 
 void Model_ResultBody::store(const std::shared_ptr<GeomAPI_Shape>& theShape)
@@ -74,17 +139,17 @@ void Model_ResultBody::store(const std::shared_ptr<GeomAPI_Shape>& theShape)
       return;  // null shape inside
 
     aBuilder.Generated(aShape);        
-       // register name
-       if(!aBuilder.NamedShape()->IsEmpty()) {
-         Handle(TDataStd_Name) anAttr;
-         if(aBuilder.NamedShape()->Label().FindAttribute(TDataStd_Name::GetID(),anAttr)) {
-               std::string aName (TCollection_AsciiString(anAttr->Get()).ToCString());
-               if(!aName.empty()) {
+    // register name
+    if(!aBuilder.NamedShape()->IsEmpty()) {
+      Handle(TDataStd_Name) anAttr;
+      if(aBuilder.NamedShape()->Label().FindAttribute(TDataStd_Name::GetID(),anAttr)) {
+        std::string aName (TCollection_AsciiString(anAttr->Get()).ToCString());
+        if(!aName.empty()) {
           std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(document());
           aDoc->addNamingName(aBuilder.NamedShape()->Label(), aName);
-               }
-         }
-       }
+        }
+      }
+    }
   }
 }
 
@@ -107,22 +172,22 @@ void Model_ResultBody::storeGenerated(const std::shared_ptr<GeomAPI_Shape>& theF
     if (aShapeNew.IsNull())
       return;  // null shape inside
     aBuilder.Generated(aShapeBasis, aShapeNew);
-               // register name
-       if(!aBuilder.NamedShape()->IsEmpty()) {
-         Handle(TDataStd_Name) anAttr;
-         if(aBuilder.NamedShape()->Label().FindAttribute(TDataStd_Name::GetID(),anAttr)) {
-               std::string aName (TCollection_AsciiString(anAttr->Get()).ToCString());
-               if(!aName.empty()) {
+    // register name
+    if(!aBuilder.NamedShape()->IsEmpty()) {
+      Handle(TDataStd_Name) anAttr;
+      if(aBuilder.NamedShape()->Label().FindAttribute(TDataStd_Name::GetID(),anAttr)) {
+        std::string aName (TCollection_AsciiString(anAttr->Get()).ToCString());
+        if(!aName.empty()) {
           std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(document());
           aDoc->addNamingName(aBuilder.NamedShape()->Label(), aName);
-               }
-         }
-       }
+        }
+      }
+    }
   }
 }
 
 void Model_ResultBody::storeModified(const std::shared_ptr<GeomAPI_Shape>& theOldShape,
-  const std::shared_ptr<GeomAPI_Shape>& theNewShape)
+  const std::shared_ptr<GeomAPI_Shape>& theNewShape, const int theDecomposeSolidsTag)
 {
   std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(data());
   if (aData) {
@@ -139,7 +204,32 @@ void Model_ResultBody::storeModified(const std::shared_ptr<GeomAPI_Shape>& theOl
     TopoDS_Shape aShapeNew = theNewShape->impl<TopoDS_Shape>();
     if (aShapeNew.IsNull())
       return;  // null shape inside
-       aBuilder.Modify(aShapeOld, aShapeNew);
+    aBuilder.Modify(aShapeOld, aShapeNew);
+    if (theDecomposeSolidsTag && aShapeNew.ShapeType() == TopAbs_COMPOUND) { // make sub elements as subs
+
+      // register name if it is possible
+      TCollection_AsciiString aName;
+      if(!aBuilder.NamedShape()->IsEmpty()) {
+        Handle(TDataStd_Name) anAttr;
+        if(aBuilder.NamedShape()->Label().FindAttribute(TDataStd_Name::GetID(),anAttr)) {
+          aName = TCollection_AsciiString(anAttr->Get()).ToCString();
+        }
+      }
+
+      TopoDS_Iterator aSubIter(aShapeNew);
+      for(int aTag = theDecomposeSolidsTag; aSubIter.More(); aSubIter.Next()) {
+        TNaming_Builder aSubBuilder(aShapeLab.FindChild(aTag++));
+        aSubBuilder.Generated(aSubIter.Value());
+        if(!aName.IsEmpty()) {
+          std::string aSolidName = 
+            (aName + "_Solid_" + TCollection_AsciiString(aTag - theDecomposeSolidsTag)).ToCString(); 
+          std::shared_ptr<Model_Document> aDoc = 
+            std::dynamic_pointer_cast<Model_Document>(document());
+          aDoc->addNamingName(aSubBuilder.NamedShape()->Label(), aSolidName);
+          TDataStd_Name::Set(aSubBuilder.NamedShape()->Label(), aSolidName.c_str());
+        }
+      }
+    }
   }
 }
 
@@ -270,7 +360,7 @@ void Model_ResultBody::loadAndOrientModifiedShapes (
     ListOfShape aList;
     std::shared_ptr<GeomAPI_Shape> aRShape(new GeomAPI_Shape());
     aRShape->setImpl((new TopoDS_Shape(aRoot)));
-       theMS->modified(aRShape, aList);
+    theMS->modified(aRShape, aList);
     std::list<std::shared_ptr<GeomAPI_Shape> >::const_iterator anIt = aList.begin(), aLast = aList.end();
     for (; anIt != aLast; anIt++) {
       TopoDS_Shape aNewShape = (*anIt)->impl<TopoDS_Shape>();    
@@ -280,9 +370,9 @@ void Model_ResultBody::loadAndOrientModifiedShapes (
       }
       if (!aRoot.IsSame (aNewShape)) {
         builder(theTag)->Modify(aRoot,aNewShape);
-               if(!isBuilt) 
-                 buildName(theTag, theName);           
-         }
+        if(!isBuilt) 
+          buildName(theTag, theName);          
+      }
     }
   }
 }
@@ -315,17 +405,17 @@ void Model_ResultBody::loadAndOrientGeneratedShapes (
       }
       if (!aRoot.IsSame (aNewShape)) {
         builder(theTag)->Generated(aRoot,aNewShape);
-               if(!isBuilt) 
-                 buildName(theTag, theName);   
-         }
+        if(!isBuilt) 
+          buildName(theTag, theName);  
+      }
     }
   }
 }
 
 //=======================================================================
 int getDangleShapes(const TopoDS_Shape&           theShapeIn, 
-                                       const TopAbs_ShapeEnum        theGeneratedFrom,
-                                   TopTools_DataMapOfShapeShape& theDangles) 
+  const TopAbs_ShapeEnum        theGeneratedFrom,
+  TopTools_DataMapOfShapeShape& theDangles) 
 {
   theDangles.Clear();
   TopTools_IndexedDataMapOfShapeListOfShape subShapeAndAncestors;
@@ -344,20 +434,20 @@ int getDangleShapes(const TopoDS_Shape&           theShapeIn,
 
 //=======================================================================
 void loadGeneratedDangleShapes(
-                                                          const TopoDS_Shape&      theShapeIn,
-                                              const TopAbs_ShapeEnum   theGeneratedFrom,
-                                              TNaming_Builder *        theBuilder)
+  const TopoDS_Shape&      theShapeIn,
+  const TopAbs_ShapeEnum   theGeneratedFrom,
+  TNaming_Builder *        theBuilder)
 {
   TopTools_DataMapOfShapeShape dangles;
   if (!getDangleShapes(theShapeIn, theGeneratedFrom, dangles)) return;
   TopTools_DataMapIteratorOfDataMapOfShapeShape itr(dangles);
   for (; itr.More(); itr.Next()) 
-       theBuilder->Generated(itr.Key(), itr.Value());
+    theBuilder->Generated(itr.Key(), itr.Value());
 }
 
 //=======================================================================
 void Model_ResultBody::loadNextLevels(std::shared_ptr<GeomAPI_Shape> theShape, 
-                                         const std::string& theName, int&  theTag)
+  const std::string& theName, int&  theTag)
 {
   if(theShape->isNull()) return;
   TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();    
@@ -365,12 +455,12 @@ void Model_ResultBody::loadNextLevels(std::shared_ptr<GeomAPI_Shape> theShape,
   if (aShape.ShapeType() == TopAbs_SOLID) {                
     TopExp_Explorer expl(aShape, TopAbs_FACE);
     for (; expl.More(); expl.Next()) {  
-         builder(theTag)->Generated(expl.Current()); 
-         TCollection_AsciiString aStr(theTag);
-         aName = theName + aStr.ToCString();
-         buildName(theTag, aName);
-         theTag++;
-       }
+      builder(theTag)->Generated(expl.Current()); 
+      TCollection_AsciiString aStr(theTag);
+      aName = theName + aStr.ToCString();
+      buildName(theTag, aName);
+      theTag++;
+    }
   }
   else if (aShape.ShapeType() == TopAbs_SHELL || aShape.ShapeType() == TopAbs_FACE) {
     // load faces and all the free edges
@@ -379,84 +469,84 @@ void Model_ResultBody::loadNextLevels(std::shared_ptr<GeomAPI_Shape> theShape,
     if (Faces.Extent() > 1 || (aShape.ShapeType() == TopAbs_SHELL && Faces.Extent() == 1)) {
       TopExp_Explorer expl(aShape, TopAbs_FACE);
       for (; expl.More(); expl.Next()) {
-                 builder(theTag)->Generated(expl.Current());          
-                 TCollection_AsciiString aStr(theTag);
-             aName = theName + aStr.ToCString();
-             buildName(theTag, aName);
-                 theTag++;
-         }
-       }
+        builder(theTag)->Generated(expl.Current());          
+        TCollection_AsciiString aStr(theTag);
+        aName = theName + aStr.ToCString();
+        buildName(theTag, aName);
+        theTag++;
+      }
+    }
     TopTools_IndexedDataMapOfShapeListOfShape anEdgeAndNeighbourFaces;
     TopExp::MapShapesAndAncestors(aShape, TopAbs_EDGE, TopAbs_FACE, anEdgeAndNeighbourFaces);
     for (Standard_Integer i = 1; i <= anEdgeAndNeighbourFaces.Extent(); i++) 
-       {
+    {
       const TopTools_ListOfShape& aLL = anEdgeAndNeighbourFaces.FindFromIndex(i);
       if (aLL.Extent() < 2) {
-                 if (BRep_Tool::Degenerated(TopoDS::Edge(anEdgeAndNeighbourFaces.FindKey(i))))
+        if (BRep_Tool::Degenerated(TopoDS::Edge(anEdgeAndNeighbourFaces.FindKey(i))))
           continue;
-           builder(theTag)->Generated(anEdgeAndNeighbourFaces.FindKey(i));
-               TCollection_AsciiString aStr(theTag);
-           aName = theName + aStr.ToCString();
-           buildName(theTag, aName);
-               theTag++;
+        builder(theTag)->Generated(anEdgeAndNeighbourFaces.FindKey(i));
+        TCollection_AsciiString aStr(theTag);
+        aName = theName + aStr.ToCString();
+        buildName(theTag, aName);
+        theTag++;
       } else {
-         TopTools_ListIteratorOfListOfShape anIter(aLL);
-         const TopoDS_Face& aFace = TopoDS::Face(anIter.Value());
-         anIter.Next();
-         if(aFace.IsEqual(anIter.Value())) {
-               builder(theTag)->Generated(anEdgeAndNeighbourFaces.FindKey(i));
-               TCollection_AsciiString aStr(theTag);
-           aName = theName + aStr.ToCString();
-           buildName(theTag, aName);
-           theTag++;
-         }
-         }
-       }
+        TopTools_ListIteratorOfListOfShape anIter(aLL);
+        const TopoDS_Face& aFace = TopoDS::Face(anIter.Value());
+        anIter.Next();
+        if(aFace.IsEqual(anIter.Value())) {
+          builder(theTag)->Generated(anEdgeAndNeighbourFaces.FindKey(i));
+          TCollection_AsciiString aStr(theTag);
+          aName = theName + aStr.ToCString();
+          buildName(theTag, aName);
+          theTag++;
+        }
+      }
+    }
   } else if (aShape.ShapeType() == TopAbs_WIRE) {
     TopTools_IndexedMapOfShape Edges;
     BRepTools::Map3DEdges(aShape, Edges);
     if (Edges.Extent() == 1) {
-         builder(++theTag)->Generated(Edges.FindKey(1));
+      builder(++theTag)->Generated(Edges.FindKey(1));
       TopExp_Explorer expl(aShape, TopAbs_VERTEX);
       for (; expl.More(); expl.Next()) {
-           builder(theTag)->Generated(expl.Current());
-               TCollection_AsciiString aStr(theTag);
-           aName = theName + aStr.ToCString();
-           buildName(theTag, aName);
-           theTag++;
-         }
-       } else {
+        builder(theTag)->Generated(expl.Current());
+        TCollection_AsciiString aStr(theTag);
+        aName = theName + aStr.ToCString();
+        buildName(theTag, aName);
+        theTag++;
+      }
+    } else {
       TopExp_Explorer expl(aShape, TopAbs_EDGE); 
       for (; expl.More(); expl.Next()) {       
-               builder(theTag)->Generated(expl.Current());
-               TCollection_AsciiString aStr(theTag);
-           aName = theName + aStr.ToCString();
-           buildName(theTag, aName);
-               theTag++;
-         }   
+        builder(theTag)->Generated(expl.Current());
+        TCollection_AsciiString aStr(theTag);
+        aName = theName + aStr.ToCString();
+        buildName(theTag, aName);
+        theTag++;
+      }   
       // and load generated vertices.
       TopTools_DataMapOfShapeShape generated;
       if (getDangleShapes(aShape, TopAbs_EDGE, generated)) 
-         {
-               TNaming_Builder* pBuilder = builder(theTag++);
-               loadGeneratedDangleShapes(aShape, TopAbs_EDGE, pBuilder);  
-         }
-       }
+      {
+        TNaming_Builder* pBuilder = builder(theTag++);
+        loadGeneratedDangleShapes(aShape, TopAbs_EDGE, pBuilder);  
+      }
+    }
   } else if (aShape.ShapeType() == TopAbs_EDGE) {
     TopExp_Explorer expl(aShape, TopAbs_VERTEX);
     for (; expl.More(); expl.Next()) {      
-               builder(theTag)->Generated(expl.Current());
-               TCollection_AsciiString aStr(theTag);
-           aName = theName + aStr.ToCString();
-           buildName(theTag, aName);
-               theTag++;
-       }
+      builder(theTag)->Generated(expl.Current());
+      TCollection_AsciiString aStr(theTag);
+      aName = theName + aStr.ToCString();
+      buildName(theTag, aName);
+      theTag++;
+    }
   }
 }
 
 //=======================================================================
 int findAmbiguities(const TopoDS_Shape&           theShapeIn,                                  
-                                         TopTools_ListOfShape&   theList) 
+  TopTools_ListOfShape&   theList) 
 {
   int aNumEdges(0);
   theList.Clear();
@@ -469,36 +559,36 @@ int findAmbiguities(const TopoDS_Shape&           theShapeIn,
   for (Standard_Integer i = 1; i <= subShapeAndAncestors.Extent(); i++) {
     const TopoDS_Shape& aKeyEdge1 = subShapeAndAncestors.FindKey(i);
     const TopTools_ListOfShape& ancestors1 = subShapeAndAncestors.FindFromIndex(i);
-       aMap1.Clear();
+    aMap1.Clear();
     TopTools_ListIteratorOfListOfShape it(ancestors1);
-       for(;it.More();it.Next()) aMap1.Add(it.Value()); // fill map with key ancestors => aKey1
-       for (Standard_Integer j = 1; j <= subShapeAndAncestors.Extent(); j++) {
-         if (i == j) continue;
+    for(;it.More();it.Next()) aMap1.Add(it.Value()); // fill map with key ancestors => aKey1
+    for (Standard_Integer j = 1; j <= subShapeAndAncestors.Extent(); j++) {
+      if (i == j) continue;
       const TopoDS_Shape& aKeyEdge2 = subShapeAndAncestors.FindKey(j);
       const TopTools_ListOfShape& ancestors2 = subShapeAndAncestors.FindFromIndex(j);
-         if(ancestors1.Extent() == ancestors2.Extent() && ancestors1.Extent() > 1) {
-               int aNum (ancestors2.Extent());
-           TopTools_ListIteratorOfListOfShape it(ancestors2);
-           for(;it.More();it.Next()) 
-                       if(aMap1.Contains(it.Value())) aNum--;
-               if(aNum == 0) {
-                 if(aMap2.Add(aKeyEdge1)) 
-                       aKeyList.Append(aKeyEdge1);
-                 if(aMap2.Add(aKeyEdge2))
-                       aKeyList.Append(aKeyEdge2);
-               }
-         }
-       } // at the end ==> List of edges to be named in addition       
+      if(ancestors1.Extent() == ancestors2.Extent() && ancestors1.Extent() > 1) {
+        int aNum (ancestors2.Extent());
+        TopTools_ListIteratorOfListOfShape it(ancestors2);
+        for(;it.More();it.Next()) 
+          if(aMap1.Contains(it.Value())) aNum--;
+        if(aNum == 0) {
+          if(aMap2.Add(aKeyEdge1)) 
+            aKeyList.Append(aKeyEdge1);
+          if(aMap2.Add(aKeyEdge2))
+            aKeyList.Append(aKeyEdge2);
+        }
+      }
+    } // at the end ==> List of edges to be named in addition  
   }
   aNumEdges = aKeyList.Extent();
   if(aNumEdges)
-       theList.Assign(aKeyList);       
+    theList.Assign(aKeyList);  
   return aNumEdges; 
 }
 
 //=======================================================================
 void Model_ResultBody::loadFirstLevel(
-                    std::shared_ptr<GeomAPI_Shape> theShape, const std::string& theName, int&  theTag)
+  std::shared_ptr<GeomAPI_Shape> theShape, const std::string& theName, int&  theTag)
 {
   if(theShape->isNull()) return;
   TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>(); 
@@ -506,43 +596,43 @@ void Model_ResultBody::loadFirstLevel(
   if (aShape.ShapeType() == TopAbs_COMPOUND || aShape.ShapeType() == TopAbs_COMPSOLID) {
     TopoDS_Iterator itr(aShape);
     for (; itr.More(); itr.Next(),theTag++) {
-         builder(theTag)->Generated(itr.Value());
-         TCollection_AsciiString aStr(theTag);
-         aName = theName + aStr.ToCString();
-         buildName(theTag, aName);
-         if(!theName.empty()) buildName(theTag, aName);
+      builder(theTag)->Generated(itr.Value());
+      TCollection_AsciiString aStr(theTag);
+      aName = theName + aStr.ToCString();
+      buildName(theTag, aName);
+      if(!theName.empty()) buildName(theTag, aName);
       if (itr.Value().ShapeType() == TopAbs_COMPOUND || 
-                 itr.Value().ShapeType() == TopAbs_COMPSOLID) 
-         {
-               std::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
+        itr.Value().ShapeType() == TopAbs_COMPSOLID) 
+      {
+        std::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
         itrShape->setImpl(new TopoDS_Shape(itr.Value()));
-           loadFirstLevel(itrShape, theName, theTag);
+        loadFirstLevel(itrShape, theName, theTag);
       } else {
-               std::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
+        std::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
         itrShape->setImpl(new TopoDS_Shape(itr.Value()));              
-               loadNextLevels(itrShape, theName, theTag);
-         }
+        loadNextLevels(itrShape, theName, theTag);
+      }
     }
   } else {
     std::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
     itrShape->setImpl(new TopoDS_Shape(aShape));
-       loadNextLevels(itrShape, theName, theTag); 
+    loadNextLevels(itrShape, theName, theTag); 
   }
   TopTools_ListOfShape   aList;
   if(findAmbiguities(aShape, aList)) {
-       TopTools_ListIteratorOfListOfShape it(aList);
+    TopTools_ListIteratorOfListOfShape it(aList);
     for (; it.More(); it.Next(),theTag++) {
-         builder(theTag)->Generated(it.Value());
-         TCollection_AsciiString aStr(theTag);
-         aName = theName + aStr.ToCString();
-         buildName(theTag, aName);
-       }
+      builder(theTag)->Generated(it.Value());
+      TCollection_AsciiString aStr(theTag);
+      aName = theName + aStr.ToCString();
+      buildName(theTag, aName);
+    }
   }
 }
 
 //=======================================================================
 void Model_ResultBody::loadDisconnectedEdges(
-                    std::shared_ptr<GeomAPI_Shape> theShape, const std::string& theName, int&  theTag)
+  std::shared_ptr<GeomAPI_Shape> theShape, const std::string& theName, int&  theTag)
 {
   if(theShape->isNull()) return;
   TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();  
@@ -558,33 +648,33 @@ void Model_ResultBody::loadDisconnectedEdges(
       Standard_Boolean faceIsNew = Standard_True;
       TopTools_ListIteratorOfListOfShape itrF(edgeNaborFaces.Find(anEdge));
       for (; itrF.More(); itrF.Next()) {
-           if (itrF.Value().IsSame(aFace)) {
-           faceIsNew = Standard_False;
-           break;
-               }
-         }
+        if (itrF.Value().IsSame(aFace)) {
+          faceIsNew = Standard_False;
+          break;
+        }
+      }
       if (faceIsNew) 
-           edgeNaborFaces.ChangeFind(anEdge).Append(aFace);      
-       }
+        edgeNaborFaces.ChangeFind(anEdge).Append(aFace);      
+    }
   }
 
-/*  TopTools_IndexedDataMapOfShapeListOfShape aDM;
+  /*  TopTools_IndexedDataMapOfShapeListOfShape aDM;
   TopExp::MapShapesAndAncestors(aShape, TopAbs_EDGE, TopAbs_FACE, aDM);
   for(int i=1; i <= aDM.Extent(); i++) {
-       if(aDM.FindFromIndex(i).Extent() > 1) continue;
-       if (BRep_Tool::Degenerated(TopoDS::Edge(aDM.FindKey(i))))
-     continue;
-       builder(theTag)->Generated(aDM.FindKey(i));
-    TCollection_AsciiString aStr(theTag);
-       std::string aName = theName + aStr.ToCString();
-       buildName(theTag, aName);
-#ifdef DEB_IMPORT
-       aName +=  + ".brep";
-       BRepTools::Write(aDM.FindKey(i), aName.c_str());
-#endif
-       theTag++;
+  if(aDM.FindFromIndex(i).Extent() > 1) continue;
+  if (BRep_Tool::Degenerated(TopoDS::Edge(aDM.FindKey(i))))
+  continue;
+  builder(theTag)->Generated(aDM.FindKey(i));
+  TCollection_AsciiString aStr(theTag);
+  std::string aName = theName + aStr.ToCString();
+  buildName(theTag, aName);
+  #ifdef DEB_IMPORT
+  aName +=  + ".brep";
+  BRepTools::Write(aDM.FindKey(i), aName.c_str());
+  #endif
+  theTag++;
   }
-*/
+  */
   TopTools_MapOfShape anEdgesToDelete;
   TopExp_Explorer anEx(aShape,TopAbs_EDGE); 
   std::string aName;
@@ -596,39 +686,39 @@ void Model_ResultBody::loadDisconnectedEdges(
       if (aList1.Extent()<2) continue;
       TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itr(edgeNaborFaces);
       for (; itr.More(); itr.Next()) {
-           TopoDS_Shape anEdge2 = itr.Key();
-           if(anEdgesToDelete.Contains(anEdge2)) continue;
-           if (anEdge1.IsSame(anEdge2)) continue;
-           const TopTools_ListOfShape& aList2 = itr.Value();
-           // compare lists of the neighbour faces of edge1 and edge2
-           if (aList1.Extent() == aList2.Extent()) {
-           Standard_Integer aMatches = 0;
-           for(TopTools_ListIteratorOfListOfShape aLIter1(aList1);aLIter1.More();aLIter1.Next())
-             for(TopTools_ListIteratorOfListOfShape aLIter2(aList2);aLIter2.More();aLIter2.Next())
-               if (aLIter1.Value().IsSame(aLIter2.Value())) aMatches++;
-               if (aMatches == aList1.Extent()) {
-                 aC0=Standard_True;
-                         builder(theTag)->Generated(anEdge2);
-                 anEdgesToDelete.Add(anEdge2);
-                         TCollection_AsciiString aStr(theTag);
-                         aName = theName + aStr.ToCString();
-                 buildName(theTag, aName);
-                         theTag++;
-                       }
-               }
-         }      
+        TopoDS_Shape anEdge2 = itr.Key();
+        if(anEdgesToDelete.Contains(anEdge2)) continue;
+        if (anEdge1.IsSame(anEdge2)) continue;
+        const TopTools_ListOfShape& aList2 = itr.Value();
+        // compare lists of the neighbour faces of edge1 and edge2
+        if (aList1.Extent() == aList2.Extent()) {
+          Standard_Integer aMatches = 0;
+          for(TopTools_ListIteratorOfListOfShape aLIter1(aList1);aLIter1.More();aLIter1.Next())
+            for(TopTools_ListIteratorOfListOfShape aLIter2(aList2);aLIter2.More();aLIter2.Next())
+              if (aLIter1.Value().IsSame(aLIter2.Value())) aMatches++;
+          if (aMatches == aList1.Extent()) {
+            aC0=Standard_True;
+            builder(theTag)->Generated(anEdge2);
+            anEdgesToDelete.Add(anEdge2);
+            TCollection_AsciiString aStr(theTag);
+            aName = theName + aStr.ToCString();
+            buildName(theTag, aName);
+            theTag++;
+          }
+        }
+      }      
       TopTools_MapIteratorOfMapOfShape itDelete(anEdgesToDelete);
       for(;itDelete.More();itDelete.Next()) 
-           edgeNaborFaces.UnBind(itDelete.Key());      
+        edgeNaborFaces.UnBind(itDelete.Key());      
       edgeNaborFaces.UnBind(anEdge1);
-       }
+    }
     if (aC0) {
-         builder(theTag)->Generated(anEdge1);
-         TCollection_AsciiString aStr(theTag);
-         aName = theName + aStr.ToCString();
-         buildName(theTag, aName);      
-         theTag++;
-       }
+      builder(theTag)->Generated(anEdge1);
+      TCollection_AsciiString aStr(theTag);
+      aName = theName + aStr.ToCString();
+      buildName(theTag, aName);         
+      theTag++;
+    }
   }  
 }
 
@@ -663,11 +753,11 @@ void Model_ResultBody::loadDisconnectedVertexes(std::shared_ptr<GeomAPI_Shape> t
   for (; itr.More(); itr.Next()) {
     const TopTools_ListOfShape& naborEdges = itr.Value();
     if (naborEdges.Extent() < 2) {             
-               builder(theTag)->Generated(itr.Key());
-               TCollection_AsciiString aStr(theTag);
-           aName = theName + aStr.ToCString();
-           buildName(theTag, aName);    
-               theTag++;
-       }
+      builder(theTag)->Generated(itr.Key());
+      TCollection_AsciiString aStr(theTag);
+      aName = theName + aStr.ToCString();
+      buildName(theTag, aName);         
+      theTag++;
+    }
   }
 }