IMPs 19998 and 21191. New gluing algorithm by PKV.

idl/GEOM_Gen.idl

@@ -1491,6 +1491,34 @@ module GEOM
     GEOM_Object MakeGlueFacesByList (in GEOM_Object theShape, in double theTolerance,
                                      in ListOfGO theFaces, in boolean doKeepNonSolids);
 
+    /*!
+     *  Replace coincident edges in theShape by one edge.
+     *  \param theShape Initial shape.
+     *  \param theTolerance Maximum distance between edges, which can be considered as coincident.
+     *  \return New GEOM_Object, containing a copy of theShape without coincident edges.
+     */
+    GEOM_Object MakeGlueEdges (in GEOM_Object theShape, in double theTolerance);
+
+    /*!
+     *  Find coincident edges in theShape for possible gluing.
+     *  \param theShape Initial shape.
+     *  \param theTolerance Maximum distance between edges, which can be considered as coincident.
+     *  \return ListOfGO
+     */
+    ListOfGO GetGlueEdges (in GEOM_Object theShape, in double theTolerance);
+
+    /*!
+     *  Replace coincident edges in theShape by one edge
+     *  in compliance with given list of edges
+     *  \param theShape Initial shape.
+     *  \param theTolerance Maximum distance between edges, which can be considered as coincident.
+     *  \param theFaces List of edges for gluing.
+     *  \return New GEOM_Object, containing a copy of theShape without some edges.
+     */
+    GEOM_Object MakeGlueEdgesByList (in GEOM_Object theShape,
+                                     in double theTolerance,
+                                     in ListOfGO theEdges);
+
     /*!
      *  Get all sub-shapes and groups of \a theShape,
      *  that were created already by any other methods.

src/GEOMAlgo/GEOMAlgo.cdl

@@ -1,23 +1,21 @@
---  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
+-- Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+-- CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+-- 
+-- This library is free software; you can redistribute it and/or
+-- modify it under the terms of the GNU Lesser General Public
+-- License as published by the Free Software Foundation; either 
+-- version 2.1 of the License.
+-- 
+-- This library is distributed in the hope that it will be useful 
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of 
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+-- Lesser General Public License for more details.
 --
---  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+-- You should have received a copy of the GNU Lesser General Public  
---  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+-- License along with this library; if not, write to the Free Software 
+-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 --
---  This library is free software; you can redistribute it and/or
+-- See http:--www.salome-platform.org/ or email : webmaster.salome@opencascade.com
---  modify it under the terms of the GNU Lesser General Public
---  License as published by the Free Software Foundation; either
---  version 2.1 of the License.
---
---  This library is distributed in the hope that it will be useful,
---  but WITHOUT ANY WARRANTY; without even the implied warranty of
---  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
---  Lesser General Public License for more details.
---
---  You should have received a copy of the GNU Lesser General Public
---  License along with this library; if not, write to the Free Software
---  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
---
---  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 --
 -- File:	GEOMAlgo.cdl
 -- Created:	Sat Dec 04 12:36:22 2004
@@ -130,6 +128,13 @@ is
     --  gluer    	     
     class Gluer; 
     class Gluer1;  
+ 
+--modified by NIZNHY-PKV Mon Feb 21 10:07:22 2011f  
+    imported Gluer2 from GEOMAlgo;   
+    imported GlueDetector from GEOMAlgo; 
+    imported GluerAlgo from GEOMAlgo;  
+--modified by NIZNHY-PKV Mon Feb 21 10:07:27 2011t     
+ 
     class GlueAnalyser;  
     
     class CoupleOfShapes; 
@@ -152,8 +157,8 @@ is
     class StateCollector; 
 
     class ClsfSolid;  
---    class FinderShapeOn2; 
+    -- class FinderShapeOn2; 
---    class PassKeyShapeMapHasher;
+    -- class PassKeyShapeMapHasher;
     --
     -- Builder/Splitter 
     deferred class BuilderShape; 

src/GEOMAlgo/GEOMAlgo_GlueDetector.cxx

@@ -0,0 +1,428 @@
+//  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File:        GEOMAlgo_GlueDetector.cxx
+// Created:     
+// Author:      Peter KURNEV
+//              <pkv@irinox>
+//
+#include <GEOMAlgo_GlueDetector.hxx>
+
+#include <Bnd_Box.hxx>
+#include <NCollection_UBTreeFiller.hxx>
+
+#include <TColStd_ListOfInteger.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+#include <TColStd_MapIteratorOfMapOfInteger.hxx>
+
+#include <TopoDS_Shape.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Compound.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <TopoDS_Iterator.hxx>
+#include <TopoDS_Compound.hxx>
+
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
+#include <TopTools_MapOfShape.hxx>
+#include <TopTools_MapIteratorOfMapOfShape.hxx>
+
+#include <TopExp.hxx>
+#include <BRep_Tool.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepBndLib.hxx>
+
+#include <NMTDS_BndSphereTree.hxx>
+#include <NMTDS_BndSphere.hxx>
+#include <NMTDS_IndexedDataMapOfShapeBndSphere.hxx>
+
+#include <GEOMAlgo_IndexedDataMapOfIntegerShape.hxx>
+#include <GEOMAlgo_Gluer.hxx>
+#include <GEOMAlgo_PassKeyShape.hxx>
+#include <GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx>
+#include <GEOMAlgo_Tools.hxx>
+
+//=======================================================================
+//function : 
+//purpose  : 
+//=======================================================================
+GEOMAlgo_GlueDetector::GEOMAlgo_GlueDetector()
+:
+  GEOMAlgo_GluerAlgo(),
+  GEOMAlgo_Algo()
+{}
+//=======================================================================
+//function : ~
+//purpose  : 
+//=======================================================================
+GEOMAlgo_GlueDetector::~GEOMAlgo_GlueDetector()
+{}
+//=======================================================================
+//function : Perform
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GlueDetector::Perform()
+{
+  myErrorStatus=0;
+  myWarningStatus=0;
+  //
+  CheckData();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  DetectVertices();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  DetectEdges();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  DetectFaces();
+  if (myErrorStatus) {
+    return;
+  }
+}
+//=======================================================================
+//function : DetectVertices
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GlueDetector::DetectVertices()
+{
+  Standard_Integer j, i, aNbV, aNbVSD;
+  Standard_Real aTolV;
+  gp_Pnt aPV;
+  TColStd_ListIteratorOfListOfInteger aIt;
+  TopoDS_Shape aVF;
+  TopTools_IndexedMapOfShape aMV;
+  TopTools_MapOfShape aMVProcessed;
+  TopTools_ListIteratorOfListOfShape aItS;
+  TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItIm;
+  TopTools_DataMapOfShapeListOfShape aMVV;
+  GEOMAlgo_IndexedDataMapOfIntegerShape aMIS;
+  NMTDS_IndexedDataMapOfShapeBndSphere aMSB;
+  //
+  NMTDS_BndSphereTreeSelector aSelector;
+  NMTDS_BndSphereTree aBBTree;
+  NCollection_UBTreeFiller <Standard_Integer, NMTDS_BndSphere> aTreeFiller(aBBTree);
+  //
+  myErrorStatus=0;
+  //
+  TopExp::MapShapes(myArgument, TopAbs_VERTEX, aMV);
+  aNbV=aMV.Extent();
+  if (!aNbV) {
+    myErrorStatus=2; // no vertices in source shape
+    return;
+  }
+  //
+  for (i=1; i<=aNbV; ++i) {
+    NMTDS_BndSphere aBox;
+    //
+    const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aMV(i));
+    aPV=BRep_Tool::Pnt(aV);
+    aTolV=BRep_Tool::Tolerance(aV);
+    //
+    aBox.SetGap(myTolerance);
+    aBox.SetCenter(aPV);
+    aBox.SetRadius(aTolV);
+    //
+    aTreeFiller.Add(i, aBox);
+    //
+    aMIS.Add(i, aV);
+    aMSB.Add(aV, aBox); 
+  }
+  //
+  aTreeFiller.Fill();
+  //
+  //---------------------------------------------------
+  // Chains
+  for (i=1; i<=aNbV; ++i) {
+    const TopoDS_Shape& aV=aMV(i);
+    //
+    if (aMVProcessed.Contains(aV)) {
+      continue;
+    }
+    //
+    Standard_Integer aNbIP, aIP, aNbIP1, aIP1;
+    TopTools_ListOfShape aLVSD;
+    TColStd_MapOfInteger aMIP, aMIP1, aMIPC;
+    TColStd_MapIteratorOfMapOfInteger aIt1;
+    //
+    aMIP.Add(i);
+    while(1) {
+      aNbIP=aMIP.Extent();
+      aIt1.Initialize(aMIP);
+      for(; aIt1.More(); aIt1.Next()) {
+	aIP=aIt1.Key();
+	if (aMIPC.Contains(aIP)) {
+	  continue;
+	}
+	//
+	const TopoDS_Shape& aVP=aMIS.FindFromKey(aIP);
+	const NMTDS_BndSphere& aBoxVP=aMSB.FindFromKey(aVP);
+	//
+	aSelector.Clear();
+	aSelector.SetBox(aBoxVP);
+	//
+	aNbVSD=aBBTree.Select(aSelector);
+	if (!aNbVSD) {
+	  continue;  // it shoild not be so [at least IP itself]    
+	}
+	//
+	const TColStd_ListOfInteger& aLI=aSelector.Indices();
+	aIt.Initialize(aLI);
+	for (; aIt.More(); aIt.Next()) {
+	  aIP1=aIt.Value();
+	  if (aMIP.Contains(aIP1)) {
+	    continue;
+	  }
+	  aMIP1.Add(aIP1);
+	} //for (; aIt.More(); aIt.Next()) {
+      }//for(; aIt1.More(); aIt1.Next()) {
+      //
+      aNbIP1=aMIP1.Extent();
+      if (!aNbIP1) {
+	break;
+      }
+      //
+      aIt1.Initialize(aMIP);
+      for(; aIt1.More(); aIt1.Next()) {
+	aIP=aIt1.Key();
+	aMIPC.Add(aIP);
+      }
+      //
+      aMIP.Clear();
+      aIt1.Initialize(aMIP1);
+      for(; aIt1.More(); aIt1.Next()) {
+	aIP=aIt1.Key();
+	aMIP.Add(aIP);
+      }
+      aMIP1.Clear();
+    }// while(1)
+    //
+    // Fill myImages
+    aNbIP=aMIPC.Extent();
+    //
+    if (!aNbIP) {// no SD vertices is found
+      aMVProcessed.Add(aV);
+      continue;
+    }
+    //else { // SD vertices founded [ aMIPC ]
+    aIt1.Initialize(aMIPC);
+    for(j=0; aIt1.More(); aIt1.Next(), ++j) {
+      aIP=aIt1.Key();
+      const TopoDS_Shape& aVP=aMIS.FindFromKey(aIP);
+      if (!j) {
+	aVF=aVP;
+      }
+      aLVSD.Append(aVP);
+      aMVProcessed.Add(aVP);
+    }
+    //}
+    myImages.Bind(aVF, aLVSD);
+  }// for (i=1; i<=aNbV; ++i) {
+  //------------------------------
+  // Origins
+  aItIm.Initialize(myImages);
+  for (; aItIm.More(); aItIm.Next()) {
+    const TopoDS_Shape& aV=aItIm.Key();
+    const TopTools_ListOfShape& aLVSD=aItIm.Value();
+    aItS.Initialize(aLVSD);
+    for (; aItS.More(); aItS.Next()) {
+      const TopoDS_Shape& aVSD=aItS.Value();
+      if (!myOrigins.IsBound(aVSD)) {
+	myOrigins.Bind(aVSD, aV);
+      }
+    }
+  }
+}
+//=======================================================================
+//function : DetectFaces
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GlueDetector::DetectFaces()
+{
+  DetectShapes(TopAbs_FACE);
+}
+//=======================================================================
+//function : DetectEdges
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GlueDetector::DetectEdges()
+{
+  DetectShapes(TopAbs_EDGE);
+}
+//=======================================================================
+//function : DetectShapes
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GlueDetector::DetectShapes(const TopAbs_ShapeEnum aType)
+{
+  Standard_Boolean bDegenerated;
+  Standard_Integer i, aNbF, aNbSDF, iErr;
+  TopTools_IndexedMapOfShape aMF;
+  TopTools_ListIteratorOfListOfShape aItLS;
+  GEOMAlgo_PassKeyShape aPKF;
+  GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape aMPKLF;
+  //
+  myErrorStatus=0;
+  //
+  TopExp::MapShapes(myArgument, aType, aMF);
+  //
+  aNbF=aMF.Extent();
+  for (i=1; i<=aNbF; ++i) {
+    const TopoDS_Shape& aS=aMF(i);
+    // 
+    if (aType==TopAbs_FACE) {
+      const TopoDS_Face& aF=*((TopoDS_Face*)&aS);
+      FacePassKey(aF, aPKF);
+    }
+    else if (aType==TopAbs_EDGE) {
+      const TopoDS_Edge& aE=*((TopoDS_Edge*)&aS);
+      EdgePassKey(aE, aPKF);
+    }
+    //
+    if (myErrorStatus) {
+      return;
+    }
+    //
+    if (aMPKLF.Contains(aPKF)) {
+      TopTools_ListOfShape& aLSDF=aMPKLF.ChangeFromKey(aPKF);
+      aLSDF.Append(aS);
+    }
+    else {
+      TopTools_ListOfShape aLSDF;
+      //
+      aLSDF.Append(aS);
+      aMPKLF.Add(aPKF, aLSDF);
+    }
+  }
+  // check geometric coincidence
+  if (myCheckGeometry) {
+    iErr=GEOMAlgo_Tools::RefineSDShapes(aMPKLF, myTolerance, myContext);
+    if (iErr) {
+      myErrorStatus=200;
+      return;
+    }
+  }
+  //
+  // Images/Origins
+  aNbF=aMPKLF.Extent();
+  for (i=1; i<=aNbF; ++i) {
+    const TopTools_ListOfShape& aLSDF=aMPKLF(i);
+    aNbSDF=aLSDF.Extent();
+    if (!aNbSDF) {
+      myErrorStatus=4; // it must not be
+    }
+    //
+    if (aNbSDF==1) {
+      continue;
+    }
+    //
+    const TopoDS_Shape& aS1=aLSDF.First();  
+    //
+    if (aType==TopAbs_EDGE) {
+      const TopoDS_Edge& aE1=*((TopoDS_Edge*)&aS1);
+      bDegenerated=BRep_Tool::Degenerated(aE1);
+      if (bDegenerated) {
+	continue;
+      }
+    }
+    //
+    myImages.Bind(aS1, aLSDF);
+    // origins
+    aItLS.Initialize(aLSDF);
+    for (; aItLS.More(); aItLS.Next()) {
+      const TopoDS_Shape& aFSD=aItLS.Value();
+      if (!myOrigins.IsBound(aFSD)) {
+        myOrigins.Bind(aFSD, aS1);
+      }
+    }
+  }// for (i=1; i<=aNbF; ++i)
+}
+//=======================================================================
+//function : FacePassKey
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GlueDetector::FacePassKey(const TopoDS_Face& aF, 
+					GEOMAlgo_PassKeyShape& aPK)
+{
+  Standard_Integer i, aNbE;
+  TopoDS_Shape aER;
+  TopTools_ListOfShape aLE;
+  TopTools_IndexedMapOfShape aME;
+  //
+  TopExp::MapShapes(aF, TopAbs_EDGE, aME);
+  //
+  aNbE=aME.Extent();
+  for (i=1; i<=aNbE; ++i) {
+    const TopoDS_Shape& aE=aME(i);
+    //
+    const TopoDS_Edge& aEE=*((TopoDS_Edge*)&aE);
+    if (BRep_Tool::Degenerated(aEE)) {
+      continue;
+    }
+    // 
+    if (myOrigins.IsBound(aE)) {
+      aER=myOrigins.Find(aE);
+    }
+    else {
+      aER=aE;
+    }
+    aLE.Append(aER);
+  }
+  aPK.SetShapes(aLE);
+}
+//=======================================================================
+//function : EdgePassKey
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GlueDetector::EdgePassKey(const TopoDS_Edge& aE, 
+					GEOMAlgo_PassKeyShape& aPK)
+{
+  TopAbs_Orientation aOr;
+  TopoDS_Shape aVR;
+  TopoDS_Iterator aIt;
+  TopTools_ListOfShape aLV;
+  //
+  aIt.Initialize(aE);
+  for (; aIt.More(); aIt.Next()) {
+    const TopoDS_Shape& aV=aIt.Value();
+    aOr=aV.Orientation();
+    if (aOr==TopAbs_FORWARD || aOr==TopAbs_REVERSED) {
+      if (myOrigins.IsBound(aV)) {
+	aVR=myOrigins.Find(aV);
+      }
+      else {
+	aVR=aV;
+      }
+      aLV.Append(aVR);
+    }
+  }
+  //
+  aPK.SetShapes(aLV);
+}

src/GEOMAlgo/GEOMAlgo_GlueDetector.hxx

@@ -0,0 +1,67 @@
+//  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File:        GEOMAlgo_GlueDetector.hxx
+// Created:     
+// Author:      Peter KURNEV
+//              <pkv@irinox>
+//
+#ifndef _GEOMAlgo_GlueDetector_HeaderFile
+#define _GEOMAlgo_GlueDetector_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Macro.hxx>
+#include <GEOMAlgo_GluerAlgo.hxx>
+#include <TopAbs_ShapeEnum.hxx>
+#include <GEOMAlgo_PassKeyShape.hxx>
+#include <GEOMAlgo_Algo.hxx>
+
+//=======================================================================
+//function : GEOMAlgo_GlueDetector
+//purpose  : 
+//=======================================================================
+class GEOMAlgo_GlueDetector  : public GEOMAlgo_GluerAlgo, 
+                               public GEOMAlgo_Algo {
+public:
+  Standard_EXPORT   GEOMAlgo_GlueDetector();
+  
+  Standard_EXPORT virtual ~GEOMAlgo_GlueDetector();
+  
+  Standard_EXPORT virtual  void Perform() ;
+
+protected:
+  Standard_EXPORT void DetectVertices() ;
+  
+  Standard_EXPORT void DetectEdges() ;
+  
+  Standard_EXPORT void DetectFaces() ;
+  
+  Standard_EXPORT void DetectShapes(const TopAbs_ShapeEnum aType) ;
+  
+  Standard_EXPORT void EdgePassKey(const TopoDS_Edge& aE,
+				   GEOMAlgo_PassKeyShape& aPK) ;
+  
+  Standard_EXPORT void FacePassKey(const TopoDS_Face& aF,
+				   GEOMAlgo_PassKeyShape& aPK) ;
+
+private:
+};
+#endif

src/GEOMAlgo/GEOMAlgo_Gluer.hxx

@@ -1,221 +1,177 @@
-//  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
+// File generated by CPPExt (Value)
-//
+//
-//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//                     Copyright (C) 1991 - 2000 by  
-//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//                      Matra Datavision SA.  All rights reserved.
-//
+//  
-//  This library is free software; you can redistribute it and/or
+//                     Copyright (C) 2001 - 2004 by
-//  modify it under the terms of the GNU Lesser General Public
+//                     Open CASCADE SA.  All rights reserved.
-//  License as published by the Free Software Foundation; either
+// 
-//  version 2.1 of the License.
+// This file is part of the Open CASCADE Technology software.
-//
+//
-//  This library is distributed in the hope that it will be useful,
+// This software may be distributed and/or modified under the terms and
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+// conditions of the Open CASCADE Public License as defined by Open CASCADE SA
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// and appearing in the file LICENSE included in the packaging of this file.
-//  Lesser General Public License for more details.
+//  
-//
+// This software is distributed on an "AS IS" basis, without warranty of any
-//  You should have received a copy of the GNU Lesser General Public
+// kind, and Open CASCADE SA hereby disclaims all such warranties,
-//  License along with this library; if not, write to the Free Software
+// including without limitation, any warranties of merchantability, fitness
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+// for a particular purpose or non-infringement. Please see the License for
-//
+// the specific terms and conditions governing rights and limitations under the
-//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+// License.
-//
+
-
+#ifndef _GEOMAlgo_Gluer_HeaderFile
-#ifndef _GEOMAlgo_Gluer_HeaderFile
+#define _GEOMAlgo_Gluer_HeaderFile
-#define _GEOMAlgo_Gluer_HeaderFile
+
-
+#ifndef _Standard_HeaderFile
-#ifndef _Standard_Boolean_HeaderFile
+#include <Standard.hxx>
-#include <Standard_Boolean.hxx>
+#endif
-#endif
+#ifndef _Standard_Macro_HeaderFile
-#ifndef _Standard_Real_HeaderFile
+#include <Standard_Macro.hxx>
-#include <Standard_Real.hxx>
+#endif
-#endif
+
-#ifndef _TopTools_DataMapOfShapeListOfShape_HeaderFile
+#ifndef _Standard_Boolean_HeaderFile
-#include <TopTools_DataMapOfShapeListOfShape.hxx>
+#include <Standard_Boolean.hxx>
-#endif
+#endif
-#ifndef _TopTools_DataMapOfShapeShape_HeaderFile
+#ifndef _Standard_Real_HeaderFile
-#include <TopTools_DataMapOfShapeShape.hxx>
+#include <Standard_Real.hxx>
-#endif
+#endif
-#ifndef _Standard_Integer_HeaderFile
+#ifndef _TopTools_DataMapOfShapeListOfShape_HeaderFile
-#include <Standard_Integer.hxx>
+#include <TopTools_DataMapOfShapeListOfShape.hxx>
-#endif
+#endif
-#ifndef _TopTools_ListOfShape_HeaderFile
+#ifndef _TopTools_DataMapOfShapeShape_HeaderFile
-#include <TopTools_ListOfShape.hxx>
+#include <TopTools_DataMapOfShapeShape.hxx>
-#endif
+#endif
-#ifndef _TopTools_MapOfShape_HeaderFile
+#ifndef _Standard_Integer_HeaderFile
-#include <TopTools_MapOfShape.hxx>
+#include <Standard_Integer.hxx>
-#endif
+#endif
-#ifndef _GEOMAlgo_ShapeAlgo_HeaderFile
+#ifndef _TopTools_ListOfShape_HeaderFile
-#include <GEOMAlgo_ShapeAlgo.hxx>
+#include <TopTools_ListOfShape.hxx>
-#endif
+#endif
-#ifndef _TopAbs_ShapeEnum_HeaderFile
+#ifndef _GEOMAlgo_ShapeAlgo_HeaderFile
-#include <TopAbs_ShapeEnum.hxx>
+#include <GEOMAlgo_ShapeAlgo.hxx>
-#endif
+#endif
-#ifndef _TopoDS_Compound_HeaderFile
+#ifndef _TopAbs_ShapeEnum_HeaderFile
-#include <TopoDS_Compound.hxx>
+#include <TopAbs_ShapeEnum.hxx>
-#endif
+#endif
-class TopTools_ListOfShape;
+class TopTools_ListOfShape;
-class TopoDS_Shape;
+class TopoDS_Shape;
-class TopoDS_Edge;
+class TopoDS_Edge;
-class GEOMAlgo_PassKeyShape;
+class GEOMAlgo_PassKeyShape;
-class TopoDS_Face;
+class TopoDS_Face;
-class TopoDS_Vertex;
+class TopoDS_Vertex;
-class TopTools_DataMapOfShapeListOfShape;
+class TopTools_DataMapOfShapeListOfShape;
-class TopTools_DataMapOfShapeShape;
+class TopTools_DataMapOfShapeShape;
-
+class TopTools_MapOfShape;
-
+class TopoDS_Compound;
-#ifndef _Standard_HeaderFile
+
-#include <Standard.hxx>
+
-#endif
+
-#ifndef _Standard_Macro_HeaderFile
+class GEOMAlgo_Gluer  : public GEOMAlgo_ShapeAlgo {
-#include <Standard_Macro.hxx>
+public:
-#endif
+
-
+  void* operator new(size_t,void* anAddress) 
-
+  {
-class GEOMAlgo_Gluer  : public GEOMAlgo_ShapeAlgo {
+    return anAddress;
-
+  }
-public:
+  void* operator new(size_t size) 
-
+  {
-    void* operator new(size_t,void* anAddress) 
+    return Standard::Allocate(size); 
-      {
+  }
-        return anAddress;
+  void  operator delete(void *anAddress) 
-      }
+  {
-    void* operator new(size_t size) 
+    if (anAddress) Standard::Free((Standard_Address&)anAddress); 
-      { 
+  }
-        return Standard::Allocate(size); 
+
-      }
+  
-    void  operator delete(void *anAddress) 
+  Standard_EXPORT   GEOMAlgo_Gluer();
-      { 
+Standard_EXPORT virtual ~GEOMAlgo_Gluer();
-        if (anAddress) Standard::Free((Standard_Address&)anAddress); 
+  
-      }
+  Standard_EXPORT     void SetCheckGeometry(const Standard_Boolean aFlag) ;
- // Methods PUBLIC
+  
- // 
+  Standard_EXPORT     Standard_Boolean CheckGeometry() const;
-
+  
-
+  Standard_EXPORT   virtual  void Perform() ;
-Standard_EXPORT GEOMAlgo_Gluer();
+  
-Standard_EXPORT virtual ~GEOMAlgo_Gluer();
+  Standard_EXPORT     Standard_Integer AloneShapes() const;
-
+  
-
+  Standard_EXPORT    const TopTools_ListOfShape& Modified(const TopoDS_Shape& S) ;
-Standard_EXPORT   void SetCheckGeometry(const Standard_Boolean aFlag) ;
+  
-
+  Standard_EXPORT    const TopTools_ListOfShape& Generated(const TopoDS_Shape& S) ;
-
+  
-Standard_EXPORT   Standard_Boolean CheckGeometry() const;
+  Standard_EXPORT     Standard_Boolean IsDeleted(const TopoDS_Shape& S) ;
-
+  
-
+  Standard_EXPORT    const TopTools_DataMapOfShapeListOfShape& Images() const;
-Standard_EXPORT   void SetKeepNonSolids(const Standard_Boolean aFlag) ;
+  
-
+  Standard_EXPORT    const TopTools_DataMapOfShapeShape& Origins() const;
-
+  
-Standard_EXPORT virtual  void Perform() ;
+  Standard_EXPORT     void MakeSubShapes(const TopoDS_Shape& aS,TopTools_MapOfShape& aM,TopoDS_Compound& aC) ;
-
+  
-
+  Standard_EXPORT     void SetKeepNonSolids(const Standard_Boolean bFlag) ;
-Standard_EXPORT   Standard_Integer AloneShapes() const;
+  
-
+  Standard_EXPORT     Standard_Boolean KeepNonSolids() const;
-
+
-Standard_EXPORT  const TopTools_ListOfShape& Modified(const TopoDS_Shape& S) ;
+
-
+
-
+
-Standard_EXPORT  const TopTools_ListOfShape& Generated(const TopoDS_Shape& S) ;
+
-
+protected:
-
+
-Standard_EXPORT   Standard_Boolean IsDeleted(const TopoDS_Shape& S) ;
+  
-
+  Standard_EXPORT   virtual  void CheckData() ;
-
+  
-Standard_EXPORT  const TopTools_DataMapOfShapeListOfShape& Images() const;
+  Standard_EXPORT   virtual  void CheckResult() ;
-
+  
-
+  Standard_EXPORT     void MakeVertices() ;
-Standard_EXPORT  const TopTools_DataMapOfShapeShape& Origins() const;
+  
-
+  Standard_EXPORT     void MakeEdges() ;
-
+  
-
+  Standard_EXPORT     void MakeFaces() ;
-
+  
-
+  Standard_EXPORT     void MakeShapes(const TopAbs_ShapeEnum aType) ;
-protected:
+  
-
+  Standard_EXPORT     void MakeShells() ;
- // Methods PROTECTED
+  
- // 
+  Standard_EXPORT     void MakeSolids() ;
-
+  
-
+  Standard_EXPORT     void InnerTolerance() ;
-Standard_EXPORT virtual  void CheckData() ;
+  
-
+  Standard_EXPORT     void EdgePassKey(const TopoDS_Edge& aE,GEOMAlgo_PassKeyShape& aPK) ;
-
+  
-Standard_EXPORT virtual  void CheckResult() ;
+  Standard_EXPORT     void FacePassKey(const TopoDS_Face& aF,GEOMAlgo_PassKeyShape& aPK) ;
-
+  
-
+  Standard_EXPORT     void MakeVertex(const TopTools_ListOfShape& aLV,TopoDS_Vertex& aNewV) ;
-Standard_EXPORT   void MakeVertices() ;
+  
-
+  Standard_EXPORT     void MakeEdge(const TopoDS_Edge& aEdge,TopoDS_Edge& aNewEdge) ;
-
+  
-Standard_EXPORT   void MakeEdges() ;
+  Standard_EXPORT     void MakeFace(const TopoDS_Face& aFace,TopoDS_Face& aNewEdge) ;
-
+  
-
+  Standard_EXPORT     Standard_Boolean IsToReverse(const TopoDS_Face& aFR,const TopoDS_Face& aF) ;
-Standard_EXPORT   void MakeFaces() ;
+  
-
+  Standard_EXPORT     Standard_Boolean HasNewSubShape(const TopoDS_Shape& aS) const;
-
+
-Standard_EXPORT   void MakeShapes(const TopAbs_ShapeEnum aType) ;
+
-
+Standard_Boolean myCheckGeometry;
-
+Standard_Real myTol;
-Standard_EXPORT   void MakeShells() ;
+TopTools_DataMapOfShapeListOfShape myImages;
-
+TopTools_DataMapOfShapeShape myOrigins;
-
+Standard_Integer myNbAlone;
-Standard_EXPORT   void MakeSubShapes(const TopoDS_Shape& theShape,
+TopTools_ListOfShape myGenerated;
-                                     TopTools_MapOfShape& theMS,
+Standard_Boolean myKeepNonSolids;
-                                     TopoDS_Compound& theResult);
+
-
+
-
+private:
-Standard_EXPORT   void MakeSolids() ;
+
-
+
-
+
-Standard_EXPORT   void InnerTolerance() ;
+
-
+
-
+};
-Standard_EXPORT   void EdgePassKey(const TopoDS_Edge& aE,GEOMAlgo_PassKeyShape& aPK) ;
+
-
+
-
+
-Standard_EXPORT   void FacePassKey(const TopoDS_Face& aF,GEOMAlgo_PassKeyShape& aPK) ;
+
-
+
-
+// other Inline functions and methods (like "C++: function call" methods)
-Standard_EXPORT   void MakeVertex(const TopTools_ListOfShape& aLV,TopoDS_Vertex& aNewV) ;
+
-
+
-
+#endif
-Standard_EXPORT   void MakeEdge(const TopoDS_Edge& aEdge,TopoDS_Edge& aNewEdge) ;
-
-
-Standard_EXPORT   void MakeFace(const TopoDS_Face& aFace,TopoDS_Face& aNewEdge) ;
-
-
-Standard_EXPORT   Standard_Boolean IsToReverse(const TopoDS_Face& aFR,const TopoDS_Face& aF) ;
-
-
-Standard_EXPORT   Standard_Boolean HasNewSubShape(const TopoDS_Shape& aS) const;
-
-
- // Fields PROTECTED
- //
-Standard_Boolean myCheckGeometry;
-Standard_Boolean myKeepNonSolids;
-Standard_Real myTol;
-TopTools_DataMapOfShapeListOfShape myImages;
-TopTools_DataMapOfShapeShape myOrigins;
-Standard_Integer myNbAlone;
-TopTools_ListOfShape myGenerated;
-
-
-private: 
-
- // Methods PRIVATE
- // 
-
-
- // Fields PRIVATE
- //
-
-
-};
-
-
-
-
-
-// other Inline functions and methods (like "C++: function call" methods)
-//
-
-
-#endif

src/GEOMAlgo/GEOMAlgo_Gluer2.cxx

@@ -0,0 +1,626 @@
+//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+// File:	GEOMAlgo_Gluer2.cxx
+// Author:	Peter KURNEV
+
+#include <GEOMAlgo_Gluer2.hxx>
+
+#include <TopAbs_ShapeEnum.hxx>
+
+#include <TopoDS_Compound.hxx>
+#include <TopoDS_Iterator.hxx>
+#include <TopoDS_Shape.hxx>
+#include <TopoDS_Vertex.hxx>
+
+#include <BRep_Builder.hxx>
+#include <TopExp.hxx>
+#include <BRepLib.hxx>
+
+#include <TopTools_MapOfShape.hxx>
+#include <TopTools_MapIteratorOfMapOfShape.hxx>
+#include <TopTools_DataMapOfShapeShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+
+#include <GEOMAlgo_GlueDetector.hxx>
+#include <GEOMAlgo_Tools3D.hxx>
+
+//=======================================================================
+//function : GEOMAlgo_Gluer2
+//purpose  : 
+//=======================================================================
+GEOMAlgo_Gluer2::GEOMAlgo_Gluer2()
+:
+  GEOMAlgo_GluerAlgo(),
+  GEOMAlgo_BuilderShape()
+{
+  myTolerance=0.0001;
+}
+//=======================================================================
+//function : ~GEOMAlgo_Gluer2
+//purpose  : 
+//=======================================================================
+GEOMAlgo_Gluer2::~GEOMAlgo_Gluer2()
+{
+}
+//=======================================================================
+//function : Clear
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::Clear()
+{
+  myErrorStatus=0;
+  myWarningStatus=0;
+  //
+  GEOMAlgo_GluerAlgo::Clear();
+  //
+  myImagesDetected.Clear();
+  myOriginsDetected.Clear();
+  myShapesToGlue.Clear();
+  myImagesToWork.Clear();
+  myOriginsToWork.Clear();
+  myKeepNonSolids=Standard_False;
+}
+//=======================================================================
+//function : SetShapesToGlue
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::SetShapesToGlue(const TopTools_DataMapOfShapeListOfShape& aM)
+{
+  myShapesToGlue=aM;
+}
+//=======================================================================
+//function : ShapesToGlue
+//purpose  : 
+//=======================================================================
+const TopTools_DataMapOfShapeListOfShape& GEOMAlgo_Gluer2::ShapesToGlue()const
+{
+  return myShapesToGlue;
+}
+//=======================================================================
+//function : SetKeepNonSolids
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::SetKeepNonSolids(const Standard_Boolean aFlag)
+{
+  myKeepNonSolids=aFlag;
+}
+//=======================================================================
+//function : KeepNonSolids
+//purpose  : 
+//=======================================================================
+Standard_Boolean GEOMAlgo_Gluer2::KeepNonSolids()const 
+{
+  return myKeepNonSolids;
+}
+//=======================================================================
+//function : ShapesDetected
+//purpose  : 
+//=======================================================================
+const TopTools_DataMapOfShapeListOfShape& GEOMAlgo_Gluer2::ShapesDetected()const
+{
+  return myImagesDetected;
+}
+//=======================================================================
+//function : ImagesToWork
+//purpose  : 
+//=======================================================================
+const TopTools_DataMapOfShapeListOfShape& GEOMAlgo_Gluer2::ImagesToWork()const
+{
+  return myImagesToWork;
+}
+//=======================================================================
+//function : Perform
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::Perform()
+{
+  myErrorStatus=0;
+  myWarningStatus=0;
+  // 
+  CheckData();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  PerformShapesToWork();
+  if (myErrorStatus) {
+    return;
+  }
+  if (myWarningStatus==1) {// no shapes to glue
+    myShape=myArgument;
+    return;
+  }
+  //
+  FillVertices();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  FillEdges();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  FillWires();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  FillFaces();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  FillShells();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  FillSolids();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  FillCompSolids();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  FillCompounds();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  BuildResult();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  PrepareHistory();
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  BRepLib::SameParameter(myShape, myTolerance, Standard_True);
+}
+//=======================================================================
+//function : CheckData
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::CheckData()
+{
+  Standard_Integer aNbSG, i;
+  TopAbs_ShapeEnum aType, aTypeX;
+  TopTools_ListIteratorOfListOfShape aItLS;
+  TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS;
+  //
+  myErrorStatus=0;
+  myWarningStatus=0;
+  //
+  aNbSG=myShapesToGlue.Extent();
+  if (aNbSG) {
+    // Check myShapesToGlue
+    aItDMSLS.Initialize(myShapesToGlue);
+    for (; aItDMSLS.More(); aItDMSLS.Next()) {
+      //const TopoDS_Shape& aSkey=aItDMSLS.Key();
+      const TopTools_ListOfShape& aLSG=aItDMSLS.Value();
+      aItLS.Initialize(aLSG);
+      for (i=0; aItLS.More(); aItLS.Next(), ++i) {
+	const TopoDS_Shape& aSG=aItLS.Value();
+	aTypeX=aSG.ShapeType();
+	if (!i) {
+	  aType=aTypeX;
+	  if (!(aType==TopAbs_VERTEX || 
+		aType==TopAbs_EDGE || 
+		aType==TopAbs_FACE)) {
+	    myErrorStatus=21;// non-brep shapes
+	    return;
+	  }
+	  continue;
+	}
+	if (aTypeX!=aType) {
+	  myErrorStatus=20;// non-homogeneous shapes
+	  return;
+	}
+      }
+    }
+  }// if (aNbSG) {
+}
+//=======================================================================
+//function : FillEdges
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillEdges()
+{
+  FillBRepShapes(TopAbs_EDGE);
+} 
+//=======================================================================
+//function : FillFaces
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillFaces()
+{
+  FillBRepShapes(TopAbs_FACE);
+}
+//=======================================================================
+//function : FillWires
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillWires()
+{
+  FillContainers(TopAbs_WIRE);
+}
+//=======================================================================
+//function : FillShells
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillShells()
+{
+  FillContainers(TopAbs_SHELL);
+}
+//=======================================================================
+//function : FillSolids
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillSolids()
+{
+  FillContainers(TopAbs_SOLID);
+} 
+//=======================================================================
+//function : FillCompSolids
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillCompSolids()
+{
+  FillContainers(TopAbs_COMPSOLID);
+} 
+//=======================================================================
+//function : FillVertices
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillVertices()
+{
+  TopAbs_ShapeEnum aType;
+  TopoDS_Vertex aVnew;
+  TopTools_ListIteratorOfListOfShape aItLS;
+  TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS;
+  //
+  myErrorStatus=0;
+  myWarningStatus=0;
+  //
+  aItDMSLS.Initialize(myImagesToWork);
+  for (; aItDMSLS.More(); aItDMSLS.Next()) {
+    const TopoDS_Shape& aSkey=aItDMSLS.Key();
+    aType=aSkey.ShapeType();
+    if (aType!=TopAbs_VERTEX) {
+      continue;
+    }
+    //
+    const TopTools_ListOfShape& aLSD=aItDMSLS.Value();
+    //
+    GEOMAlgo_Gluer2::MakeVertex(aLSD, aVnew);
+    //
+    myImages.Bind(aVnew, aLSD);
+    //
+    aItLS.Initialize(aLSD);
+    for (; aItLS.More(); aItLS.Next()) {
+      const TopoDS_Shape& aV=aItLS.Value();
+      myOrigins.Bind(aV, aVnew);
+    }
+  }
+}
+//=======================================================================
+//function : FillBRepShapes
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillBRepShapes(const TopAbs_ShapeEnum theType)
+{ 
+  Standard_Boolean bHasImage, bIsToWork;
+  Standard_Integer i, aNbE;
+  TopoDS_Iterator aItS;
+  TopoDS_Shape aEnew;
+  TopTools_IndexedMapOfShape aME;
+  TopTools_MapOfShape aMFence;
+  TopTools_ListIteratorOfListOfShape aItLS;
+  //
+  myErrorStatus=0;
+  myWarningStatus=0;
+  //
+  TopExp::MapShapes(myArgument, theType, aME);
+  //
+  aNbE=aME.Extent();
+  for (i=1; i<=aNbE; ++i) {
+    const TopoDS_Shape& aE=aME(i);
+    //
+    if (!aMFence.Add(aE)) {
+      continue;
+    }
+    //
+    bIsToWork=myOriginsToWork.IsBound(aE);
+    bHasImage=HasImage(aE);
+    if (!bHasImage && !bIsToWork) {
+      continue;
+    }
+    //
+    MakeBRepShapes(aE, aEnew);
+    //
+    //myImages / myOrigins
+    if (bIsToWork) {
+      const TopoDS_Shape& aSkey=myOriginsToWork.Find(aE);
+      const TopTools_ListOfShape& aLSD=myImagesToWork.Find(aSkey);
+      //
+      myImages.Bind(aEnew, aLSD);
+      //
+      aItLS.Initialize(aLSD);
+      for (; aItLS.More(); aItLS.Next()) {
+	const TopoDS_Shape& aEx=aItLS.Value();
+	myOrigins.Bind(aEx, aEnew);
+	//
+	aMFence.Add(aEx);
+      }
+    }
+    else {
+      TopTools_ListOfShape aLSD;
+      //
+      aLSD.Append(aE);
+      myImages.Bind(aEnew, aLSD);
+      myOrigins.Bind(aE, aEnew);
+    }
+  }//for (i=1; i<=aNbF; ++i) {
+}
+//=======================================================================
+//function : FillContainers
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillContainers(const TopAbs_ShapeEnum aType)
+{
+  Standard_Boolean bHasImage, bToReverse;
+  Standard_Integer i, aNbW;
+  TopoDS_Shape aWnew, aEnew;
+  TopoDS_Iterator aItS;
+  BRep_Builder aBB;
+  TopTools_IndexedMapOfShape aMW;
+  TopTools_MapOfShape aMFence;
+  //
+  myErrorStatus=0;
+  myWarningStatus=0;
+  //
+  TopExp::MapShapes(myArgument, aType, aMW);
+  //
+  aNbW=aMW.Extent();
+  for (i=1; i<=aNbW; ++i) {
+    const TopoDS_Shape& aW=aMW(i);
+    //
+    if (!aMFence.Add(aW)) {
+      continue;
+    }
+    //
+    bHasImage=HasImage(aW);
+    if (!bHasImage) {
+      continue;
+    }
+    //
+    GEOMAlgo_Tools3D::MakeContainer(aType, aWnew);
+    //
+    aItS.Initialize(aW);
+    for (; aItS.More(); aItS.Next()) {
+      const TopoDS_Shape& aE=aItS.Value();
+      if (myOrigins.IsBound(aE)) {
+	aEnew=myOrigins.Find(aE);
+	//
+	bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aEnew, aE, myContext);
+	if (bToReverse) {
+	  aEnew.Reverse();
+	}
+	//
+	aBB.Add(aWnew, aEnew);
+      }
+      else {
+	aBB.Add(aWnew, aE);
+      }
+    }
+    //
+    aWnew.Orientation(aW.Orientation());
+    //
+    //myImages / myOrigins
+    TopTools_ListOfShape aLSD;
+    //
+    aLSD.Append(aW);
+    myImages.Bind(aWnew, aLSD);
+    myOrigins.Bind(aW, aWnew);
+    //
+  }//for (i=1; i<=aNbE; ++i) {
+}
+//=======================================================================
+//function : FillCompounds
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillCompounds()
+{
+  TopAbs_ShapeEnum aType;
+  TopoDS_Iterator aItC;
+  //
+  myErrorStatus=0;
+  myWarningStatus=0;
+  //
+  aItC.Initialize(myArgument);
+  for (; aItC.More(); aItC.Next()) {
+    const TopoDS_Shape& aCx=aItC.Value();
+    aType=aCx.ShapeType();
+    if (aType==TopAbs_COMPOUND) {
+      FillCompound(aCx);
+    }
+  }
+}
+//=======================================================================
+//function : FillCompound
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::FillCompound(const TopoDS_Shape& aC)
+{
+  Standard_Boolean bHasImage;
+  TopAbs_ShapeEnum aType;
+  TopoDS_Shape aCnew, aCXnew;
+  TopoDS_Iterator aItC;
+  BRep_Builder aBB;
+  //
+  bHasImage=HasImage(aC);
+  if (!bHasImage) {
+    return;
+  }
+  //
+  GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew);
+  //
+  aItC.Initialize(aC);
+  for (; aItC.More(); aItC.Next()) {
+    const TopoDS_Shape& aCX=aItC.Value();
+    aType=aCX.ShapeType();
+    //
+    if (aType==TopAbs_COMPOUND) {
+      FillCompound(aCX);
+    }
+    //
+    if (myOrigins.IsBound(aCX)) {
+      aCXnew=myOrigins.Find(aCX);
+      aCXnew.Orientation(aCX.Orientation());
+      aBB.Add(aCnew, aCXnew);
+    }
+    else {
+      aBB.Add(aCnew, aCX);
+    }
+  }
+  //
+  //myImages / myOrigins
+  TopTools_ListOfShape aLSD;
+  //
+  aLSD.Append(aC);
+  myImages.Bind(aCnew, aLSD);
+  myOrigins.Bind(aC, aCnew);
+}
+//=======================================================================
+//function : HasImage
+//purpose  : 
+//=======================================================================
+Standard_Boolean GEOMAlgo_Gluer2::HasImage(const TopoDS_Shape& aC)
+{
+  Standard_Boolean bRet;
+  TopAbs_ShapeEnum aType;
+  TopoDS_Iterator aItC;
+  //
+  bRet=Standard_False;
+  aItC.Initialize(aC);
+  for (; aItC.More(); aItC.Next()) {
+    const TopoDS_Shape& aCx=aItC.Value();
+    aType=aCx.ShapeType();
+    //
+    if (aType==TopAbs_COMPOUND) {
+      bRet=HasImage(aCx);
+      if (bRet) {
+	return bRet;
+      }
+    }
+    else {
+      bRet=myOrigins.IsBound(aCx);
+      if (bRet) {
+	return bRet;
+      }
+    }
+  }
+  //
+  bRet=myOrigins.IsBound(aC);
+  //
+  return bRet;
+}
+//=======================================================================
+//function : BuildResult
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::BuildResult()
+{
+  Standard_Boolean bHasImage;
+  TopoDS_Shape aCnew, aCXnew;
+  TopoDS_Iterator aItC;
+  BRep_Builder aBB;
+  //
+  myErrorStatus=0;
+  myWarningStatus=0;
+  //
+  aItC.Initialize(myArgument);
+  for (; aItC.More(); aItC.Next()) {
+    const TopoDS_Shape& aCx=aItC.Value();
+    bHasImage=HasImage(aCx);
+    if (bHasImage) {
+      break;
+    }
+  }
+  //
+  if (!bHasImage) {
+    myShape=myArgument;
+    return;
+  }
+  //
+  GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew);
+  //
+  aItC.Initialize(myArgument);
+  for (; aItC.More(); aItC.Next()) {
+    const TopoDS_Shape& aCX=aItC.Value();
+    if (myOrigins.IsBound(aCX)) {
+      aCXnew=myOrigins.Find(aCX);
+      aCXnew.Orientation(aCX.Orientation());
+      aBB.Add(aCnew, aCXnew);
+    }
+    else {
+      aBB.Add(aCnew, aCX);
+    }
+  }
+  //
+  if (!myKeepNonSolids) {
+    Standard_Integer i, aNb;
+    TopoDS_Shape aCnew1;
+    TopTools_IndexedMapOfShape aM;
+    //
+    GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew1);
+    //
+    TopExp::MapShapes(aCnew, TopAbs_SOLID, aM);
+    
+    aNb=aM.Extent();
+    for (i=1; i<=aNb; ++i) {
+      const TopoDS_Shape& aS=aM(i);
+      aBB.Add(aCnew1, aS);
+    }
+    aCnew=aCnew1;
+  }
+  //
+  myShape=aCnew;
+}
+//--------------------------------------------------------
+//
+// ErrorStatus
+// 11   - GEOMAlgo_GlueDetector failed
+// 13   - PerformImagesToWork failed
+// 14   - PerformImagesToWork failed
+//
+// WarningStatus
+// 1    - no shapes to glue

src/GEOMAlgo/GEOMAlgo_Gluer2.hxx

@@ -0,0 +1,144 @@
+//  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File:        GEOMAlgo_Gluer2.hxx
+// Created:     
+// Author:      Peter KURNEV
+//              <pkv@irinox>
+
+#ifndef _GEOMAlgo_Gluer2_HeaderFile
+#define _GEOMAlgo_Gluer2_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Macro.hxx>
+
+#include <TopTools_DataMapOfShapeListOfShape.hxx>
+#include <TopTools_DataMapOfShapeShape.hxx>
+#include <Standard_Boolean.hxx>
+#include <GEOMAlgo_GluerAlgo.hxx>
+#include <TopAbs_ShapeEnum.hxx>
+#include <NMTTools_CoupleOfShape.hxx>
+#include <NMTTools_ListOfCoupleOfShape.hxx>
+#include <GEOMAlgo_BuilderShape.hxx>
+
+//=======================================================================
+//class : GEOMAlgo_Gluer2
+//purpose  : 
+//=======================================================================
+class GEOMAlgo_Gluer2  : public GEOMAlgo_GluerAlgo, 
+                         public GEOMAlgo_BuilderShape {
+public:
+  
+  Standard_EXPORT   GEOMAlgo_Gluer2();
+  
+  Standard_EXPORT virtual ~GEOMAlgo_Gluer2();
+  
+  Standard_EXPORT     void SetShapesToGlue(const TopTools_DataMapOfShapeListOfShape& aM) ;
+  
+  Standard_EXPORT    const TopTools_DataMapOfShapeListOfShape& ShapesToGlue() const;
+  
+  Standard_EXPORT     void SetKeepNonSolids(const Standard_Boolean theFlag) ;
+  
+  Standard_EXPORT     Standard_Boolean KeepNonSolids() const;
+  
+  Standard_EXPORT   virtual  void Clear() ;
+  
+  Standard_EXPORT   virtual  void Perform() ;
+  
+  Standard_EXPORT   virtual  void CheckData() ;
+  
+  Standard_EXPORT     void Detect() ;
+  
+  Standard_EXPORT    const TopTools_DataMapOfShapeListOfShape& ShapesDetected() const;
+  
+  Standard_EXPORT    const TopTools_DataMapOfShapeListOfShape& ImagesToWork() const;
+  
+  Standard_EXPORT   virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& theS) ;
+  
+  Standard_EXPORT   virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& theS) ;
+  
+  Standard_EXPORT   virtual  Standard_Boolean IsDeleted(const TopoDS_Shape& theS) ;
+  
+  Standard_EXPORT   static  void MakeVertex(const TopTools_ListOfShape& theLV,
+					    TopoDS_Vertex& theV) ;
+  
+  Standard_EXPORT   static  void MapBRepShapes(const TopoDS_Shape& theS,
+					       TopTools_MapOfShape& theM) ;
+  
+  Standard_EXPORT   static  void MapShapes(const TopoDS_Shape& theS,
+					   TopTools_MapOfShape& theM) ;
+
+
+protected:
+  
+  Standard_EXPORT     void PerformShapesToWork() ;
+  
+  Standard_EXPORT     void FillVertices() ;
+  
+  Standard_EXPORT     void FillEdges() ;
+  
+  Standard_EXPORT     void FillWires() ;
+  
+  Standard_EXPORT     void FillFaces() ;
+  
+  Standard_EXPORT     void FillShells() ;
+  
+  Standard_EXPORT     void FillSolids() ;
+  
+  Standard_EXPORT     void FillCompSolids() ;
+  
+  Standard_EXPORT     void FillCompounds() ;
+  
+  Standard_EXPORT     void BuildResult() ;
+  
+  Standard_EXPORT     void FillBRepShapes(const TopAbs_ShapeEnum theType) ;
+  
+  Standard_EXPORT     void FillContainers(const TopAbs_ShapeEnum theType) ;
+  
+  Standard_EXPORT     void FillCompound(const TopoDS_Shape& theC) ;
+  
+  Standard_EXPORT     virtual  void PrepareHistory() ;
+  
+  Standard_EXPORT     Standard_Boolean HasImage(const TopoDS_Shape& theC) ;
+  
+  Standard_EXPORT     void MakeBRepShapes(const TopoDS_Shape& theS,
+					  TopoDS_Shape& theSnew) ;
+  
+  Standard_EXPORT     void MakeEdge(const TopoDS_Edge& theE,
+				    TopoDS_Edge& theEnew) ;
+  
+  Standard_EXPORT     void MakeFace(const TopoDS_Face& theF,
+				    TopoDS_Face& theFnew) ;
+  
+  Standard_EXPORT     void TreatPair(const NMTTools_CoupleOfShape& theCS,
+				     NMTTools_ListOfCoupleOfShape& theLCS) ;
+
+protected:
+  TopTools_DataMapOfShapeListOfShape myShapesToGlue;
+  TopTools_DataMapOfShapeListOfShape myImagesDetected;
+  TopTools_DataMapOfShapeShape myOriginsDetected;
+  TopTools_DataMapOfShapeListOfShape myImagesToWork;
+  TopTools_DataMapOfShapeShape myOriginsToWork;
+  Standard_Boolean myKeepNonSolids;
+
+private:
+};
+#endif

src/GEOMAlgo/GEOMAlgo_Gluer2_1.cxx

@@ -0,0 +1,319 @@
+//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File:	GEOMAlgo_Gluer2_1.cxx
+// Created:	
+// Author:	Peter KURNEV
+//		<peter@PREFEX>
+//
+#include <GEOMAlgo_Gluer2.hxx>
+
+#include <gp_XYZ.hxx>
+#include <gp_Pnt.hxx>
+
+#include <TopLoc_Location.hxx>
+
+#include <Geom_Surface.hxx>
+
+#include <TopAbs_ShapeEnum.hxx>
+
+#include <TopoDS_Shape.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Iterator.hxx>
+
+#include <BRep_Tool.hxx>
+#include <BRep_Builder.hxx>
+
+#include <BRepTools.hxx>
+#include <TopExp.hxx>
+
+#include <TopTools_MapOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+
+#include <BOPTools_Tools.hxx>
+#include <BOPTools_Tools2D.hxx>
+#include <BOPTools_Tools3D.hxx>
+
+#include <GEOMAlgo_Tools.hxx>
+
+
+//=======================================================================
+//function : MakeBRepShapes
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::MakeBRepShapes(const TopoDS_Shape& theS, 
+				    TopoDS_Shape& theSnew)
+{
+  TopAbs_ShapeEnum aType;
+  //
+  aType=theS.ShapeType();
+  if (aType==TopAbs_EDGE) {
+    TopoDS_Edge aEE, aEEnew;
+    //
+    aEE=*((TopoDS_Edge*)&theS);
+    MakeEdge(aEE, aEEnew);
+    if (myErrorStatus) {
+      return;
+    }
+    //
+    theSnew=aEEnew;
+  }
+  else if (aType==TopAbs_FACE) {
+    TopoDS_Face aFF, aFFnew;
+    //
+    aFF=*((TopoDS_Face*)&theS);
+    MakeFace(aFF, aFFnew);
+    if (myErrorStatus) {
+      return;
+    }
+    //
+    theSnew=aFFnew;
+  }
+}
+//=======================================================================
+//function : MakeFace
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::MakeFace(const TopoDS_Face& theF, 
+			       TopoDS_Face& theFnew)
+{
+  Standard_Boolean bIsToReverse, bIsUPeriodic;
+  Standard_Real aTol, aUMin, aUMax, aVMin, aVMax;
+  TopAbs_Orientation aOrE;
+  Handle(Geom_Surface) aS;
+  TopLoc_Location aLoc;
+  TopoDS_Shape aW, aWr;
+  TopoDS_Edge aEx;
+  TopoDS_Face aFF, aFnew;
+  TopoDS_Iterator aItW, aItE;
+  BRep_Builder aBB;
+  TopTools_ListOfShape aLEr;
+  TopTools_ListIteratorOfListOfShape aItLE;
+  //
+  myErrorStatus=0;
+  //
+  aFF=theF;
+  aFF.Orientation(TopAbs_FORWARD);
+  //
+  aTol=BRep_Tool::Tolerance(aFF);
+  aS=BRep_Tool::Surface(aFF, aLoc);
+  bIsUPeriodic=GEOMAlgo_Tools::IsUPeriodic(aS);
+  BRepTools::UVBounds(aFF, aUMin, aUMax, aVMin, aVMax);
+  //
+  aBB.MakeFace (aFnew, aS, aLoc, aTol);
+  //
+  aItW.Initialize(aFF);
+  for (; aItW.More(); aItW.Next()) {
+    const TopoDS_Shape& aW=aItW.Value();
+    //
+    if (!myOrigins.IsBound(aW)) {
+      aBB.Add(aFnew, aW);
+      continue;
+    }
+    //
+    aWr=myOrigins.Find(aW);
+    //
+    // clear contents of Wr
+    aLEr.Clear();
+    aItE.Initialize(aWr);
+    for (; aItE.More(); aItE.Next()) {
+      const TopoDS_Shape& aEr=aItE.Value();
+      aLEr.Append(aEr);
+    }
+    //
+    aItLE.Initialize(aLEr);
+    for (; aItLE.More(); aItLE.Next()) {
+      const TopoDS_Shape& aEr=aItLE.Value();
+      aBB.Remove(aWr, aEr);
+    }
+    //
+    // refill contents of Wr
+    aItE.Initialize(aW);
+    for (; aItE.More(); aItE.Next()) {
+      const TopoDS_Edge& aE=*((TopoDS_Edge*)(&aItE.Value()));
+      //
+      aEx=aE;
+      if (myOrigins.IsBound(aE)) {
+	aEx=*((TopoDS_Edge*)(&myOrigins.Find(aE)));
+      }
+      //
+      if (!BRep_Tool::Degenerated(aEx)) {
+	aEx.Orientation(TopAbs_FORWARD);
+	if (bIsUPeriodic) {
+	  GEOMAlgo_Tools::RefinePCurveForEdgeOnFace(aEx, aFF, aUMin, aUMax);
+	}
+	BOPTools_Tools2D::BuildPCurveForEdgeOnFace(aEx, aFF);
+	//  
+	bIsToReverse=BOPTools_Tools3D::IsSplitToReverse1(aEx, aE, myContext);
+	if (bIsToReverse) {
+	  aEx.Reverse();
+	}
+      }
+      else {
+	aEx.Orientation(aE.Orientation());
+      }
+      aBB.Add(aWr, aEx);
+    }// for (; aItE.More(); aItE.Next()) {
+    //
+    aBB.Add(aFnew, aWr);
+  }// for (; aItW.More(); aItW.Next()) {
+  theFnew=aFnew;
+}
+//=======================================================================
+//function : MakeEdge
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::MakeEdge(const TopoDS_Edge& aE, 
+			       TopoDS_Edge& aNewEdge)
+{
+  myErrorStatus=0;
+  //
+  Standard_Boolean bIsDE;
+  Standard_Real aT1, aT2;
+  TopoDS_Vertex aV1, aV2, aVR1, aVR2;
+  TopoDS_Edge aEx;
+  //
+  bIsDE=BRep_Tool::Degenerated(aE);
+  //
+  aEx=aE;
+  aEx.Orientation(TopAbs_FORWARD);
+  //
+  TopExp::Vertices(aEx, aV1, aV2);
+  //
+  aT1=BRep_Tool::Parameter(aV1, aEx);
+  aT2=BRep_Tool::Parameter(aV2, aEx);
+  //
+  aVR1=aV1;
+  if (myOrigins.IsBound(aV1)) {
+    aVR1=*((TopoDS_Vertex*)&myOrigins.Find(aV1));
+  }
+  aVR1.Orientation(TopAbs_FORWARD);
+  //
+  aVR2=aV2;
+  if (myOrigins.IsBound(aV2)) {
+    aVR2=*((TopoDS_Vertex*)&myOrigins.Find(aV2));
+  }
+  aVR2.Orientation(TopAbs_REVERSED);
+  //
+  if (!bIsDE) {
+    BOPTools_Tools::MakeSplitEdge(aEx, aVR1, aT1, aVR2, aT2, aNewEdge); 
+  }
+  else {
+    Standard_Real aTol;
+    BRep_Builder aBB;
+    TopoDS_Edge E;
+    TopAbs_Orientation anOrE;
+    //
+    anOrE=aE.Orientation();
+    aTol=BRep_Tool::Tolerance(aE);
+    //
+    E=aEx;
+    E.EmptyCopy();
+    //
+    aBB.Add  (E, aVR1);
+    aBB.Add  (E, aVR2);
+    aBB.Range(E, aT1, aT2);
+    aBB.Degenerated(E, Standard_True);
+    aBB.UpdateEdge(E, aTol);
+    //
+    aNewEdge=E;
+  }
+}
+//=======================================================================
+//function : MakeVertex
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::MakeVertex(const TopTools_ListOfShape& aLV, 
+				 TopoDS_Vertex& aNewVertex)
+{
+  Standard_Integer aNbV;
+  Standard_Real aTolV, aD, aDmax;
+  gp_XYZ aGC;
+  gp_Pnt aP3D, aPGC;
+  TopoDS_Vertex aVx;
+  BRep_Builder aBB;
+  TopTools_ListIteratorOfListOfShape aIt;
+  //
+  aNbV=aLV.Extent();
+  if (!aNbV) {
+    return;
+  }
+  //
+  // center of gravity
+  aGC.SetCoord(0.,0.,0.);
+  aIt.Initialize(aLV);
+  for (; aIt.More(); aIt.Next()) {
+    aVx=*((TopoDS_Vertex*)(&aIt.Value()));
+    aP3D=BRep_Tool::Pnt(aVx);
+    aGC+=aP3D.XYZ();
+  }
+  aGC/=(Standard_Real)aNbV;
+  aPGC.SetXYZ(aGC);
+  //
+  // tolerance value
+  aDmax=-1.;
+  aIt.Initialize(aLV);
+  for (; aIt.More(); aIt.Next()) {
+    aVx=*((TopoDS_Vertex*)(&aIt.Value()));
+    aP3D=BRep_Tool::Pnt(aVx);
+    aTolV=BRep_Tool::Tolerance(aVx);
+    aD=aPGC.Distance(aP3D)+aTolV;
+    if (aD>aDmax) {
+      aDmax=aD;
+    }
+  }
+  //
+  aBB.MakeVertex (aNewVertex, aPGC, aDmax);
+}
+//=======================================================================
+//function : MapBRepShapes
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::MapBRepShapes(const TopoDS_Shape& aS,
+				    TopTools_MapOfShape& aM)
+{
+  Standard_Boolean bHasBRep;
+  TopAbs_ShapeEnum aType;
+  TopoDS_Iterator aIt;
+  //
+  aType=aS.ShapeType();
+  if (aType==TopAbs_VERTEX ||
+      aType==TopAbs_EDGE ||
+      aType==TopAbs_FACE) {
+    aM.Add(aS);
+  }
+  //
+  aIt.Initialize(aS);
+  for(; aIt.More(); aIt.Next()) {
+    const TopoDS_Shape& aSx=aIt.Value();
+    aType=aSx.ShapeType();
+    GEOMAlgo_Gluer2::MapBRepShapes(aSx, aM);
+  }
+}
+
+//
+// ErrorStatus
+//
+// 40   - GEOMAlgo_GlueDetector is failed

src/GEOMAlgo/GEOMAlgo_Gluer2_2.cxx

@@ -0,0 +1,156 @@
+//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File:	GEOMAlgo_Gluer2_2.cxx
+// Created:	
+// Author:	Peter KURNEV
+//		<peter@PREFEX>
+//
+#include <GEOMAlgo_Gluer2.hxx>
+
+#include <TopAbs_ShapeEnum.hxx>
+
+#include <TopoDS_Iterator.hxx>
+#include <TopoDS_Shape.hxx>
+
+#include <GEOMAlgo_BuilderShape.hxx>
+#include <GEOMAlgo_Tools3D.hxx>
+
+//=======================================================================
+//function : PrepareHistory
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::PrepareHistory()
+{
+  Standard_Boolean bHasImage, bContainsSD;
+  //
+  // 1. Clearing 
+  GEOMAlgo_BuilderShape::PrepareHistory();
+  //  
+  if(myShape.IsNull()) {
+    return;
+  }
+  //
+  GEOMAlgo_Gluer2::MapShapes(myShape, myMapShape);  
+  //
+}
+//=======================================================================
+//function : Generated
+//purpose  : 
+//=======================================================================
+const TopTools_ListOfShape& GEOMAlgo_Gluer2::Generated(const TopoDS_Shape& )
+{
+  myHistShapes.Clear();
+  return myHistShapes;
+}
+//=======================================================================
+//function : Modified
+//purpose  : 
+//=======================================================================
+const TopTools_ListOfShape& GEOMAlgo_Gluer2::Modified(const TopoDS_Shape& theS)
+{
+  Standard_Boolean bIsDeleted, bHasImage, bToReverse;
+  TopAbs_ShapeEnum aType;
+  TopoDS_Shape aSim;
+  //
+  myHistShapes.Clear();
+  //
+  aType=theS.ShapeType();
+  if (!(aType==TopAbs_VERTEX || aType==TopAbs_EDGE || 
+	aType==TopAbs_FACE || aType==TopAbs_SOLID)) { 
+    return myHistShapes;
+  }
+  //
+  bIsDeleted=IsDeleted(theS);
+  if (bIsDeleted) {
+    return myHistShapes;
+  }
+  //
+  bHasImage=myOrigins.IsBound(theS);
+  if (!bHasImage) {
+    return myHistShapes;
+  }
+  //
+  aSim=myOrigins.Find(theS);
+  if (aSim.IsSame(theS)){
+    return myHistShapes;
+  }
+  //
+  if (aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
+    aSim.Orientation(theS.Orientation());
+  }
+  else {
+    bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aSim, theS, myContext);
+    if (bToReverse) {
+      aSim.Reverse();
+    }
+  }
+  //
+  myHistShapes.Append(aSim);
+  //
+  return myHistShapes;
+}
+//=======================================================================
+//function : IsDeleted
+//purpose  : 
+//=======================================================================
+Standard_Boolean GEOMAlgo_Gluer2::IsDeleted(const TopoDS_Shape& theS)
+{
+  Standard_Boolean bRet, bContains, bHasImage;
+  //
+  bRet=Standard_False;
+  //
+  if (theS.IsNull()) {
+    return !bRet; //true
+  }
+  //
+  bContains=myMapShape.Contains(theS);
+  if (bContains) {
+    return bRet; //false
+  }
+  //
+  bHasImage=myOrigins.IsBound(theS);
+  if (bHasImage) {
+    const TopoDS_Shape& aSim=myOrigins.Find(theS);
+    bContains=myMapShape.Contains(aSim);
+    if (bContains) {
+      return bRet; //false
+    }
+  }
+  //
+  return !bRet; //true
+}
+//=======================================================================
+//function : MapShapes
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::MapShapes(const TopoDS_Shape& theS,
+				TopTools_MapOfShape& theM)
+{
+  TopoDS_Iterator aIt;
+  //
+  theM.Add(theS);
+  aIt.Initialize(theS);
+  for (; aIt.More(); aIt.Next()) {
+    const TopoDS_Shape& aSx=aIt.Value();
+    GEOMAlgo_Gluer2::MapShapes(aSx, theM);
+  }
+}

src/GEOMAlgo/GEOMAlgo_Gluer2_3.cxx

@@ -0,0 +1,347 @@
+//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File:	GEOMAlgo_Gluer2_3.cxx
+// Created:	
+// Author:	Peter KURNEV
+//		<peter@PREFEX>
+//
+#include <GEOMAlgo_Gluer2.hxx>
+
+#include <TopAbs_ShapeEnum.hxx>
+
+#include <TopoDS_Shape.hxx>
+#include <TopoDS_Edge.hxx>
+
+#include <BRep_Tool.hxx>
+
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+
+#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
+#include <TopTools_DataMapOfShapeListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_MapOfShape.hxx>
+#include <TopTools_MapIteratorOfMapOfShape.hxx>
+#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+
+#include <NMTTools_CoupleOfShape.hxx>
+#include <NMTTools_ListOfCoupleOfShape.hxx>
+#include <NMTTools_ListIteratorOfListOfCoupleOfShape.hxx>
+#include <NMTTools_IndexedDataMapOfShapeIndexedMapOfShape.hxx>
+#include <NMTTools_Tools.hxx>
+
+#include <GEOMAlgo_GlueDetector.hxx>
+
+
+static
+  void MapShapes1(const TopoDS_Shape& aS,
+		  const TopAbs_ShapeEnum aType,
+		  TopTools_IndexedMapOfShape& aM);
+
+//=======================================================================
+//function : Detect
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::Detect()
+{
+  Standard_Boolean bCheckGeometry;
+  Standard_Integer iErr, aNbSD;
+  TopTools_ListIteratorOfListOfShape aItLS;
+  TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS;
+  GEOMAlgo_GlueDetector aDetector;
+  //
+  myErrorStatus=0;
+  myWarningStatus=0;
+  //
+  myImagesDetected.Clear();
+  myOriginsDetected.Clear();
+  //
+  bCheckGeometry=Standard_True;
+  aDetector.SetArgument(myArgument);
+  aDetector.SetTolerance(myTolerance);
+  aDetector.SetCheckGeometry(bCheckGeometry);
+  //
+  aDetector.Perform();
+  iErr=aDetector.ErrorStatus();
+  if (iErr) {
+    myErrorStatus=11;// Detector failed
+    return;
+  }
+  //
+  const TopTools_DataMapOfShapeListOfShape& aImages=aDetector.Images();
+  aItDMSLS.Initialize(aImages);
+  for (; aItDMSLS.More(); aItDMSLS.Next()) {
+    const TopoDS_Shape& aSkey=aItDMSLS.Key();
+    const TopTools_ListOfShape& aLSD=aItDMSLS.Value();
+    aNbSD=aLSD.Extent();
+    myImagesDetected.Bind(aSkey, aLSD);
+  }
+  //
+  aItDMSLS.Initialize(myImagesDetected);
+  for (; aItDMSLS.More(); aItDMSLS.Next()) {
+    const TopoDS_Shape& aSkey=aItDMSLS.Key();
+    const TopTools_ListOfShape& aLSD=aItDMSLS.Value();
+    aItLS.Initialize(aLSD);
+    for (; aItLS.More(); aItLS.Next()) {
+      const TopoDS_Shape& aSx=aItLS.Value();
+      myOriginsDetected.Bind(aSx, aSkey);
+    }
+  }
+}
+//=======================================================================
+//function : PerformShapesToWork
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::PerformShapesToWork()
+{ 
+  Standard_Integer aNbSG, i, j, aNbC, aNb, aNbSD;
+  TopTools_ListIteratorOfListOfShape aItLS1, aItLS2;
+  TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS;
+  NMTTools_CoupleOfShape aCS;
+  NMTTools_ListOfCoupleOfShape aLCS;
+  NMTTools_ListIteratorOfListOfCoupleOfShape aItCS; 
+  //
+  myErrorStatus=0;
+  myWarningStatus=0;
+  //
+  myImagesToWork.Clear();
+  myOriginsToWork.Clear();
+  //
+  aNbSD=myImagesDetected.Extent();
+  if (!aNbSD) {// no shapes to glue detected
+    myWarningStatus=1;
+    return;
+  }
+  //
+  aNbSG=myShapesToGlue.Extent();
+  if (!aNbSG) {
+    // glue all possible
+    myImagesToWork=myImagesDetected;
+    //
+    aItDMSLS.Initialize(myImagesToWork);
+    for (; aItDMSLS.More(); aItDMSLS.Next()) {
+      const TopoDS_Shape& aSkey=aItDMSLS.Key();
+      const TopTools_ListOfShape& aLSD=aItDMSLS.Value();
+      aItLS1.Initialize(aLSD);
+      for (; aItLS1.More(); aItLS1.Next()) {
+	const TopoDS_Shape& aSx=aItLS1.Value();
+	myOriginsToWork.Bind(aSx, aSkey);
+      }
+    }
+    return;
+  }// if (!aNbSG) {
+  //
+  // 1. Make pairs
+  aItDMSLS.Initialize(myShapesToGlue);
+  for (; aItDMSLS.More(); aItDMSLS.Next()) {
+    const TopoDS_Shape& aSkey=aItDMSLS.Key();
+    const TopTools_ListOfShape& aLSG=aItDMSLS.Value();
+    aItLS1.Initialize(aLSG);
+    for (i=0; aItLS1.More(); aItLS1.Next(), ++i) {
+      aItLS2.Initialize(aLSG);
+      for (j=0; aItLS2.More(); aItLS2.Next(), ++j) {
+	if (j>i) {
+	  const TopoDS_Shape& aSG1=aItLS1.Value();
+	  const TopoDS_Shape& aSG2=aItLS2.Value();
+	  aCS.SetShape1(aSG1);
+	  aCS.SetShape2(aSG2);
+	  TreatPair(aCS, aLCS);
+	}
+      }
+    }
+  }
+  //
+  // 2. Find Chains
+  TopTools_ListOfShape aLSX;
+  NMTTools_IndexedDataMapOfShapeIndexedMapOfShape aMC;
+  //
+  NMTTools_Tools::FindChains(aLCS, aMC);
+  //
+  // 3. myImagesToWork, myOriginsToWork
+  aNbC=aMC.Extent();
+  for (i=1; i<=aNbC; ++i) {
+    const TopoDS_Shape& aSkey=aMC.FindKey(i);
+    const TopTools_IndexedMapOfShape& aM=aMC(i);
+    aLSX.Clear();
+    aNb=aM.Extent();
+    for (j=1; j<=aNb; ++j) {
+      const TopoDS_Shape& aS=aM(j);
+      aLSX.Append(aS);
+      myOriginsToWork.Bind(aS, aSkey);
+    }
+    myImagesToWork.Bind(aSkey, aLSX);
+  }
+}
+//=======================================================================
+//function : TreatPair
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_Gluer2::TreatPair(const NMTTools_CoupleOfShape& aCS,
+				NMTTools_ListOfCoupleOfShape& aLCS)
+{
+  if (myErrorStatus) {
+    return;
+  }
+  //
+  Standard_Integer i, aNbS1, aNbS2, aNbS;
+  TopAbs_ShapeEnum aType, aTypeS;
+  TopTools_ListIteratorOfListOfShape aItLS;
+  TopTools_IndexedMapOfShape aMS1, aMS2;
+  TopTools_DataMapOfShapeListOfShape aDMSLS;
+  TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS;
+  NMTTools_CoupleOfShape aCSS;
+  //
+  // 1. Checking the pair on whether it can be glued at all
+  // 1.1
+  const TopoDS_Shape& aS1=aCS.Shape1();
+  if (!myOriginsDetected.IsBound(aS1)) {
+    myErrorStatus=30;
+    return;
+  }
+  const TopoDS_Shape& aSkey1=myOriginsDetected.Find(aS1);
+  // 1.2
+  const TopoDS_Shape& aS2=aCS.Shape2();
+  if (!myOriginsDetected.IsBound(aS2)) {
+    myErrorStatus=30;
+    return;
+  }
+  const TopoDS_Shape& aSkey2=myOriginsDetected.Find(aS2);
+  // 1.3
+  if (!aSkey1.IsSame(aSkey2)) {
+    myErrorStatus=33;
+    return;
+  }
+  //
+  // 2. Append the pair to the aLCS
+  aLCS.Append(aCS);
+  //
+  // 3. Treatment the subshapes of the pair
+  aType=aS1.ShapeType();
+  if (aType==TopAbs_VERTEX) {
+    return;
+  }
+  aTypeS=TopAbs_EDGE;
+  if (aType==aTypeS) {
+    aTypeS=TopAbs_VERTEX;
+  }
+  //
+  MapShapes1(aS1, aTypeS, aMS1);
+  MapShapes1(aS2, aTypeS, aMS2);
+  //
+  aNbS1=aMS1.Extent();
+  aNbS2=aMS2.Extent();
+  if (aNbS1!=aNbS2) {
+    myErrorStatus=31;
+    return;
+  }
+  //
+  // 1.
+  for (i=1; i<=aNbS1; ++i) {
+    const TopoDS_Shape& aSS1=aMS1(i);
+    if (aMS2.Contains(aSS1)) {
+      continue;
+    }
+    //
+    if (!myOriginsDetected.IsBound(aSS1)) {
+      myErrorStatus=30;
+      return;
+    }
+    //
+    const TopoDS_Shape& aSkey=myOriginsDetected.Find(aSS1);
+    if (aDMSLS.IsBound(aSkey)) {
+      TopTools_ListOfShape& aLS=aDMSLS.ChangeFind(aSkey);
+      aLS.Append(aSS1);
+    }
+    else {
+      TopTools_ListOfShape aLS;
+      //
+      aLS.Append(aSS1);
+      aDMSLS.Bind(aSkey, aLS);
+    }
+  }
+  //
+  // 2.
+  for (i=1; i<=aNbS2; ++i) {
+    const TopoDS_Shape& aSS2=aMS2(i);
+    if (aMS1.Contains(aSS2)) {
+      continue;
+    }
+    //
+    if (!myOriginsDetected.IsBound(aSS2)) {
+      myErrorStatus=30;
+      return;
+    }
+    //
+    const TopoDS_Shape& aSkey=myOriginsDetected.Find(aSS2);
+    if (aDMSLS.IsBound(aSkey)) {
+      TopTools_ListOfShape& aLS=aDMSLS.ChangeFind(aSkey);
+      aLS.Append(aSS2);
+    }
+    else {
+      TopTools_ListOfShape aLS;
+      //
+      aLS.Append(aSS2);
+      aDMSLS.Bind(aSkey, aLS);
+    }
+  }
+  //
+  // 3.
+  aItDMSLS.Initialize(aDMSLS);
+  for (; aItDMSLS.More(); aItDMSLS.Next()) {
+    const TopoDS_Shape& aSkey=aItDMSLS.Key();
+    const TopTools_ListOfShape& aLS=aItDMSLS.Value();
+    aNbS=aLS.Extent();
+    if (aNbS!=2) {
+      myErrorStatus=32;
+      return;
+    }
+    //
+    const TopoDS_Shape& aSS1=aLS.First();
+    const TopoDS_Shape& aSS2=aLS.Last();
+    aCSS.SetShape1(aSS1);
+    aCSS.SetShape2(aSS2);
+    TreatPair(aCSS, aLCS);
+  }
+}
+//=======================================================================
+//function : MapShapes1
+//purpose  : 
+//=======================================================================
+void MapShapes1(const TopoDS_Shape& aS,
+	       const TopAbs_ShapeEnum aType,
+	       TopTools_IndexedMapOfShape& aM)
+{
+  TopExp_Explorer aEx (aS, aType);
+  while (aEx.More()) {
+    const TopoDS_Shape aSx=aEx.Current();
+    if (aType==TopAbs_EDGE) {
+      const TopoDS_Edge& aEx=*((TopoDS_Edge*)&aSx);
+      if (BRep_Tool::Degenerated(aEx)) {
+	continue;
+      }
+    }
+    aM.Add(aSx);
+    aEx.Next();
+  }
+}

src/GEOMAlgo/GEOMAlgo_GluerAlgo.cxx

@@ -0,0 +1,134 @@
+//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File:	GEOMAlgo_GluerAlgo.cxx
+// Created:	
+// Author:	Peter KURNEV
+//		<peter@PREFEX>
+//
+#include <GEOMAlgo_GluerAlgo.hxx>
+
+
+//=======================================================================
+//function : GEOMAlgo_GluerAlgo
+//purpose  : 
+//=======================================================================
+GEOMAlgo_GluerAlgo::GEOMAlgo_GluerAlgo()
+{
+  myTolerance=0.0001;
+  myCheckGeometry=Standard_True;
+}
+//=======================================================================
+//function : ~GEOMAlgo_GluerAlgo
+//purpose  : 
+//=======================================================================
+GEOMAlgo_GluerAlgo::~GEOMAlgo_GluerAlgo()
+{
+}
+//=======================================================================
+//function : SetArgument
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GluerAlgo::SetArgument(const TopoDS_Shape& theShape)
+{
+  myArgument=theShape;
+}
+//=======================================================================
+//function : Argument
+//purpose  : 
+//=======================================================================
+const TopoDS_Shape& GEOMAlgo_GluerAlgo::Argument()const
+{
+  return myArgument;
+}
+//=======================================================================
+//function : SetTolerance
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GluerAlgo::SetTolerance(const Standard_Real aT)
+{
+  myTolerance=aT;
+}
+//=======================================================================
+//function : Tolerance
+//purpose  : 
+//=======================================================================
+Standard_Real GEOMAlgo_GluerAlgo::Tolerance()const
+{
+  return myTolerance;
+}
+
+//=======================================================================
+//function : SetCheckGeometry
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GluerAlgo::SetCheckGeometry(const Standard_Boolean aFlag)
+{
+  myCheckGeometry=aFlag;
+}
+//=======================================================================
+//function : CheckGeometry
+//purpose  : 
+//=======================================================================
+Standard_Boolean GEOMAlgo_GluerAlgo::CheckGeometry() const
+{
+  return myCheckGeometry;
+}
+//=======================================================================
+//function : Context
+//purpose  : 
+//=======================================================================
+IntTools_Context& GEOMAlgo_GluerAlgo::Context()
+{
+  return myContext;
+}
+//=======================================================================
+//function : Images
+//purpose  : 
+//=======================================================================
+const TopTools_DataMapOfShapeListOfShape& GEOMAlgo_GluerAlgo::Images()const
+{
+  return myImages;
+}
+//=======================================================================
+//function : Origins
+//purpose  : 
+//=======================================================================
+const TopTools_DataMapOfShapeShape& GEOMAlgo_GluerAlgo::Origins()const
+{
+  return myOrigins;
+}
+//=======================================================================
+//function : Clear
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GluerAlgo::Clear()
+{
+  myImages.Clear();
+  myOrigins.Clear();
+}
+//=======================================================================
+//function : Perform
+//purpose  : 
+//=======================================================================
+void GEOMAlgo_GluerAlgo::Perform()
+{
+}

src/GEOMAlgo/GEOMAlgo_GluerAlgo.hxx

@@ -0,0 +1,95 @@
+//  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File:        GEOMAlgo_GluerAlgo.hxx
+// Created:     
+// Author:      Peter KURNEV
+//              <pkv@irinox>
+//
+#ifndef _GEOMAlgo_GluerAlgo_HeaderFile
+#define _GEOMAlgo_GluerAlgo_HeaderFile
+
+#include <Standard_Macro.hxx>
+#include <TopoDS_Shape.hxx>
+#include <Standard_Real.hxx>
+#include <Standard_Boolean.hxx>
+#include <IntTools_Context.hxx>
+#include <TopTools_DataMapOfShapeListOfShape.hxx>
+#include <TopTools_DataMapOfShapeShape.hxx>
+#include <GEOMAlgo_BuilderShape.hxx>
+
+//=======================================================================
+//class    : GEOMAlgo_GluerAlgo
+//purpose  : 
+//=======================================================================
+class GEOMAlgo_GluerAlgo {
+public:
+
+  Standard_EXPORT 
+    GEOMAlgo_GluerAlgo();
+
+  Standard_EXPORT 
+    virtual ~GEOMAlgo_GluerAlgo();
+
+  Standard_EXPORT 
+    virtual void SetArgument(const TopoDS_Shape& theShape) ;
+
+  Standard_EXPORT 
+    const TopoDS_Shape& Argument() const;
+  
+  Standard_EXPORT 
+    void SetTolerance(const Standard_Real aT) ;
+  
+  Standard_EXPORT 
+    Standard_Real Tolerance() const;
+  
+  Standard_EXPORT 
+    void SetCheckGeometry(const Standard_Boolean aFlag) ;
+  
+  Standard_EXPORT 
+    Standard_Boolean CheckGeometry() const;
+  
+  Standard_EXPORT 
+    virtual  void Perform() ;
+  
+  Standard_EXPORT 
+    virtual  void Clear() ;
+  
+  Standard_EXPORT 
+    IntTools_Context& Context() ;
+  
+  Standard_EXPORT 
+    const TopTools_DataMapOfShapeListOfShape& Images() const;
+  
+  Standard_EXPORT 
+    const TopTools_DataMapOfShapeShape& Origins() const;
+
+protected:
+  TopoDS_Shape myArgument;
+  Standard_Real myTolerance;
+  Standard_Boolean myCheckGeometry;
+  IntTools_Context myContext;
+  TopTools_DataMapOfShapeListOfShape myImages;
+  TopTools_DataMapOfShapeShape myOrigins;
+  
+private:
+};
+#endif

src/GEOMAlgo/Makefile.am

@@ -15,14 +15,11 @@
 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
 #  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
+
-#
 #  GEOM GEOMAlgo : tools for Glue Faces algorithm
 #  File   : Makefile.in
 #  Author : Julia DOROVSKIKH
-#  Modified by : Alexander BORODIN (OCN) - autotools usage
 #  Module : GEOM
-#  $Header$
 
 include $(top_srcdir)/adm_local/unix/make_common_starter.am
 
@@ -78,6 +75,12 @@ dist_libGEOMAlgo_la_SOURCES =			\
 	GEOMAlgo_FinderShapeOnQuad.cxx		\
 	GEOMAlgo_GlueAnalyser.cxx		\
 	GEOMAlgo_Gluer.cxx			\
+	GEOMAlgo_GlueDetector.cxx		\
+	GEOMAlgo_Gluer2.cxx			\
+	GEOMAlgo_Gluer2_1.cxx			\
+	GEOMAlgo_Gluer2_2.cxx			\
+	GEOMAlgo_Gluer2_3.cxx			\
+	GEOMAlgo_GluerAlgo.cxx			\
 	GEOMAlgo_Gluer1.cxx			\
 	GEOMAlgo_HAlgo.cxx			\
 	GEOMAlgo_IndexedDataMapNodeOfIndexedDataMapOfIntegerShape_0.cxx			\
@@ -223,6 +226,9 @@ salomeinclude_HEADERS =					\
 	GEOMAlgo_Gluer1.hxx			\
 	GEOMAlgo_Gluer1.ixx			\
 	GEOMAlgo_Gluer1.jxx			\
+	GEOMAlgo_GlueDetector.hxx		\
+	GEOMAlgo_Gluer2.hxx			\
+	GEOMAlgo_GluerAlgo.hxx			\
 	GEOMAlgo_HAlgo.hxx			\
 	GEOMAlgo_HAlgo.ixx			\
 	GEOMAlgo_HAlgo.jxx			\

src/GEOMGUI/GEOM_images.ts

@@ -277,6 +277,14 @@
             <source>ICON_DLG_GLUE_FACES2</source>
             <translation>glue2.png</translation>
         </message>
+        <message>
+            <source>ICON_DLG_GLUE_EDGES</source>
+            <translation>glue.png</translation>
+        </message>
+        <message>
+            <source>ICON_DLG_GLUE_EDGES2</source>
+            <translation>glue2.png</translation>
+        </message>
         <message>
             <source>ICON_DLG_LIMIT_TOLERANCE</source>
             <translation>limit_tolerance.png</translation>
@@ -861,6 +869,10 @@
             <source>ICO_GLUE_FACES</source>
             <translation>glue.png</translation>
         </message>
+        <message>
+            <source>ICO_GLUE_EDGES</source>
+            <translation>glue.png</translation>
+        </message>
         <message>
             <source>ICO_LIMIT_TOLERANCE</source>
             <translation>limit_tolerance.png</translation>

src/GEOMGUI/GEOM_msg_en.ts

@@ -754,9 +754,13 @@ Please, select face, shell or solid and try again</translation>
         <translation>Glue</translation>
     </message>
     <message>
-        <source>GEOM_GLUE_TITLE</source>
+        <source>GEOM_GLUE_FACES_TITLE</source>
         <translation>Glue faces</translation>
     </message>
+    <message>
+        <source>GEOM_GLUE_EDGES_TITLE</source>
+        <translation>Glue edges</translation>
+    </message>
     <message>
         <source>GEOM_LIMIT_TOLERANCE_TITLE</source>
         <translation>Limit tolerance</translation>
@@ -2341,6 +2345,10 @@ Please, select face, shell or solid and try again</translation>
         <source>MEN_GLUE_FACES</source>
         <translation>Glue Faces</translation>
     </message>
+    <message>
+        <source>MEN_GLUE_EDGES</source>
+        <translation>Glue Edges</translation>
+    </message>
     <message>
         <source>MEN_GROUP</source>
         <translation>Group</translation>
@@ -2480,7 +2488,7 @@ Please, select face, shell or solid and try again</translation>
     <message>
         <source>MEN_POP_PUBLISH_OBJ</source>
         <translation>Publish...</translation>
-    </message>			    			    
+    </message>
     <message>
         <source>MEN_POP_ISOS</source>
         <translation>Isos</translation>
@@ -3005,6 +3013,10 @@ Please, select face, shell or solid and try again</translation>
         <source>STB_GLUE_FACES</source>
         <translation>Perform glue faces</translation>
     </message>
+    <message>
+        <source>STB_GLUE_EDGES</source>
+        <translation>Perform glue edges</translation>
+    </message>
     <message>
         <source>STB_GROUP_CREATE</source>
         <translation>Create a group</translation>
@@ -3119,12 +3131,12 @@ Please, select face, shell or solid and try again</translation>
     </message>
     <message>
         <source>STB_POP_UNPUBLISH_OBJ</source>
-	<translation>Unpublish object</translation>
+        <translation>Unpublish object</translation>
    </message>
     <message>
         <source>STB_POP_PUBLISH_OBJ</source>
         <translation>Publish object</translation>
-   </message>		          			    
+   </message>
     <message>
         <source>STB_POP_HIDE_CHILDREN</source>
         <translation>Hide child objects</translation>
@@ -3545,6 +3557,10 @@ Please, select face, shell or solid and try again</translation>
         <source>TOP_GLUE_FACES</source>
         <translation>Perform glue faces</translation>
     </message>
+    <message>
+        <source>TOP_GLUE_EDGES</source>
+        <translation>Perform glue edges</translation>
+    </message>
     <message>
         <source>TOP_GROUP_CREATE</source>
         <translation>Create a group</translation>
@@ -3656,11 +3672,11 @@ Please, select face, shell or solid and try again</translation>
     <message>
         <source>TOP_POP_UNPUBLISH_OBJ</source>
         <translation>Unpublish object</translation>
-    </message> 
+    </message>
     <message>
         <source>TOP_POP_PUBLISH_OBJ</source>
-	<translation>Publish object</translation>
+        <translation>Publish object</translation>
-   </message>			    
+   </message>
     <message>
         <source>TOP_POP_HIDE_CHILDREN</source>
         <translation>Hide Children</translation>
@@ -4642,20 +4658,37 @@ Number of sketch points too small</translation>
     <message>
         <source>FACES_FOR_GLUING_ARE_DETECTED</source>
         <translation>There are %1 face(s) that can be glued. They are coloured on the screen with red colour.
-Please close this message box and select faces for glueing</translation>
+Please close this message box and select faces for gluing</translation>
+    </message>
+    <message>
+        <source>EDGES_FOR_GLUING_ARE_DETECTED</source>
+        <translation>There are %1 edge(s) that can be glued. They are coloured on the screen with red colour.
+Please close this message box and select edges for gluing</translation>
     </message>
     <message>
         <source>GLUE_FACES</source>
         <translation>Glue faces</translation>
     </message>
+    <message>
+        <source>GLUE_EDGES</source>
+        <translation>Glue edges</translation>
+    </message>
     <message>
         <source>SELECT_FACES</source>
         <translation>Select Faces</translation>
     </message>
+    <message>
+        <source>SELECT_EDGES</source>
+        <translation>Select Edges</translation>
+    </message>
     <message>
         <source>THERE_ARE_NO_FACES_FOR_GLUING</source>
         <translation>There are no faces for gluing</translation>
     </message>
+    <message>
+        <source>THERE_ARE_NO_EDGES_FOR_GLUING</source>
+        <translation>There are no edges for gluing</translation>
+    </message>
 </context>
 <context>
     <name>RepairGUI_ShapeProcessDlg</name>
@@ -4848,31 +4881,31 @@ Would you like to continue?</translation>
     <name>GEOMToolsGUI_PublishDlg</name>
     <message>
         <source>GEOM_PUBLISH_OBJECTS_TLT</source>
-	<translation>Publish Objects</translation>
+        <translation>Publish Objects</translation>
-    </message>			            
-    <message>
-	<source>OBJECT_NAME</source>
-	<translation>Name</translation>
     </message>
     <message>
-	<source>OBJECT_ENTRY</source>
+      <source>OBJECT_NAME</source>
-	<translation>Entry</translation>
+      <translation>Name</translation>
-    </message>    
+    </message>
+    <message>
+      <source>OBJECT_ENTRY</source>
+      <translation>Entry</translation>
+    </message>
     <message>
         <source>UNSELECT_ALL</source>
         <translation>U&amp;nselect All</translation>
     </message>
-    <message>    
+    <message>
         <source>SELECT_ALL</source>
-	<translation>Select &amp;All</translation>
+        <translation>Select &amp;All</translation>
     </message>
     <message>
         <source>GEOM_PUBLISH_BTN</source>
-	<translation>&amp;Publish</translation>
+        <translation>&amp;Publish</translation>
     </message>
     <message>
         <source>GEOM_PUBLISH_CLOSE_BTN</source>
-	<translation>P&amp;ublish And Close</translation>
+        <translation>P&amp;ublish And Close</translation>
-    </message>			        
+    </message>
 </context>
 </TS>

src/GEOMGUI/GeometryGUI.cxx

@@ -496,6 +496,7 @@ void GeometryGUI::OnGUIEvent( int id )
   case GEOMOp::OpFreeFaces:        // MENU MEASURE - FREE FACES
   case GEOMOp::OpOrientation:      // MENU REPAIR - CHANGE ORIENTATION
   case GEOMOp::OpGlueFaces:        // MENU REPAIR - GLUE FACES
+  case GEOMOp::OpGlueEdges:        // MENU REPAIR - GLUE EDGES
   case GEOMOp::OpLimitTolerance:   // MENU REPAIR - LIMIT TOLERANCE
   case GEOMOp::OpRemoveExtraEdges: // MENU REPAIR - REMOVE EXTRA EDGES
     libName = "RepairGUI";
@@ -730,6 +731,7 @@ void GeometryGUI::initialize( CAM_Application* app )
 
   createGeomAction( GEOMOp::OpSewing,           "SEWING" );
   createGeomAction( GEOMOp::OpGlueFaces,        "GLUE_FACES" );
+  createGeomAction( GEOMOp::OpGlueEdges,        "GLUE_EDGES" );
   createGeomAction( GEOMOp::OpLimitTolerance,   "LIMIT_TOLERANCE" );
   createGeomAction( GEOMOp::OpSuppressFaces,    "SUPPRESS_FACES" );
   createGeomAction( GEOMOp::OpSuppressHoles,    "SUPPERSS_HOLES" );
@@ -932,6 +934,7 @@ void GeometryGUI::initialize( CAM_Application* app )
   createMenu( GEOMOp::OpSuppressHoles,   repairId, -1 );
   createMenu( GEOMOp::OpSewing,          repairId, -1 );
   createMenu( GEOMOp::OpGlueFaces,       repairId, -1 );
+  createMenu( GEOMOp::OpGlueEdges,       repairId, -1 );
   createMenu( GEOMOp::OpLimitTolerance,  repairId, -1 );
   createMenu( GEOMOp::OpAddPointOnEdge,  repairId, -1 );
   //createMenu( GEOMOp::OpFreeBoundaries,  repairId, -1 );

src/GEOMGUI/GeometryGUI_Operations.h

@@ -139,6 +139,7 @@ namespace GEOMOp {
     OpGlueFaces         = 4010,   // MENU REPAIR - GLUE FACES
     OpRemoveExtraEdges  = 4011,   // MENU REPAIR - REMOVE EXTRA EDGES
     OpLimitTolerance    = 4012,   // MENU REPAIR - LIMIT TOLERANCE
+    OpGlueEdges         = 4013,   // MENU REPAIR - GLUE EDGES
     // MeasureGUI ----------------//--------------------------------
     OpProperties        = 5000,   // MENU MEASURES - PROPERTIES
     OpCenterMass        = 5001,   // MENU MEASURES - CENTRE OF MASS

src/GEOMImpl/GEOMImpl_GlueDriver.cxx

@@ -18,7 +18,6 @@
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 //
 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
 
 #include <Standard_Stream.hxx>
 
@@ -31,6 +30,7 @@
 
 #include <GEOMAlgo_Gluer.hxx>
 #include "GEOMAlgo_Gluer1.hxx"
+#include "GEOMAlgo_Gluer2.hxx"
 #include "GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx"
 #include "GEOMAlgo_CoupleOfShapes.hxx"
 #include "GEOMAlgo_ListOfCoupleOfShapes.hxx"
@@ -41,8 +41,9 @@
 
 #include <TopExp.hxx>
 #include <TopoDS_Shape.hxx>
-#include <TopTools_ListOfShape.hxx>
+#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
 #include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
 #include <TopTools_ListIteratorOfListOfShape.hxx>
 
 #include <ShapeFix_Shape.hxx>
@@ -75,6 +76,7 @@ const Standard_GUID& GEOMImpl_GlueDriver::GetID()
 //function : GlueFacesWithWarnings
 //purpose  :
 //=======================================================================
+/*
 TopoDS_Shape GEOMImpl_GlueDriver::GlueFacesWithWarnings (const TopoDS_Shape& theShape,
                                                          const Standard_Real theTolerance,
                                                          const Standard_Boolean doKeepNonSolids,
@@ -155,7 +157,6 @@ TopoDS_Shape GEOMImpl_GlueDriver::GlueFacesWithWarnings (const TopoDS_Shape& the
   aSfs->Perform();
   aRes = aSfs->Shape();
 
-
   // Fill history to be used by GetInPlace functionality
   TopTools_IndexedMapOfShape aResIndices;
   TopExp::MapShapes(aRes, aResIndices);
@@ -204,7 +205,6 @@ TopoDS_Shape GEOMImpl_GlueDriver::GlueFacesWithWarnings (const TopoDS_Shape& the
   return aRes;
 }
 
-
 //=======================================================================
 //function : GlueFaces
 //purpose  :
@@ -213,7 +213,6 @@ TopoDS_Shape GEOMImpl_GlueDriver::GlueFaces (const TopoDS_Shape& theShape,
                                              const Standard_Real theTolerance,
                                              const Standard_Boolean doKeepNonSolids)
 {
-  Standard_Integer iErr, iWrn;
   TopoDS_Shape aRes;
   GEOMAlgo_Gluer aGluer;
 
@@ -224,7 +223,7 @@ TopoDS_Shape GEOMImpl_GlueDriver::GlueFaces (const TopoDS_Shape& theShape,
 
   aGluer.Perform();
 
-  iErr = aGluer.ErrorStatus();
+  Standard_Integer iErr = aGluer.ErrorStatus();
   if (iErr) {
     switch (iErr) {
     case 2:
@@ -251,7 +250,7 @@ TopoDS_Shape GEOMImpl_GlueDriver::GlueFaces (const TopoDS_Shape& theShape,
     return aRes;
   }
 
-  iWrn = aGluer.WarningStatus();
+  Standard_Integer iWrn = aGluer.WarningStatus();
   if (iWrn) {
     switch (iWrn) {
     case 1:
@@ -269,7 +268,6 @@ TopoDS_Shape GEOMImpl_GlueDriver::GlueFaces (const TopoDS_Shape& theShape,
   return aRes;
 }
 
-
 //=======================================================================
 //function : GlueFacesByList
 //purpose  :
@@ -301,14 +299,14 @@ TopoDS_Shape GEOMImpl_GlueDriver::GlueFacesByList (const TopoDS_Shape& theShape,
     const GEOMAlgo_CoupleOfShapes& aCSG = aItCS.Value();
     const TopoDS_Shape& aF1 = aCSG.Shape1();
     const TopoDS_Shape& aF2 = aCSG.Shape2();
-    if( aFaces.Contains(aF1) || aFaces.Contains(aF2) )
+    if (aFaces.Contains(aF1) || aFaces.Contains(aF2))
       continue;
     aCS.SetShapes(aF1,aF2);
     aLCS.Append(aCS);
   }
 
   //cout<<"aLCS.Extent() = "<<aLCS.Extent()<<endl;
-  if(aLCS.Extent()>0) {
+  if (aLCS.Extent()>0) {
     aGluer.SetFacesToUnglue(aLCS);
     aGluer.UnglueFaces();
     iErr = aGluer.ErrorStatus();
@@ -319,7 +317,348 @@ TopoDS_Shape GEOMImpl_GlueDriver::GlueFacesByList (const TopoDS_Shape& theShape,
 
   return aRes;
 }
+*/
 
+//=======================================================================
+//function : GlueFaces
+//purpose  :
+//=======================================================================
+TopoDS_Shape GEOMImpl_GlueDriver::GlueFaces (const TopoDS_Shape& theShape,
+                                             const Standard_Real theTolerance,
+                                             const Standard_Boolean doKeepNonSolids)
+{
+  TopoDS_Shape aRes;
+
+  GEOMAlgo_Gluer2 aGA;
+
+  // 1. Initialization
+  aGA.SetArgument(theShape);
+  aGA.SetTolerance(theTolerance);
+  aGA.SetKeepNonSolids(doKeepNonSolids);
+
+  // 2. Detect interferred shapes
+  aGA.Detect();
+  Standard_Integer iErr = aGA.ErrorStatus();
+  if (iErr) {
+    switch (iErr) {
+    case 11:
+      Standard_Failure::Raise("GEOMAlgo_GlueDetector failed");
+      break;
+    case 13:
+    case 14:
+      Standard_Failure::Raise("PerformImagesToWork failed");
+      break;
+    default:
+      {
+        // description of all errors see in GEOMAlgo_Gluer2.cxx
+        TCollection_AsciiString aMsg ("Error in GEOMAlgo_Gluer2 with code ");
+        aMsg += TCollection_AsciiString(iErr);
+        Standard_Failure::Raise(aMsg.ToCString());
+        break;
+      }
+    }
+    return aRes;
+  }
+
+  // 3. Set shapes to glue. If the operator is absent, the whole gluing will be done
+  //aGA.SetShapesToGlue(aMSG);
+
+  // 4. Gluing
+  aGA.Perform();
+  iErr = aGA.ErrorStatus();
+  if (iErr) {
+    switch (iErr) {
+    case 11:
+      Standard_Failure::Raise("GEOMAlgo_GlueDetector failed");
+      break;
+    case 13:
+    case 14:
+      Standard_Failure::Raise("PerformImagesToWork failed");
+      break;
+    default:
+      {
+        // description of all errors see in GEOMAlgo_Gluer2.cxx
+        TCollection_AsciiString aMsg ("Error in GEOMAlgo_Gluer2 with code ");
+        aMsg += TCollection_AsciiString(iErr);
+        Standard_Failure::Raise(aMsg.ToCString());
+        break;
+      }
+    }
+    return aRes;
+  }
+
+  Standard_Integer iWrn = aGA.WarningStatus();
+  if (iWrn) {
+    switch (iWrn) {
+    case 1:
+      MESSAGE("No shapes to glue");
+      break;
+    default:
+      // description of all warnings see in GEOMAlgo_Gluer2.cxx
+      MESSAGE("Warning in GEOMAlgo_Gluer2 with code " << iWrn);
+      break;
+    }
+  }
+
+  // 5. Result
+  aRes = aGA.Shape();
+
+  return aRes;
+}
+
+//=======================================================================
+//function : GlueWithWarnings
+//purpose  :
+//=======================================================================
+TopoDS_Shape GEOMImpl_GlueDriver::GlueWithWarnings (const TopoDS_Shape& theShape,
+                                                    const Standard_Real theTolerance,
+                                                    const TopAbs_ShapeEnum theShapeType,
+                                                    const Standard_Boolean doKeepNonSolids,
+                                                    TCollection_AsciiString& theWarning) const
+{
+  TopoDS_Shape aRes;
+
+  GEOMAlgo_Gluer2 aGA;
+
+  // 1. Initialization
+  aGA.SetArgument(theShape);
+  aGA.SetTolerance(theTolerance);
+  aGA.SetKeepNonSolids(doKeepNonSolids);
+
+  // 2. Detect interferred shapes
+  aGA.Detect();
+  Standard_Integer iErr = aGA.ErrorStatus();
+  if (iErr) {
+    switch (iErr) {
+    case 11:
+      Standard_Failure::Raise("GEOMAlgo_GlueDetector failed");
+      break;
+    case 13:
+    case 14:
+      Standard_Failure::Raise("PerformImagesToWork failed");
+      break;
+    default:
+      {
+        // description of all errors see in GEOMAlgo_Gluer2.cxx
+        TCollection_AsciiString aMsg ("Error in GEOMAlgo_Gluer2 with code ");
+        aMsg += TCollection_AsciiString(iErr);
+        Standard_Failure::Raise(aMsg.ToCString());
+        break;
+      }
+    }
+    return aRes;
+  }
+
+  // 3. Fill shapes to glue aMSG
+  TopTools_DataMapOfShapeListOfShape aMSG;
+  const TopTools_DataMapOfShapeListOfShape& aMSD = aGA.ShapesDetected();
+  TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItMSD;
+  aItMSD.Initialize(aMSD);
+  for (; aItMSD.More(); aItMSD.Next()) {
+    const TopoDS_Shape& aSx = aItMSD.Key();
+    const TopTools_ListOfShape& aLSD = aItMSD.Value();
+    if (aSx.ShapeType() == theShapeType) {
+      aMSG.Bind(aSx, aLSD);
+    }
+  }
+
+  // 4. Set shapes to glue. If the operator is absent, the whole gluing will be done
+  aGA.SetShapesToGlue(aMSG);
+
+  // 5. Gluing
+  aGA.Perform();
+  iErr = aGA.ErrorStatus();
+  if (iErr) {
+    switch (iErr) {
+    case 11:
+      Standard_Failure::Raise("GEOMAlgo_GlueDetector failed");
+      break;
+    case 13:
+    case 14:
+      Standard_Failure::Raise("PerformImagesToWork failed");
+      break;
+    default:
+      {
+        // description of all errors see in GEOMAlgo_Gluer2.cxx
+        TCollection_AsciiString aMsg ("Error in GEOMAlgo_Gluer2 with code ");
+        aMsg += TCollection_AsciiString(iErr);
+        Standard_Failure::Raise(aMsg.ToCString());
+        break;
+      }
+    }
+    return aRes;
+  }
+
+  Standard_Integer iWrn = aGA.WarningStatus();
+  if (iWrn) {
+    switch (iWrn) {
+    case 1:
+      theWarning = "No shapes to glue";
+      break;
+    default:
+      // description of all warnings see in GEOMAlgo_Gluer2.cxx
+      theWarning = "Warning in GEOMAlgo_Gluer2 with code ";
+      theWarning += TCollection_AsciiString(iWrn);
+      break;
+    }
+  }
+
+  // 6. Result
+  aRes = aGA.Shape();
+
+  // 7. Fill history to be used by GetInPlace functionality
+  TopTools_IndexedMapOfShape aResIndices;
+  TopExp::MapShapes(aRes, aResIndices);
+
+  Handle(GEOM_Function) aFunction = GEOM_Function::GetFunction(Label());
+
+  // history for all argument shapes
+  TDF_LabelSequence aLabelSeq;
+  aFunction->GetDependency(aLabelSeq);
+  Standard_Integer nbArg = aLabelSeq.Length();
+
+  for (Standard_Integer iarg = 1; iarg <= nbArg; iarg++) {
+
+    TDF_Label anArgumentRefLabel = aLabelSeq.Value(iarg);
+
+    Handle(GEOM_Object) anArgumentObject = GEOM_Object::GetReferencedObject(anArgumentRefLabel);
+    TopoDS_Shape anArgumentShape = anArgumentObject->GetValue();
+
+    TopTools_IndexedMapOfShape anArgumentIndices;
+    TopExp::MapShapes(anArgumentShape, anArgumentIndices);
+    Standard_Integer nbArgumentEntities = anArgumentIndices.Extent();
+
+    // Find corresponding label in history
+    TDF_Label anArgumentHistoryLabel =
+      aFunction->GetArgumentHistoryEntry(anArgumentRefLabel, Standard_True);
+
+    for (Standard_Integer ie = 1; ie <= nbArgumentEntities; ie++) {
+      TopoDS_Shape anEntity = anArgumentIndices.FindKey(ie);
+      const TopTools_ListOfShape& aModified = aGA.Modified(anEntity);
+      Standard_Integer nbModified = aModified.Extent();
+
+      if (nbModified > 0) {
+        TDF_Label aWhatHistoryLabel = anArgumentHistoryLabel.FindChild(ie, Standard_True);
+        Handle(TDataStd_IntegerArray) anAttr =
+          TDataStd_IntegerArray::Set(aWhatHistoryLabel, 1, nbModified);
+
+        TopTools_ListIteratorOfListOfShape itM (aModified);
+        for (int im = 1; itM.More(); itM.Next(), ++im) {
+          int id = aResIndices.FindIndex(itM.Value());
+          anAttr->SetValue(im, id);
+        }
+      }
+    }
+  }
+
+  return aRes;
+}
+
+//=======================================================================
+//function : GlueByList
+//purpose  :
+//=======================================================================
+TopoDS_Shape GEOMImpl_GlueDriver::GlueByList (const TopoDS_Shape& theShape,
+                                              const Standard_Real theTolerance,
+                                              const Standard_Boolean doKeepNonSolids,
+                                              const TopTools_MapOfShape& theShapesList)
+{
+  TopoDS_Shape aRes;
+
+  GEOMAlgo_Gluer2 aGA;
+
+  // 1. Initialization
+  aGA.SetArgument(theShape);
+  aGA.SetTolerance(theTolerance);
+  aGA.SetKeepNonSolids(doKeepNonSolids);
+
+  // 2. Detect interferred shapes
+  aGA.Detect();
+  Standard_Integer iErr = aGA.ErrorStatus();
+  if (iErr) {
+    switch (iErr) {
+    case 11:
+      Standard_Failure::Raise("GEOMAlgo_GlueDetector failed");
+      break;
+    case 13:
+    case 14:
+      Standard_Failure::Raise("PerformImagesToWork failed");
+      break;
+    default:
+      {
+        // description of all errors see in GEOMAlgo_Gluer2.cxx
+        TCollection_AsciiString aMsg ("Error in GEOMAlgo_Gluer2 with code ");
+        aMsg += TCollection_AsciiString(iErr);
+        Standard_Failure::Raise(aMsg.ToCString());
+        break;
+      }
+    }
+    return aRes;
+  }
+
+  // 3. Fill shapes to glue aMSG
+  TopTools_DataMapOfShapeListOfShape aMSG;
+  const TopTools_DataMapOfShapeListOfShape& aMSD = aGA.ShapesDetected();
+  TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItMSD;
+  aItMSD.Initialize(aMSD);
+  for (; aItMSD.More(); aItMSD.Next()) {
+    const TopoDS_Shape& aSx = aItMSD.Key();
+    const TopTools_ListOfShape& aLSD = aItMSD.Value();
+    TopTools_ListIteratorOfListOfShape anItLSD (aLSD);
+    bool isToGlue = false;
+    for (; anItLSD.More() && !isToGlue; anItLSD.Next()) {
+      if (theShapesList.Contains(anItLSD.Value())) {
+        isToGlue = true;
+        aMSG.Bind(aSx, aLSD);
+      }
+    }
+  }
+
+  // 4. Set shapes to glue. If the operator is absent, the whole gluing will be done
+  aGA.SetShapesToGlue(aMSG);
+
+  // 5. Gluing
+  aGA.Perform();
+  iErr = aGA.ErrorStatus();
+  if (iErr) {
+    switch (iErr) {
+    case 11:
+      Standard_Failure::Raise("GEOMAlgo_GlueDetector failed");
+      break;
+    case 13:
+    case 14:
+      Standard_Failure::Raise("PerformImagesToWork failed");
+      break;
+    default:
+      {
+        // description of all errors see in GEOMAlgo_Gluer2.cxx
+        TCollection_AsciiString aMsg ("Error in GEOMAlgo_Gluer2 with code ");
+        aMsg += TCollection_AsciiString(iErr);
+        Standard_Failure::Raise(aMsg.ToCString());
+        break;
+      }
+    }
+    return aRes;
+  }
+
+  Standard_Integer iWrn = aGA.WarningStatus();
+  if (iWrn) {
+    switch (iWrn) {
+    case 1:
+      MESSAGE("No shapes to glue");
+      break;
+    default:
+      // description of all warnings see in GEOMAlgo_Gluer2.cxx
+      MESSAGE("Warning in GEOMAlgo_Gluer2 with code " << iWrn);
+      break;
+    }
+  }
+
+  // 6. Result
+  aRes = aGA.Shape();
+
+  return aRes;
+}
 
 //=======================================================================
 //function : Execute
@@ -347,26 +686,31 @@ Standard_Integer GEOMImpl_GlueDriver::Execute(TFunction_Logbook& log) const
   Standard_Boolean aKeepNonSolids = aCI.GetKeepNonSolids();
 
   if (aType == GLUE_FACES) {
-    aShape = GlueFacesWithWarnings(aShapeBase, tol3d, aKeepNonSolids, aWrn);
+    //aShape = GlueFacesWithWarnings(aShapeBase, tol3d, aKeepNonSolids, aWrn);
+    aShape = GlueWithWarnings(aShapeBase, tol3d, TopAbs_FACE, aKeepNonSolids, aWrn);
   }
-  else { // aType == GLUE_FACES_BY_LIST
+  else if (aType == GLUE_EDGES) {
+    aShape = GlueWithWarnings(aShapeBase, tol3d, TopAbs_EDGE, aKeepNonSolids, aWrn);
+  }
+  else if (aType == GLUE_FACES_BY_LIST || aType == GLUE_EDGES_BY_LIST) {
     Handle(TColStd_HSequenceOfTransient) SF = aCI.GetFaces();
     TopTools_MapOfShape aFaces;
-    int i=1;
+    int i = 1;
-    for( ; i <= SF->Length(); i++) {
+    for (; i <= SF->Length(); i++) {
       Handle(Standard_Transient) anItem = SF->Value(i);
-      if(anItem.IsNull())
+      if (anItem.IsNull())
         continue;
       Handle(GEOM_Function) aRefSh = Handle(GEOM_Function)::DownCast(anItem);
-      if(aRefSh.IsNull())
+      if (aRefSh.IsNull())
         continue;
       TopoDS_Shape aFace = aRefSh->GetValue();
-      if(aFace.IsNull())
+      if (aFace.IsNull())
         continue;
-      if(!aFaces.Contains(aFace))
+      if (!aFaces.Contains(aFace))
         aFaces.Add(aFace);
     }
-    aShape = GlueFacesByList(aShapeBase, tol3d, aKeepNonSolids, aFaces);
+    //aShape = GlueFacesByList(aShapeBase, tol3d, aKeepNonSolids, aFaces);
+    aShape = GlueByList(aShapeBase, tol3d, aKeepNonSolids, aFaces);
   }
 
   if (aShape.IsNull()) return 0;
@@ -390,11 +734,11 @@ Standard_EXPORT Handle_Standard_Type& GEOMImpl_GlueDriver_Type_()
 {
 
   static Handle_Standard_Type aType1 = STANDARD_TYPE(TFunction_Driver);
-  if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TFunction_Driver);
+  if (aType1.IsNull()) aType1 = STANDARD_TYPE(TFunction_Driver);
   static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared);
-  if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
+  if (aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
   static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient);
-  if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
+  if (aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
 
 
   static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
@@ -421,5 +765,5 @@ const Handle(GEOMImpl_GlueDriver) Handle(GEOMImpl_GlueDriver)::DownCast(const Ha
      }
   }
 
-  return _anOtherObject ;
+  return _anOtherObject;
 }

src/GEOMImpl/GEOMImpl_GlueDriver.hxx

@@ -18,11 +18,10 @@
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 //
 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
 
 //  File   : GEOMImpl_GlueDriver.ixx
 //  Module : GEOMImpl
-//
+
 #ifndef _GEOMImpl_GlueDriver_HeaderFile
 #define _GEOMImpl_GlueDriver_HeaderFile
 
@@ -155,7 +154,7 @@ Standard_EXPORT ~GEOMImpl_GlueDriver() {};
 Standard_EXPORT static TopoDS_Shape GlueFaces (const TopoDS_Shape& theShape,
                                                const Standard_Real theTolerance,
                                                const Standard_Boolean doKeepNonSolids = Standard_True);
-
+  /*
 Standard_EXPORT TopoDS_Shape GlueFacesWithWarnings (const TopoDS_Shape& theShape,
                                                     const Standard_Real theTolerance,
                                                     const Standard_Boolean doKeepNonSolids,
@@ -165,6 +164,17 @@ Standard_EXPORT static TopoDS_Shape GlueFacesByList (const TopoDS_Shape& theShap
                                                      const Standard_Real theTolerance,
                                                      const Standard_Boolean doKeepNonSolids,
                                                      const TopTools_MapOfShape& aFaces);
+  */
+Standard_EXPORT TopoDS_Shape GlueWithWarnings (const TopoDS_Shape& theShape,
+                                               const Standard_Real theTolerance,
+                                               const TopAbs_ShapeEnum theShapeType,
+                                               const Standard_Boolean doKeepNonSolids,
+                                               TCollection_AsciiString& theWarning) const;
+
+Standard_EXPORT static TopoDS_Shape GlueByList (const TopoDS_Shape& theShape,
+                                                const Standard_Real theTolerance,
+                                                const Standard_Boolean doKeepNonSolids,
+                                                const TopTools_MapOfShape& theShapesList);
 
 
  // Type management

src/GEOMImpl/GEOMImpl_IShapesOperations.cxx

@@ -51,6 +51,7 @@
 #include "GEOMAlgo_ClsfBox.hxx"
 #include "GEOMAlgo_ClsfSolid.hxx"
 #include "GEOMAlgo_Gluer1.hxx"
+#include "GEOMAlgo_GlueDetector.hxx"
 #include "GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx"
 #include "GEOMAlgo_CoupleOfShapes.hxx"
 #include "GEOMAlgo_ListOfCoupleOfShapes.hxx"
@@ -82,6 +83,8 @@
 
 #include <TopAbs.hxx>
 #include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopLoc_Location.hxx>
 #include <TopoDS.hxx>
 #include <TopoDS_Shape.hxx>
 #include <TopoDS_Solid.hxx>
@@ -90,13 +93,12 @@
 #include <TopoDS_Vertex.hxx>
 #include <TopoDS_Compound.hxx>
 #include <TopoDS_Iterator.hxx>
-#include <TopExp_Explorer.hxx>
+#include <TopTools_Array1OfShape.hxx>
-#include <TopLoc_Location.hxx>
+#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
 #include <TopTools_MapOfShape.hxx>
 #include <TopTools_MapOfOrientedShape.hxx>
-#include <TopTools_Array1OfShape.hxx>
-#include <TopTools_ListIteratorOfListOfShape.hxx>
-#include <TopTools_IndexedMapOfShape.hxx>
 
 #include <Geom_Surface.hxx>
 #include <Geom_Plane.hxx>
@@ -721,6 +723,7 @@ Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeGlueFaces
  *  GetGlueFaces
  */
 //=============================================================================
+/*
 Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetGlueFaces
                                                 (Handle(GEOM_Object) theShape,
                                                  const Standard_Real theTolerance)
@@ -781,7 +784,7 @@ Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetGlueFaces
   if( anAsciiList.Length() > 0 ) {
     anAsciiList.Trunc(anAsciiList.Length() - 1);
     Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
-    GEOM::TPythonDump pd (aFunction, /*append=*/true);
+    GEOM::TPythonDump pd (aFunction, true);
     pd << "[" << anAsciiList.ToCString();
     pd << "] = geompy.GetGlueFaces(" << theShape << ", " << theTolerance << ")";
   }
@@ -790,6 +793,7 @@ Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetGlueFaces
 
   return aSeq;
 }
+*/
 
 //=============================================================================
 /*!
@@ -880,6 +884,233 @@ Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeGlueFacesByList
   return aGlued;
 }
 
+//=============================================================================
+/*!
+ *  MakeGlueEdges
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeGlueEdges
+                                                (Handle(GEOM_Object) theShape,
+                                                 const Standard_Real theTolerance)
+{
+  SetErrorCode(KO);
+
+  if (theShape.IsNull()) return NULL;
+
+  //Add a new Glued object
+  Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GetDocID(), GEOM_GLUED);
+
+  //Add a new Glue function
+  Handle(GEOM_Function) aFunction;
+  aFunction = aGlued->AddFunction(GEOMImpl_GlueDriver::GetID(), GLUE_EDGES);
+  if (aFunction.IsNull()) return NULL;
+
+  //Check if the function is set correctly
+  if (aFunction->GetDriverGUID() != GEOMImpl_GlueDriver::GetID()) return NULL;
+
+  GEOMImpl_IGlue aCI (aFunction);
+
+  Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
+  if (aRefShape.IsNull()) return NULL;
+
+  aCI.SetBase(aRefShape);
+  aCI.SetTolerance(theTolerance);
+  aCI.SetKeepNonSolids(true);
+
+  //Compute the sub-shape value
+  Standard_Boolean isWarning = Standard_False;
+  try {
+#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
+    OCC_CATCH_SIGNALS;
+#endif
+    if (!GetSolver()->ComputeFunction(aFunction)) {
+      SetErrorCode("Shape driver failed to glue edges");
+      return NULL;
+    }
+  }
+  catch (Standard_Failure) {
+    Handle(Standard_Failure) aFail = Standard_Failure::Caught();
+    SetErrorCode(aFail->GetMessageString());
+    // to provide warning
+    if (!aFunction->GetValue().IsNull()) {
+      isWarning = Standard_True;
+    } else {
+      return NULL;
+    }
+  }
+
+  //Make a Python command
+  GEOM::TPythonDump(aFunction) << aGlued << " = geompy.MakeGlueEdges("
+    << theShape << ", " << theTolerance << ")";
+
+  // to provide warning
+  if (!isWarning) SetErrorCode(OK);
+  return aGlued;
+}
+
+//=============================================================================
+/*!
+ *  GetGlueShapes
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetGlueShapes
+                                                (Handle(GEOM_Object)    theShape,
+                                                 const Standard_Real    theTolerance,
+                                                 const TopAbs_ShapeEnum theType)
+{
+  SetErrorCode(KO);
+
+  if (theShape.IsNull()) return NULL;
+  TopoDS_Shape aShape = theShape->GetValue();
+  if (aShape.IsNull()) return NULL;
+
+  Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+  GEOMAlgo_GlueDetector aGluer;
+  aGluer.SetArgument(aShape);
+  aGluer.SetTolerance(theTolerance);
+  aGluer.Perform();
+  Standard_Integer iErr = aGluer.ErrorStatus();
+  if (iErr) return NULL;
+
+  TCollection_AsciiString anAsciiList, anEntry;
+  TopTools_IndexedMapOfShape anIndices;
+  TopExp::MapShapes(aShape, anIndices);
+  Handle(TColStd_HArray1OfInteger) anArray;
+  Handle(GEOM_Object) anObj;
+
+  const TopTools_DataMapOfShapeListOfShape& aImages = aGluer.Images();
+  TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS (aImages);
+  for (int index = 1; aItDMSLS.More(); aItDMSLS.Next(), ++index) {
+    // some key shape
+    //const TopoDS_Shape& aSkey = aItDMSLS.Key();  
+
+    // list of shapes of the argument that can be glued
+    const TopTools_ListOfShape& aLSD = aItDMSLS.Value(); 
+
+    //listShape.Append(aLSD.First());
+    TopoDS_Shape aValue = aLSD.First();
+
+    if (aValue.ShapeType() == theType) {
+      anArray = new TColStd_HArray1OfInteger(1,1);
+      anArray->SetValue(1, anIndices.FindIndex(aValue));
+      anObj = GetEngine()->AddSubShape(theShape, anArray);
+      if (!anObj.IsNull()) {
+        aSeq->Append(anObj);
+
+        // for python command
+        TDF_Tool::Entry(anObj->GetEntry(), anEntry);
+        anAsciiList += anEntry;
+        anAsciiList += ",";
+      }
+    }
+  }
+
+  // Make a Python command
+  if (anAsciiList.Length() > 0) {
+    anAsciiList.Trunc(anAsciiList.Length() - 1);
+    Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
+    GEOM::TPythonDump pd (aFunction, /*append=*/true);
+    pd << "[" << anAsciiList.ToCString();
+    if (theType == TopAbs_FACE)
+      pd << "] = geompy.GetGlueFaces(" << theShape << ", " << theTolerance << ")";
+    else if (theType == TopAbs_EDGE)
+      pd << "] = geompy.GetGlueEdges(" << theShape << ", " << theTolerance << ")";
+  }
+
+  SetErrorCode(OK);
+
+  return aSeq;
+}
+
+//=============================================================================
+/*!
+ *  MakeGlueEdgesByList
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeGlueEdgesByList
+                                                (Handle(GEOM_Object) theShape,
+                                                 const Standard_Real theTolerance,
+                                                 std::list<Handle(GEOM_Object)> theEdges)
+{
+  SetErrorCode(KO);
+
+  if (theShape.IsNull()) return NULL;
+
+  //Add a new Glued object
+  Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GetDocID(), GEOM_GLUED);
+
+  //Add a new Glue function
+  Handle(GEOM_Function) aFunction;
+  aFunction = aGlued->AddFunction(GEOMImpl_GlueDriver::GetID(), GLUE_EDGES_BY_LIST);
+  if (aFunction.IsNull()) return NULL;
+
+  //Check if the function is set correctly
+  if (aFunction->GetDriverGUID() != GEOMImpl_GlueDriver::GetID()) return NULL;
+
+  GEOMImpl_IGlue aCI (aFunction);
+
+  Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
+  if (aRefShape.IsNull()) return NULL;
+
+  aCI.SetBase(aRefShape);
+  aCI.SetTolerance(theTolerance);
+  aCI.SetKeepNonSolids(true);
+
+  Handle(TColStd_HSequenceOfTransient) anEdges = new TColStd_HSequenceOfTransient;
+  std::list<Handle(GEOM_Object)>::iterator it = theEdges.begin();
+  for (; it != theEdges.end(); it++) {
+    Handle(GEOM_Function) aRefSh = (*it)->GetLastFunction();
+    if (aRefSh.IsNull()) {
+      SetErrorCode("NULL argument shape for the shape construction");
+      return NULL;
+    }
+    anEdges->Append(aRefSh);
+  }
+  aCI.SetFaces(anEdges);
+
+  //Compute the sub-shape value
+  Standard_Boolean isWarning = Standard_False;
+  try {
+#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
+    OCC_CATCH_SIGNALS;
+#endif
+    if (!GetSolver()->ComputeFunction(aFunction)) {
+      SetErrorCode("Shape driver failed to glue edges");
+      return NULL;
+    }
+  }
+  catch (Standard_Failure) {
+    Handle(Standard_Failure) aFail = Standard_Failure::Caught();
+    SetErrorCode(aFail->GetMessageString());
+    // to provide warning
+    if (!aFunction->GetValue().IsNull()) {
+      isWarning = Standard_True;
+    } else {
+      return NULL;
+    }
+  }
+
+  //Make a Python command
+
+  GEOM::TPythonDump pd (aFunction);
+  pd << aGlued << " = geompy.MakeGlueEdgesByList("
+     << theShape << ", " << theTolerance << ", [";
+  // Edges
+  it = theEdges.begin();
+  if (it != theEdges.end()) {
+    pd << (*it++);
+    while (it != theEdges.end()) {
+      pd << ", " << (*it++);
+    }
+  }
+  pd << "])";
+
+  // to provide warning
+  if (!isWarning) SetErrorCode(OK);
+  return aGlued;
+}
+
 //=============================================================================
 /*!
  *  GetExistingSubObjects

src/GEOMImpl/GEOMImpl_IShapesOperations.hxx

@@ -81,14 +81,25 @@ class GEOMImpl_IShapesOperations : public GEOM_IOperations
                                                      const Standard_Real theTolerance,
                                                      const Standard_Boolean doKeepNonSolids);
 
-  Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetGlueFaces (Handle(GEOM_Object) theShape,
+  //Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetGlueFaces (Handle(GEOM_Object) theShape,
-                                                                     const Standard_Real theTolerance);
+  //                                                                   const Standard_Real theTolerance);
 
   Standard_EXPORT Handle(GEOM_Object) MakeGlueFacesByList (Handle(GEOM_Object) theShape,
                                                            const Standard_Real theTolerance,
                                                            std::list<Handle(GEOM_Object)> theFaces,
                                                            const Standard_Boolean doKeepNonSolids);
 
+  Standard_EXPORT Handle(GEOM_Object) MakeGlueEdges (Handle(GEOM_Object) theShape,
+                                                     const Standard_Real theTolerance);
+
+  Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetGlueShapes (Handle(GEOM_Object) theShape,
+                                                                      const Standard_Real theTolerance,
+                                                                      const TopAbs_ShapeEnum theType);
+
+  Standard_EXPORT Handle(GEOM_Object) MakeGlueEdgesByList (Handle(GEOM_Object) theShape,
+                                                           const Standard_Real theTolerance,
+                                                           std::list<Handle(GEOM_Object)> theEdges);
+
   Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetExistingSubObjects
     (Handle(GEOM_Object)    theShape,
      const Standard_Boolean theGroupsOnly);

src/GEOMImpl/GEOMImpl_Types.hxx

@@ -275,8 +275,10 @@
 
 #define BASIC_FILLING 1
 
-#define GLUE_FACES 1
+#define GLUE_FACES         1
 #define GLUE_FACES_BY_LIST 2
+#define GLUE_EDGES         3
+#define GLUE_EDGES_BY_LIST 4
 
 #define SKETCHER_NINE_DOUBLS 1
 #define SKETCHER_PLANE 2

src/GEOM_I/GEOM_IShapesOperations_i.cc

@@ -398,7 +398,6 @@ GEOM::GEOM_Object_ptr GEOM_IShapesOperations_i::MakeGlueFaces
   return GetObject(anObject);
 }
 
-
 //=============================================================================
 /*!
  *  GetGlueFaces
@@ -418,7 +417,8 @@ GEOM::ListOfGO* GEOM_IShapesOperations_i::GetGlueFaces
   if (aShape.IsNull()) return aSeq._retn();
 
   Handle(TColStd_HSequenceOfTransient) aHSeq =
-    GetOperations()->GetGlueFaces(aShape, theTolerance);
+    //GetOperations()->GetGlueFaces(aShape, theTolerance);
+    GetOperations()->GetGlueShapes(aShape, theTolerance, TopAbs_FACE);
 
   //if (!GetOperations()->IsDone() || aHSeq.IsNull())
   // to allow warning
@@ -433,7 +433,6 @@ GEOM::ListOfGO* GEOM_IShapesOperations_i::GetGlueFaces
   return aSeq._retn();
 }
 
-
 //=============================================================================
 /*!
  *  MakeGlueFacesByList
@@ -475,6 +474,109 @@ GEOM::GEOM_Object_ptr GEOM_IShapesOperations_i::MakeGlueFacesByList
   return GetObject(anObject);
 }
 
+//=============================================================================
+/*!
+ *  MakeGlueEdges
+ */
+//=============================================================================
+GEOM::GEOM_Object_ptr GEOM_IShapesOperations_i::MakeGlueEdges
+                                           (GEOM::GEOM_Object_ptr theShape,
+                                            CORBA::Double   theTolerance)
+{
+  GEOM::GEOM_Object_var aGEOMObject;
+
+  //Set a not done flag
+  GetOperations()->SetNotDone();
+
+  //Get the reference objects
+  Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
+  if (aShape.IsNull()) return aGEOMObject._retn();
+
+  //Perform the gluing
+  Handle(GEOM_Object) anObject =
+    GetOperations()->MakeGlueEdges(aShape, theTolerance);
+  //if (!GetOperations()->IsDone() || anObject.IsNull())
+  // to allow warning
+  if (anObject.IsNull())
+    return aGEOMObject._retn();
+
+  return GetObject(anObject);
+}
+
+//=============================================================================
+/*!
+ *  GetGlueEdges
+ */
+//=============================================================================
+GEOM::ListOfGO* GEOM_IShapesOperations_i::GetGlueEdges
+                                           (GEOM::GEOM_Object_ptr theShape,
+                                            const CORBA::Double   theTolerance)
+{
+  GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
+
+  //Set a not done flag
+  GetOperations()->SetNotDone();
+
+  //Get the reference objects
+  Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
+  if (aShape.IsNull()) return aSeq._retn();
+
+  Handle(TColStd_HSequenceOfTransient) aHSeq =
+    GetOperations()->GetGlueShapes(aShape, theTolerance, TopAbs_EDGE);
+
+  //if (!GetOperations()->IsDone() || aHSeq.IsNull())
+  // to allow warning
+  if (aHSeq.IsNull())
+    return aSeq._retn();
+
+  Standard_Integer aLength = aHSeq->Length();
+  aSeq->length(aLength);
+  for (Standard_Integer i = 1; i <= aLength; i++)
+    aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
+
+  return aSeq._retn();
+}
+
+//=============================================================================
+/*!
+ *  MakeGlueEdgesByList
+ */
+//=============================================================================
+GEOM::GEOM_Object_ptr GEOM_IShapesOperations_i::MakeGlueEdgesByList
+                                           (GEOM::GEOM_Object_ptr theShape,
+                                            CORBA::Double   theTolerance,
+                                            const GEOM::ListOfGO& theEdges)
+{
+  GEOM::GEOM_Object_var aGEOMObject;
+
+  //Set a not done flag
+  GetOperations()->SetNotDone();
+
+  //Get the reference objects
+  Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
+  if (aShape.IsNull()) return aGEOMObject._retn();
+
+  int ind, aLen;
+  std::list<Handle(GEOM_Object)> anEdges;
+  //Get the shapes
+  aLen = theEdges.length();
+  for (ind = 0; ind < aLen; ind++) {
+    Handle(GEOM_Object) aSh = GetObjectImpl(theEdges[ind]);
+    if (aSh.IsNull()) return aGEOMObject._retn();
+    anEdges.push_back(aSh);
+  }
+
+  //Perform the gluing
+  Handle(GEOM_Object) anObject =
+    GetOperations()->MakeGlueEdgesByList(aShape, theTolerance, anEdges);
+  //if (!GetOperations()->IsDone() || anObject.IsNull())
+  // to allow warning
+  if (anObject.IsNull())
+    return aGEOMObject._retn();
+
+  return GetObject(anObject);
+}
+
 //=============================================================================
 /*!
  *  GetExistingSubObjects

src/GEOM_I/GEOM_IShapesOperations_i.hh

@@ -82,6 +82,16 @@ class GEOM_I_EXPORT GEOM_IShapesOperations_i :
                                              const GEOM::ListOfGO& theFaces,
                                              CORBA::Boolean  doKeepNonSolids);
 
+  GEOM::GEOM_Object_ptr MakeGlueEdges (GEOM::GEOM_Object_ptr theShape,
+                                       CORBA::Double         theTolerance);
+
+  GEOM::ListOfGO* GetGlueEdges (GEOM::GEOM_Object_ptr theShape,
+                                CORBA::Double         theTolerance);
+
+  GEOM::GEOM_Object_ptr MakeGlueEdgesByList (GEOM::GEOM_Object_ptr theShape,
+                                             CORBA::Double         theTolerance,
+                                             const GEOM::ListOfGO& theEdges);
+
   GEOM::ListOfGO* GetExistingSubObjects (GEOM::GEOM_Object_ptr theShape,
                                          CORBA::Boolean        theGroupsOnly);
 

src/GEOM_SWIG/geompyDC.py

@@ -2565,6 +2565,51 @@ class geompyDC(GEOM._objref_GEOM_Gen):
                 raise RuntimeError, "MakeGlueFacesByList : " + self.ShapesOp.GetErrorCode()
             return anObj
 
+        ## Replace coincident edges in theShape by one edge.
+        #  @param theShape Initial shape.
+        #  @param theTolerance Maximum distance between edges, which can be considered as coincident.
+        #  @return New GEOM_Object, containing a copy of theShape without coincident edges.
+        #
+        #  @ref tui_glue_faces "Example"
+        def MakeGlueEdges(self, theShape, theTolerance):
+            # Example: see GEOM_Spanner.py
+            theTolerance,Parameters = ParseParameters(theTolerance)
+            anObj = self.ShapesOp.MakeGlueEdges(theShape, theTolerance)
+            if anObj is None:
+                raise RuntimeError, "MakeGlueEdges : " + self.ShapesOp.GetErrorCode()
+            anObj.SetParameters(Parameters)
+            return anObj
+
+        ## Find coincident edges in theShape for possible gluing.
+        #  @param theShape Initial shape.
+        #  @param theTolerance Maximum distance between edges,
+        #                      which can be considered as coincident.
+        #  @return ListOfGO.
+        #
+        #  @ref tui_glue_faces "Example"
+        def GetGlueEdges(self, theShape, theTolerance):
+            # Example: see GEOM_Spanner.py
+            anObj = self.ShapesOp.GetGlueEdges(theShape, theTolerance)
+            RaiseIfFailed("GetGlueEdges", self.ShapesOp)
+            return anObj
+
+        ## Replace coincident edges in theShape by one edge
+        #  in compliance with given list of edges
+        #  @param theShape Initial shape.
+        #  @param theTolerance Maximum distance between edges,
+        #                      which can be considered as coincident.
+        #  @param theFaces List of edges for gluing.
+        #  @return New GEOM_Object, containing a copy of theShape
+        #          without some edges.
+        #
+        #  @ref tui_glue_faces "Example"
+        def MakeGlueEdgesByList(self, theShape, theTolerance, theEdges):
+            # Example: see GEOM_Spanner.py
+            anObj = self.ShapesOp.MakeGlueEdgesByList(theShape, theTolerance, theEdges)
+            if anObj is None:
+                raise RuntimeError, "MakeGlueEdgesByList : " + self.ShapesOp.GetErrorCode()
+            return anObj
+
         # end of l3_healing
         ## @}
 

src/RepairGUI/RepairGUI.cxx

@@ -76,9 +76,10 @@ bool RepairGUI::OnGUIEvent( int theCommandID, SUIT_Desktop* parent )
   getGeometryGUI()->EmitSignalDeactivateDialog();
 
   QDialog* aDlg = NULL;
-  switch ( theCommandID ) {
+  switch (theCommandID) {
   case GEOMOp::OpSewing:           aDlg = new RepairGUI_SewingDlg            (getGeometryGUI(), parent); break;
-  case GEOMOp::OpGlueFaces:        aDlg = new RepairGUI_GlueDlg              (getGeometryGUI(), parent); break;
+  case GEOMOp::OpGlueFaces: aDlg = new RepairGUI_GlueDlg (getGeometryGUI(), parent, false, TopAbs_FACE); break;
+  case GEOMOp::OpGlueEdges: aDlg = new RepairGUI_GlueDlg (getGeometryGUI(), parent, false, TopAbs_EDGE); break;
   case GEOMOp::OpLimitTolerance:   aDlg = new RepairGUI_LimitToleranceDlg    (getGeometryGUI(), parent); break;
   case GEOMOp::OpSuppressFaces:    aDlg = new RepairGUI_SuppressFacesDlg     (getGeometryGUI(), parent); break;
   case GEOMOp::OpSuppressHoles:    aDlg = new RepairGUI_RemoveHolesDlg       (getGeometryGUI(), parent); break;
@@ -91,11 +92,11 @@ bool RepairGUI::OnGUIEvent( int theCommandID, SUIT_Desktop* parent )
   case GEOMOp::OpOrientation:      aDlg = new RepairGUI_ChangeOrientationDlg (getGeometryGUI(), parent); break;
   case GEOMOp::OpRemoveExtraEdges: aDlg = new RepairGUI_RemoveExtraEdgesDlg  (getGeometryGUI(), parent); break;
     default:
-      app->putInfo( tr( "GEOM_PRP_COMMAND" ).arg( theCommandID ) );
+      app->putInfo(tr("GEOM_PRP_COMMAND").arg(theCommandID));
       break;
   }
 
-  if ( aDlg )
+  if (aDlg)
     aDlg->show();
 
   return true;

src/RepairGUI/RepairGUI_GlueDlg.cxx

@@ -18,12 +18,11 @@
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 //
 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
 
 // GEOM RepairGUI : GUI for Geometry component
 // File   : RepairGUI_GlueDlg.cxx
-// Author : Lucien PIGNOLONI, Open CASCADE S.A.S. 
+// Author : Lucien PIGNOLONI, Open CASCADE S.A.S.
-//
+
 #include "RepairGUI_GlueDlg.h"
 
 #include <DlgRef.h>
@@ -32,9 +31,9 @@
 #include <SalomeApp_DoubleSpinBox.h>
 
 #include <SalomeApp_Application.h>
-#include <LightApp_SelectionMgr.h>
 #include <SalomeApp_Study.h>
 #include <SalomeApp_Tools.h>
+#include <LightApp_SelectionMgr.h>
 #include <SUIT_Session.h>
 #include <SUIT_Desktop.h>
 #include <SUIT_MessageBox.h>
@@ -58,81 +57,102 @@
 //            The dialog will by default be modeless, unless you set 'modal' to
 //            TRUE to construct a modal dialog.
 //=================================================================================
-RepairGUI_GlueDlg::RepairGUI_GlueDlg( GeometryGUI* theGeometryGUI, QWidget* parent,
+RepairGUI_GlueDlg::RepairGUI_GlueDlg(GeometryGUI* theGeometryGUI, QWidget* parent,
-                                      bool modal )
+                                     bool modal, TopAbs_ShapeEnum theGlueMode)
-  : GEOMBase_Skeleton( theGeometryGUI, parent, modal ),
+  : GEOMBase_Skeleton(theGeometryGUI, parent, modal),
-    myCurrConstrId( -1 )
+    myCurrConstrId(-1), myGlueMode(theGlueMode)
 {
-  QPixmap image0( SUIT_Session::session()->resourceMgr()->loadPixmap( "GEOM", tr( "ICON_DLG_GLUE_FACES" ) ) );
+  QPixmap image0 (SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_SELECT")));
-  QPixmap image2( SUIT_Session::session()->resourceMgr()->loadPixmap( "GEOM", tr( "ICON_DLG_GLUE_FACES2" )  ));
+  QPixmap image1 (SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_DLG_GLUE_FACES")));
-  QPixmap image1( SUIT_Session::session()->resourceMgr()->loadPixmap( "GEOM", tr( "ICON_SELECT" ) ) );
+  QPixmap image2 (SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_DLG_GLUE_FACES2")));
+  QPixmap image3 (SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_DLG_GLUE_EDGES")));
+  QPixmap image4 (SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_DLG_GLUE_EDGES2")));
 
-  setWindowTitle( tr( "GEOM_GLUE_TITLE" ) );
+  QString aTitle;
+  if (theGlueMode == TopAbs_FACE)
+    aTitle = tr("GEOM_GLUE_FACES_TITLE");
+  else if (theGlueMode == TopAbs_EDGE)
+    aTitle = tr("GEOM_GLUE_EDGES_TITLE");
+  setWindowTitle(aTitle);
 
   /***************************************************************/
-  mainFrame()->GroupConstructors->setTitle( tr( "GEOM_GLUE_TITLE" ) );
+  mainFrame()->GroupConstructors->setTitle(aTitle);
-  mainFrame()->RadioButton1->setIcon( image0 );
+  if (theGlueMode == TopAbs_FACE) {
-  mainFrame()->RadioButton2->setIcon( image2 );
+    mainFrame()->RadioButton1->setIcon(image1);
-  mainFrame()->RadioButton3->setAttribute( Qt::WA_DeleteOnClose );
+    mainFrame()->RadioButton2->setIcon(image2);
+  }
+  else if (theGlueMode == TopAbs_EDGE) {
+    mainFrame()->RadioButton1->setIcon(image3);
+    mainFrame()->RadioButton2->setIcon(image4);
+  }
+  mainFrame()->RadioButton3->setAttribute(Qt::WA_DeleteOnClose);
   mainFrame()->RadioButton3->close();
 
-  GroupPoints = new DlgRef_1SelExt( centralWidget() );
+  GroupPoints = new DlgRef_1SelExt(centralWidget());
-  GroupPoints->GroupBox1->setTitle( tr( "GEOM_GLUE" ) );
+  GroupPoints->GroupBox1->setTitle(tr("GEOM_GLUE"));
-  GroupPoints->TextLabel1->setText( tr( "GEOM_SELECTED_SHAPE" ) );
+  GroupPoints->TextLabel1->setText(tr("GEOM_SELECTED_SHAPE"));
-  GroupPoints->PushButton1->setIcon( image1 );
+  GroupPoints->PushButton1->setIcon(image0);
-  GroupPoints->LineEdit1->setReadOnly( true );
+  GroupPoints->LineEdit1->setReadOnly(true);
-  
-  QLabel* aTolLab = new QLabel( tr( "GEOM_TOLERANCE" ), GroupPoints->Box );
-  myTolEdt = new SalomeApp_DoubleSpinBox( GroupPoints->Box );
-  initSpinBox( myTolEdt, 0., 100., DEFAULT_TOLERANCE_VALUE, "len_tol_precision" );
-  myTolEdt->setValue( DEFAULT_TOLERANCE_VALUE );
 
-  QGridLayout* boxLayout = new QGridLayout( GroupPoints->Box );
+  QLabel* aTolLab = new QLabel(tr("GEOM_TOLERANCE"), GroupPoints->Box);
-  boxLayout->setMargin( 0 ); boxLayout->setSpacing( 6 );
+  myTolEdt = new SalomeApp_DoubleSpinBox(GroupPoints->Box);
-  boxLayout->addWidget( aTolLab,  0, 0 );
+  initSpinBox(myTolEdt, 0., 100., DEFAULT_TOLERANCE_VALUE, "len_tol_precision");
-  boxLayout->addWidget( myTolEdt, 0, 2 );
+  myTolEdt->setValue(DEFAULT_TOLERANCE_VALUE);
+
+  QGridLayout* boxLayout = new QGridLayout(GroupPoints->Box);
+  boxLayout->setMargin(0); boxLayout->setSpacing(6);
+  boxLayout->addWidget(aTolLab,  0, 0);
+  boxLayout->addWidget(myTolEdt, 0, 2);
   /***************************************************************/
 
-  GroupPoints2 = new DlgRef_1SelExt( centralWidget() );
+  GroupPoints2 = new DlgRef_1SelExt(centralWidget());
-  GroupPoints2->GroupBox1->setTitle( tr( "GEOM_GLUE" ) );
+  GroupPoints2->GroupBox1->setTitle(tr("GEOM_GLUE"));
-  GroupPoints2->TextLabel1->setText( tr( "GEOM_SELECTED_SHAPE" ) );
+  GroupPoints2->TextLabel1->setText(tr("GEOM_SELECTED_SHAPE"));
-  GroupPoints2->PushButton1->setIcon( image1 );
+  GroupPoints2->PushButton1->setIcon(image0);
-  GroupPoints2->LineEdit1->setReadOnly( true );
+  GroupPoints2->LineEdit1->setReadOnly(true);
 
-  QLabel* aTolLab2 = new QLabel( tr( "GEOM_TOLERANCE" ), GroupPoints2->Box );
+  QLabel* aTolLab2 = new QLabel(tr("GEOM_TOLERANCE"), GroupPoints2->Box);
-  myTolEdt2 = new SalomeApp_DoubleSpinBox( GroupPoints2->Box );
+  myTolEdt2 = new SalomeApp_DoubleSpinBox(GroupPoints2->Box);
-  initSpinBox( myTolEdt2, 0., 100., DEFAULT_TOLERANCE_VALUE, "len_tol_precision" );
+  initSpinBox(myTolEdt2, 0., 100., DEFAULT_TOLERANCE_VALUE, "len_tol_precision");
-  myTolEdt2->setValue( DEFAULT_TOLERANCE_VALUE );
+  myTolEdt2->setValue(DEFAULT_TOLERANCE_VALUE);
 
-  myDetectBtn = new QPushButton( tr( "GEOM_DETECT" ) + QString( " [%1]" ).arg( tr( "GLUE_FACES" ) ), 
+  QString aGlueString (" [%1]");
-                                 GroupPoints2->Box );
+  QString aSelString;
-  mySubShapesChk = new QCheckBox( tr( "SELECT_FACES" ), GroupPoints2->Box );
+  if (theGlueMode == TopAbs_FACE) {
+    aGlueString = aGlueString.arg(tr("GLUE_FACES"));
+    aSelString = tr("SELECT_FACES");
+  }
+  else if (theGlueMode == TopAbs_EDGE) {
+    aGlueString = aGlueString.arg(tr("GLUE_EDGES"));
+    aSelString = tr("SELECT_EDGES");
+  }
+  myDetectBtn = new QPushButton (tr("GEOM_DETECT") + aGlueString, GroupPoints2->Box);
+  mySubShapesChk = new QCheckBox (aSelString, GroupPoints2->Box);
 
-  boxLayout = new QGridLayout( GroupPoints2->Box );
+  boxLayout = new QGridLayout(GroupPoints2->Box);
-  boxLayout->setMargin( 0 ); boxLayout->setSpacing( 6 );
+  boxLayout->setMargin(0); boxLayout->setSpacing(6);
-  boxLayout->addWidget( aTolLab2,    0, 0 );
+  boxLayout->addWidget(aTolLab2,    0, 0);
-  boxLayout->addWidget( myTolEdt2,   0, 2 );
+  boxLayout->addWidget(myTolEdt2,   0, 2);
-  boxLayout->addWidget( myDetectBtn, 1, 0, 1, 3 );
+  boxLayout->addWidget(myDetectBtn, 1, 0, 1, 3);
-  boxLayout->addWidget( mySubShapesChk, 2, 0, 1, 3 );
+  boxLayout->addWidget(mySubShapesChk, 2, 0, 1, 3);
 
-  QVBoxLayout* layout = new QVBoxLayout( centralWidget() );
+  QVBoxLayout* layout = new QVBoxLayout(centralWidget());
-  layout->setMargin( 0 ); layout->setSpacing( 6 );
+  layout->setMargin(0); layout->setSpacing(6);
-  layout->addWidget( GroupPoints );
+  layout->addWidget(GroupPoints);
-  layout->addWidget( GroupPoints2 );
+  layout->addWidget(GroupPoints2);
 
   /***************************************************************/
 
-  setHelpFileName( "glue_faces_operation_page.html" );
+  setHelpFileName("glue_faces_operation_page.html");
-  
+
   // Disable second way of gluing if OCC viewer is not active one
-  if ( myGeomGUI->getApp()->desktop()->activeWindow()->getViewManager()->getType()
+  if (myGeomGUI->getApp()->desktop()->activeWindow()->getViewManager()->getType()
-       != OCCViewer_Viewer::Type() )
+       != OCCViewer_Viewer::Type())
-    mainFrame()->RadioButton2->setEnabled( false );
+    mainFrame()->RadioButton2->setEnabled(false);
 
   Init();
 }
 
-
 //=================================================================================
 // function : ~RepairGUI_GlueDlg()
 // purpose  : Destroys the object and frees any allocated resources
@@ -141,7 +161,6 @@ RepairGUI_GlueDlg::~RepairGUI_GlueDlg()
 {
 }
 
-
 //=================================================================================
 // function : Init()
 // purpose  :
@@ -153,91 +172,90 @@ void RepairGUI_GlueDlg::Init()
 
   myObject = GEOM::GEOM_Object::_nil();
 
-  //myGeomGUI->SetState( 0 );
+  //myGeomGUI->SetState(0);
-  //globalSelection( GEOM_COMPOUND );
+  //globalSelection(GEOM_COMPOUND);
 
   mainFrame()->GroupBoxPublish->show();
   //Hide preview checkbox
   mainFrame()->CheckBoxPreview->hide();
 
   /* signals and slots connections */
-  connect( buttonOk(),    SIGNAL(clicked()), this, SLOT(ClickOnOk()));
+  connect(buttonOk(),    SIGNAL(clicked()), this, SLOT(ClickOnOk()));
-  connect( buttonApply(), SIGNAL(clicked()), this, SLOT(ClickOnApply()));
+  connect(buttonApply(), SIGNAL(clicked()), this, SLOT(ClickOnApply()));
 
-  connect( this,          SIGNAL( constructorsClicked( int ) ), this, SLOT( ConstructorsClicked( int ) ) );
+  connect(this,          SIGNAL(constructorsClicked(int)), this, SLOT(ConstructorsClicked(int)));
 
-  connect( GroupPoints->PushButton1,  SIGNAL( clicked() ),       this, SLOT( SetEditCurrentArgument() ) );
+  connect(GroupPoints->PushButton1,  SIGNAL(clicked()),       this, SLOT(SetEditCurrentArgument()));
-  connect( GroupPoints->LineEdit1,    SIGNAL( returnPressed() ), this, SLOT( LineEditReturnPressed() ) );
+  connect(GroupPoints->LineEdit1,    SIGNAL(returnPressed()), this, SLOT(LineEditReturnPressed()));
 
-  connect( GroupPoints2->PushButton1, SIGNAL( clicked() ),       this, SLOT( SetEditCurrentArgument() ) );
+  connect(GroupPoints2->PushButton1, SIGNAL(clicked()),       this, SLOT(SetEditCurrentArgument()));
-  connect( GroupPoints2->LineEdit1,   SIGNAL( returnPressed() ), this, SLOT( LineEditReturnPressed() ) );
+  connect(GroupPoints2->LineEdit1,   SIGNAL(returnPressed()), this, SLOT(LineEditReturnPressed()));
-  connect( myTolEdt2, SIGNAL( valueChanged( double ) ), this, SLOT( onTolerChanged( double ) ) );
+  connect(myTolEdt2, SIGNAL(valueChanged(double)), this, SLOT(onTolerChanged(double)));
-  connect( mySubShapesChk, SIGNAL( stateChanged( int ) ), this, SLOT( onSubShapesChk() ) );
+  connect(mySubShapesChk, SIGNAL(stateChanged(int)), this, SLOT(onSubShapesChk()));
 
-  connect( myGeomGUI->getApp()->selectionMgr(), SIGNAL( currentSelectionChanged() ),
+  connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
-           this, SLOT( SelectionIntoArgument() ) );
+           this, SLOT(SelectionIntoArgument()));
 
-  connect( myDetectBtn, SIGNAL( clicked() ), this, SLOT( onDetect() ) );
+  connect(myDetectBtn, SIGNAL(clicked()), this, SLOT(onDetect()));
 
-  initName( tr( "GLUE_NEW_OBJ_NAME" ) );
+  initName(tr("GLUE_NEW_OBJ_NAME"));
+
+  ConstructorsClicked(0);
 
-  ConstructorsClicked( 0 );
-  
   activateSelection();
   updateButtonState();
 }
 
-
 //=================================================================================
 // function : ConstructorsClicked()
 // purpose  : Radio button management
 //=================================================================================
-void RepairGUI_GlueDlg::ConstructorsClicked( int constructorId )
+void RepairGUI_GlueDlg::ConstructorsClicked(int constructorId)
 {
-  if ( myCurrConstrId == constructorId )
+  if (myCurrConstrId == constructorId)
     return;
-  
+
-  disconnect( myGeomGUI->getApp()->selectionMgr(), 0, this, 0 );
+  disconnect(myGeomGUI->getApp()->selectionMgr(), 0, this, 0);
-  
+
-  switch ( constructorId ) {
+  switch (constructorId) {
   case 0:
     GroupPoints2->hide();
     GroupPoints->show();
-    GroupPoints->LineEdit1->setText( "" );
+    GroupPoints->LineEdit1->setText("");
     myEditCurrentArgument = GroupPoints->LineEdit1;
-    
+
-    if ( myCurrConstrId >= 0 ) {
+    if (myCurrConstrId >= 0) {
       // i.e. it is not initialisation
       // copy tolerance from previous tolerance field
-      myTolEdt->setValue( myTolEdt2->value() );
+      myTolEdt->setValue(myTolEdt2->value());
     }
     break;
   case 1:
     GroupPoints->hide();
     GroupPoints2->show();
-    GroupPoints->LineEdit1->setText( "" );
+    GroupPoints->LineEdit1->setText("");
     myEditCurrentArgument = GroupPoints2->LineEdit1;
-        
+
-    if ( myCurrConstrId >= 0 ) {
+    if (myCurrConstrId >= 0) {
       // i.e. it is not initialisation
       // copy tolerance from previous tolerance field
-      myTolEdt2->setValue( myTolEdt->value() );
+      myTolEdt2->setValue(myTolEdt->value());
-      mySubShapesChk->setChecked( false );
+      mySubShapesChk->setChecked(false);
       clearTemporary();
     }
     break;
   }
-    
+
   myCurrConstrId = constructorId;
 
   myEditCurrentArgument->setFocus();
 
-  connect( myGeomGUI->getApp()->selectionMgr(), SIGNAL( currentSelectionChanged() ),
+  connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
-           this, SLOT( SelectionIntoArgument() ) );
+           this, SLOT(SelectionIntoArgument()));
 
   qApp->processEvents();
   updateGeometry();
-  resize( minimumSizeHint() );
+  resize(minimumSizeHint());
 
   processPreview();
   updateButtonState();
@@ -245,26 +263,24 @@ void RepairGUI_GlueDlg::ConstructorsClicked( int constructorId )
   SelectionIntoArgument();
 }
 
-
 //=================================================================================
 // function : ClickOnOk()
 // purpose  : Same than click on apply but close this dialog.
 //=================================================================================
 void RepairGUI_GlueDlg::ClickOnOk()
 {
-  setIsApplyAndClose( true );
+  setIsApplyAndClose(true);
-  if ( ClickOnApply() )
+  if (ClickOnApply())
     ClickOnCancel();
 }
 
-
 //=================================================================================
 // function : ClickOnApply()
 // purpose  :
 //=================================================================================
 bool RepairGUI_GlueDlg::ClickOnApply()
 {
-  if ( !onAcceptLocal() )
+  if (!onAcceptLocal())
     return false;
 
   initName();
@@ -272,9 +288,9 @@ bool RepairGUI_GlueDlg::ClickOnApply()
   //GroupPoints->LineEdit1->setText("");
   //myObject = GEOM::GEOM_Object::_nil();
 
-  //globalSelection( GEOM_COMPOUND );
+  //globalSelection(GEOM_COMPOUND);
 
-  ConstructorsClicked( getConstructorId() );
+  ConstructorsClicked(getConstructorId());
 
   return true;
 }
@@ -286,24 +302,24 @@ bool RepairGUI_GlueDlg::ClickOnApply()
 //=================================================================================
 void RepairGUI_GlueDlg::SelectionIntoArgument()
 {
-  if ( mySubShapesChk->isChecked() &&  getConstructorId() == 1 ) {
+  if (mySubShapesChk->isChecked() &&  getConstructorId() == 1) {
     updateButtonState();
     return;
   }
-  
+
   erasePreview();
-  myEditCurrentArgument->setText( "" );
+  myEditCurrentArgument->setText("");
   myObject = GEOM::GEOM_Object::_nil();
 
   LightApp_SelectionMgr* aSelMgr = myGeomGUI->getApp()->selectionMgr();
   SALOME_ListIO aSelList;
   aSelMgr->selectedObjects(aSelList);
 
-  if ( aSelList.Extent() == 1 ) {
+  if (aSelList.Extent() == 1) {
     Handle(SALOME_InteractiveObject) anIO = aSelList.First();
-    myObject = GEOMBase::ConvertIOinGEOMObject( anIO );
+    myObject = GEOMBase::ConvertIOinGEOMObject(anIO);
-    if ( !CORBA::is_nil( myObject ) )
+    if (!CORBA::is_nil(myObject))
-      myEditCurrentArgument->setText( GEOMBase::GetName( myObject ) );
+      myEditCurrentArgument->setText(GEOMBase::GetName(myObject));
   }
   updateButtonState();
 }
@@ -315,13 +331,12 @@ void RepairGUI_GlueDlg::SelectionIntoArgument()
 void RepairGUI_GlueDlg::SetEditCurrentArgument()
 {
   const QObject* send = sender();
-  if ( send == GroupPoints->PushButton1 || send == GroupPoints2->PushButton1 )  {
+  if (send == GroupPoints->PushButton1 || send == GroupPoints2->PushButton1)  {
     myEditCurrentArgument->setFocus();
     SelectionIntoArgument();
   }
 }
 
-
 //=================================================================================
 // function : LineEditReturnPressed()
 // purpose  :
@@ -329,17 +344,16 @@ void RepairGUI_GlueDlg::SetEditCurrentArgument()
 void RepairGUI_GlueDlg::LineEditReturnPressed()
 {
   const QObject* send = sender();
-  if ( send == GroupPoints->LineEdit1 ) {
+  if (send == GroupPoints->LineEdit1) {
     myEditCurrentArgument = GroupPoints->LineEdit1;
     GEOMBase_Skeleton::LineEditReturnPressed();
   }
-  else if ( send == GroupPoints2->LineEdit1 ) {
+  else if (send == GroupPoints2->LineEdit1) {
     myEditCurrentArgument = GroupPoints2->LineEdit1;
     GEOMBase_Skeleton::LineEditReturnPressed();
   }
 }
 
-
 //=================================================================================
 // function : ActivateThisDialog()
 // purpose  :
@@ -347,99 +361,103 @@ void RepairGUI_GlueDlg::LineEditReturnPressed()
 void RepairGUI_GlueDlg::ActivateThisDialog()
 {
   GEOMBase_Skeleton::ActivateThisDialog();
-  connect( myGeomGUI->getApp()->selectionMgr(), SIGNAL( currentSelectionChanged() ), 
+  connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
-           this, SLOT( SelectionIntoArgument() ) );
+           this, SLOT(SelectionIntoArgument()));
 
   //GroupPoints->LineEdit1->setText("");
   //GroupPoints2->LineEdit1->setText("");
   //myObject = GEOM::GEOM_Object::_nil();
 
-  //myGeomGUI->SetState( 0 );
+  //myGeomGUI->SetState(0);
-  //globalSelection( GEOM_COMPOUND );
+  //globalSelection(GEOM_COMPOUND);
   activateSelection();
 }
 
-
 //=================================================================================
 // function : enterEvent()
 // purpose  : Mouse enter onto the dialog to activate it
 //=================================================================================
-void RepairGUI_GlueDlg::enterEvent( QEvent* )
+void RepairGUI_GlueDlg::enterEvent(QEvent*)
 {
-  if ( !mainFrame()->GroupConstructors->isEnabled() )
+  if (!mainFrame()->GroupConstructors->isEnabled())
     ActivateThisDialog();
 }
 
-
 //=================================================================================
 // function : createOperation
 // purpose  :
 //=================================================================================
 GEOM::GEOM_IOperations_ptr RepairGUI_GlueDlg::createOperation()
 {
-  return getGeomEngine()->GetIShapesOperations( getStudyId() );
+  return getGeomEngine()->GetIShapesOperations(getStudyId());
 }
 
 //=================================================================================
 // function : isValid
 // purpose  :
 //=================================================================================
-bool RepairGUI_GlueDlg::isValid( QString& msg )
+bool RepairGUI_GlueDlg::isValid(QString& msg)
 {
   bool ok = true;
   double v = 0;
-  switch ( getConstructorId() )
+  switch (getConstructorId())
   {
   case 0:
     v = myTolEdt->value();
-    ok = myTolEdt->isValid( msg, !IsPreview() );
+    ok = myTolEdt->isValid(msg, !IsPreview());
     break;
   case 1:
-    v = myTolEdt2->value(); 
+    v = myTolEdt2->value();
-    ok = myTolEdt2->isValid( msg, !IsPreview() );
+    ok = myTolEdt2->isValid(msg, !IsPreview());
     break;
   }
-  return !myObject->_is_nil() && ( IsPreview() || v > 0. ) && ok;
+  return !myObject->_is_nil() && (IsPreview() || v > 0.) && ok;
 }
 
 //=================================================================================
 // function : execute
 // purpose  :
 //=================================================================================
-bool RepairGUI_GlueDlg::execute( ObjectList& objects )
+bool RepairGUI_GlueDlg::execute(ObjectList& objects)
 {
   bool aResult = false;
   objects.clear();
 
-  GEOM::GEOM_IShapesOperations_var anOper = GEOM::GEOM_IShapesOperations::_narrow( getOperation() );
+  GEOM::GEOM_IShapesOperations_var anOper = GEOM::GEOM_IShapesOperations::_narrow(getOperation());
-  switch ( getConstructorId() ) {
+  switch (getConstructorId()) {
   case 0:
     {
-      GEOM::GEOM_Object_var anObj = anOper->MakeGlueFaces( myObject, myTolEdt->value(), true );
+      GEOM::GEOM_Object_var anObj;
+      if (myGlueMode == TopAbs_FACE)
+        anObj = anOper->MakeGlueFaces(myObject, myTolEdt->value(), true);
+      else if (myGlueMode == TopAbs_EDGE)
+        anObj = anOper->MakeGlueEdges(myObject, myTolEdt->value());
+
       aResult = !anObj->_is_nil();
-      if ( aResult && !IsPreview() )
+      if (aResult && !IsPreview())
       {
         QStringList aParameters;
         aParameters << myTolEdt->text();
         anObj->SetParameters(aParameters.join(":").toLatin1().constData());
 
-        objects.push_back( anObj._retn() );
+        objects.push_back(anObj._retn());
       }
       break;
     }
   case 1:
     {
-      if ( IsPreview() ) {
+      if (IsPreview()) {
-        // if this method is used for displaying preview then we must detect glue faces only
+        // if this method is used for displaying preview then we must detect glue faces/edges only
-        ObjectList::iterator anIter;
+        for (int i = 0; i < myTmpObjs.count(); i++) {
-        for ( anIter = myTmpObjs.begin(); anIter != myTmpObjs.end(); ++anIter )
+          myTmpObjs[i].get()->Register(); // increment counter, since calling function will call UnRegister()
-          objects.push_back( GEOM::GEOM_Object::_duplicate( *anIter ) );
+          objects.push_back(myTmpObjs[i].copy());
-        return myTmpObjs.size() ? true : false;
+        }
+        return !myTmpObjs.isEmpty();
       } // IsPreview
 
-      // Make glue face by list.
+      // Make glue faces/edges by list.
       // Iterate through myTmpObjs and verifies where each object is currently selected or not.
-      QMap<QString, char> selected;
+      QSet<QString> selected;
 
       // Get names of selected objects
       LightApp_SelectionMgr* aSelMgr = myGeomGUI->getApp()->selectionMgr();
@@ -447,37 +465,40 @@ bool RepairGUI_GlueDlg::execute( ObjectList& objects )
       aSelMgr->selectedObjects(aSelList);
 
       SALOME_ListIteratorOfListIO it (aSelList);
-      for (; it.More(); it.Next()) 
+      for (; it.More(); it.Next())
-        selected.insert(it.Value()->getName(), 0);
+        selected.insert(it.Value()->getName());
 
       // Iterate through result and select objects with names from selection
       // ObjectList toRemoveFromEnggine;
-      ObjectList toGlue;
+
-      ObjectList::iterator anIter;
+      // make glue faces/edges
-      for ( anIter = myTmpObjs.begin(); anIter != myTmpObjs.end(); ++anIter ) {
-        if ( selected.contains( myGeomGUI->getApp()->orb()->object_to_string(*anIter) ) )
-          toGlue.push_back( *anIter );
-      }
-      
-      // make glue faces
       GEOM::ListOfGO_var aListForGlue = new GEOM::ListOfGO();
-      aListForGlue->length( toGlue.size() );
+      aListForGlue->length(myTmpObjs.count());
-      ObjectList::iterator anIter3 = toGlue.begin();
+      int added = 0;
-      for ( int i = 0; anIter3 != toGlue.end(); ++anIter3, ++i )
+      for (int i = 0; i < myTmpObjs.count(); i++) {
-        aListForGlue[ i ] = *anIter3;
+        CORBA::String_var tmpior = myGeomGUI->getApp()->orb()->object_to_string(myTmpObjs[i].get());
-      GEOM::GEOM_Object_var anObj = anOper->MakeGlueFacesByList( myObject, myTolEdt2->value(), aListForGlue, true );
+        if (selected.contains(tmpior.in()))
+          aListForGlue[ added++ ] = myTmpObjs[i].copy();
+      }
+      aListForGlue->length(added);
+
+      GEOM::GEOM_Object_var anObj;
+      if (myGlueMode == TopAbs_FACE)
+        anObj = anOper->MakeGlueFacesByList(myObject, myTolEdt2->value(), aListForGlue.in(), true);
+      else if (myGlueMode == TopAbs_EDGE)
+        anObj = anOper->MakeGlueEdgesByList(myObject, myTolEdt2->value(), aListForGlue.in());
 
       aResult = !anObj->_is_nil();
 
-      if ( aResult )
+      if (aResult)
       {
-        if ( !IsPreview() )
+        if (!IsPreview())
         {
           QStringList aParameters;
           aParameters << myTolEdt2->text();
           anObj->SetParameters(aParameters.join(":").toLatin1().constData());
         }
-        objects.push_back( anObj._retn() );
+        objects.push_back(anObj._retn());
       }
 
       // Remove from engine useless objects
@@ -496,49 +517,49 @@ bool RepairGUI_GlueDlg::execute( ObjectList& objects )
 // function : restoreSubShapes
 // purpose  :
 //=================================================================================
-void RepairGUI_GlueDlg::restoreSubShapes( SALOMEDS::Study_ptr   theStudy,
+void RepairGUI_GlueDlg::restoreSubShapes(SALOMEDS::Study_ptr   theStudy,
-                                          SALOMEDS::SObject_ptr theSObject )
+                                          SALOMEDS::SObject_ptr theSObject)
 {
-  if ( mainFrame()->CheckBoxRestoreSS->isChecked() ) {
+  if (mainFrame()->CheckBoxRestoreSS->isChecked()) {
     GEOM::find_shape_method aFindMethod = GEOM::FSM_GetInPlace;
-    if ( getConstructorId() == 0 ) // MakeGlueFaces
+    if (getConstructorId() == 0) // MakeGlueFaces or MakeGlueEdges
       aFindMethod = GEOM::FSM_GetInPlaceByHistory;
 
     // empty list of arguments means that all arguments should be restored
-    getGeomEngine()->RestoreSubShapesSO( theStudy, theSObject, GEOM::ListOfGO(),
+    getGeomEngine()->RestoreSubShapesSO(theStudy, theSObject, GEOM::ListOfGO(),
                                          aFindMethod, /*theInheritFirstArg=*/true,
-                                         mainFrame()->CheckBoxAddPrefix->isChecked() );
+                                         mainFrame()->CheckBoxAddPrefix->isChecked());
   }
 }
 
 //================================================================
 // Function : clearShapeBufferLocal
-// Purpose  : 
+// Purpose  :
 //================================================================
-void RepairGUI_GlueDlg::clearShapeBufferLocal( GEOM::GEOM_Object_ptr theObj )
+void RepairGUI_GlueDlg::clearShapeBufferLocal(GEOM::GEOM_Object_ptr theObj)
 {
-  if ( CORBA::is_nil( theObj ) )
+  if (CORBA::is_nil(theObj))
     return;
 
-  CORBA::String_var IOR = myGeomGUI->getApp()->orb()->object_to_string( theObj );
+  CORBA::String_var IOR = myGeomGUI->getApp()->orb()->object_to_string(theObj);
-  TCollection_AsciiString asciiIOR( (char *)( IOR.in() ) );
+  TCollection_AsciiString asciiIOR((char *)(IOR.in()));
-  myGeomGUI->GetShapeReader().RemoveShapeFromBuffer( asciiIOR );
+  myGeomGUI->GetShapeReader().RemoveShapeFromBuffer(asciiIOR);
 
-  if ( !getStudy() || !( getStudy()->studyDS() ) )
+  if (!getStudy() || !(getStudy()->studyDS()))
     return;
 
   _PTR(Study) aStudy = getStudy()->studyDS();
-  _PTR(SObject) aSObj ( aStudy->FindObjectIOR( std::string( IOR.in() ) ) );
+  _PTR(SObject) aSObj (aStudy->FindObjectIOR(std::string(IOR.in())));
-  if ( !aSObj )
+  if (!aSObj)
     return;
 
-  _PTR(ChildIterator) anIt ( aStudy->NewChildIterator( aSObj ) );
+  _PTR(ChildIterator) anIt (aStudy->NewChildIterator(aSObj));
-  for ( anIt->InitEx( true ); anIt->More(); anIt->Next() ) {
+  for (anIt->InitEx(true); anIt->More(); anIt->Next()) {
     _PTR(GenericAttribute) anAttr;
-    if ( anIt->Value()->FindAttribute(anAttr, "AttributeIOR") ) {
+    if (anIt->Value()->FindAttribute(anAttr, "AttributeIOR")) {
-      _PTR(AttributeIOR) anIOR ( anAttr );
+      _PTR(AttributeIOR) anIOR (anAttr);
-      TCollection_AsciiString asciiIOR( (char*)anIOR->Value().c_str() );
+      TCollection_AsciiString asciiIOR((char*)anIOR->Value().c_str());
-      myGeomGUI->GetShapeReader().RemoveShapeFromBuffer( asciiIOR );      
+      myGeomGUI->GetShapeReader().RemoveShapeFromBuffer(asciiIOR);
     }
   }
 }
@@ -546,83 +567,83 @@ void RepairGUI_GlueDlg::clearShapeBufferLocal( GEOM::GEOM_Object_ptr theObj )
 //================================================================
 // Function : onAccept
 // Purpose  : This method should be called from dialog's slots onOk() and onApply()
-//            It perfroms user input validation, then it 
+//            It perfroms user input validation, then it
 //            performs a proper operation and manages transactions, etc.
 //================================================================
 bool RepairGUI_GlueDlg::onAcceptLocal()
 {
-  if ( !getStudy() || !( getStudy()->studyDS() ) )
+  if (!getStudy() || !(getStudy()->studyDS()))
     return false;
 
   _PTR(Study) aStudy = getStudy()->studyDS();
 
   bool aLocked = aStudy->GetProperties()->IsLocked();
-  if ( aLocked ) {
+  if (aLocked) {
     MESSAGE("GEOMBase_Helper::onAccept - ActiveStudy is locked");
-    SUIT_MessageBox::warning( this, tr( "WRN_WARNING" ), tr( "WRN_STUDY_LOCKED" ), tr( "BUT_OK" ) );
+    SUIT_MessageBox::warning(this, tr("WRN_WARNING"), tr("WRN_STUDY_LOCKED"), tr("BUT_OK"));
     return false;
   }
 
   QString msg;
-  if ( !isValid( msg ) ) {
+  if (!isValid(msg)) {
-    showError( msg );
+    showError(msg);
     return false;
   }
 
-  erasePreview( false );
+  erasePreview(false);
 
   try {
-    if ( openCommand() ) {
+    if (openCommand()) {
       SUIT_OverrideCursor wc;
-      
+
-      myGeomGUI->getApp()->putInfo( "" );
+      myGeomGUI->getApp()->putInfo("");
       ObjectList objects;
-      
+
-      if ( !execute( objects ) ) { 
+      if (!execute(objects)) {
         wc.suspend();
         abortCommand();
         showError();
       }
       else {
         const int nbObjs = objects.size();
-        for ( ObjectList::iterator it = objects.begin(); it != objects.end(); ++it ) {
+        for (ObjectList::iterator it = objects.begin(); it != objects.end(); ++it) {
           QString aName = getNewObjectName();
-          if ( nbObjs > 1 ) {
+          if (nbObjs > 1) {
-            if ( aName.isEmpty() )
+            if (aName.isEmpty())
-              aName = getPrefix( *it );
+              aName = getPrefix(*it);
-            aName = GEOMBase::GetDefaultName( aName );
+            aName = GEOMBase::GetDefaultName(aName);
           }
           else {
             // PAL6521: use a prefix, if some dialog box doesn't reimplement getNewObjectName()
-            if ( aName.isEmpty() )
+            if (aName.isEmpty())
-              aName = GEOMBase::GetDefaultName( getPrefix( *it ) );
+              aName = GEOMBase::GetDefaultName(getPrefix(*it));
           }
-          addInStudy( *it, aName.toLatin1().data() );
+          addInStudy(*it, aName.toLatin1().data());
-          display( *it, false );
+          display(*it, false);
         }
-        
+
-        if ( nbObjs ) {
+        if (nbObjs) {
           commitCommand();
           updateObjBrowser();
-          myGeomGUI->getApp()->putInfo( QObject::tr("GEOM_PRP_DONE") );
+          myGeomGUI->getApp()->putInfo(QObject::tr("GEOM_PRP_DONE"));
         }
         else {
           abortCommand();
         }
 
         // JFA 28.12.2004 BEGIN // To enable warnings
-        GEOM::GEOM_IShapesOperations_var anOper = GEOM::GEOM_IShapesOperations::_narrow( getOperation() );
+        GEOM::GEOM_IShapesOperations_var anOper = GEOM::GEOM_IShapesOperations::_narrow(getOperation());
-        if ( !CORBA::is_nil(anOper) && !anOper->IsDone() ) {
+        if (!CORBA::is_nil(anOper) && !anOper->IsDone()) {
           wc.suspend();
-          QString msgw = QObject::tr( anOper->GetErrorCode() );
+          QString msgw = QObject::tr(anOper->GetErrorCode());
-          SUIT_MessageBox::warning( this, tr( "WRN_WARNING" ), msgw, tr( "BUT_OK" ) );
+          SUIT_MessageBox::warning(this, tr("WRN_WARNING"), msgw, tr("BUT_OK"));
         }
         // JFA 28.12.2004 END
       }
     }
   }
-  catch( const SALOME::SALOME_Exception& e ) {
+  catch(const SALOME::SALOME_Exception& e) {
-    SalomeApp_Tools::QtCatchCorbaException( e );
+    SalomeApp_Tools::QtCatchCorbaException(e);
     abortCommand();
   }
 
@@ -633,7 +654,6 @@ bool RepairGUI_GlueDlg::onAcceptLocal()
   return true;
 }
 
-
 //=================================================================================
 // function : onDetect
 // purpose  :
@@ -642,32 +662,42 @@ void RepairGUI_GlueDlg::onDetect()
 {
   clearTemporary();
   QString msg;
-  if ( !isValid( msg ) ) {
+  if (!isValid(msg)) {
-    showError( msg );
+    showError(msg);
     return;
   }
 
-  buttonOk()->setEnabled( false );
+  buttonOk()->setEnabled(false);
-  buttonApply()->setEnabled( false );
+  buttonApply()->setEnabled(false);
-  globalSelection( GEOM_ALLSHAPES );
+  globalSelection(GEOM_ALLSHAPES);
 
-  GEOM::GEOM_IShapesOperations_var anOper = GEOM::GEOM_IShapesOperations::_narrow( getOperation() );
+  GEOM::GEOM_IShapesOperations_var anOper = GEOM::GEOM_IShapesOperations::_narrow(getOperation());
-  GEOM::ListOfGO_var aList = anOper->GetGlueFaces( myObject, myTolEdt2->value() );
+  GEOM::ListOfGO_var aList;
-  
+  if (myGlueMode == TopAbs_FACE)
-  for ( int i = 0, n = aList->length(); i < n; i++ ) 
+    aList = anOper->GetGlueFaces(myObject.in(), myTolEdt2->value());
-    myTmpObjs.push_back(GEOM::GEOM_Object::_duplicate(aList[i]));
+  else if (myGlueMode == TopAbs_EDGE)
-  
+    aList = anOper->GetGlueEdges(myObject.in(), myTolEdt2->value());
-  if ( myTmpObjs.size() > 0  ) {
+
-    msg = tr( "FACES_FOR_GLUING_ARE_DETECTED" ).arg( myTmpObjs.size() );
+  for (int i = 0, n = aList->length(); i < n; i++)
-    mySubShapesChk->setChecked( true );
+    myTmpObjs << GEOM::GeomObjPtr(aList[i].in());
+
+  if (!myTmpObjs.isEmpty()) {
+    if (myGlueMode == TopAbs_FACE)
+      msg = tr("FACES_FOR_GLUING_ARE_DETECTED").arg(myTmpObjs.count());
+    else if (myGlueMode == TopAbs_EDGE)
+      msg = tr("EDGES_FOR_GLUING_ARE_DETECTED").arg(myTmpObjs.count());
+    mySubShapesChk->setChecked(true);
   }
   else {
-    msg = tr( "THERE_ARE_NO_FACES_FOR_GLUING" );
+    if (myGlueMode == TopAbs_FACE)
+      msg = tr("THERE_ARE_NO_FACES_FOR_GLUING");
+    else if (myGlueMode == TopAbs_EDGE)
+      msg = tr("THERE_ARE_NO_EDGES_FOR_GLUING");
   }
-  
+
-  connect( myGeomGUI->getApp()->selectionMgr(), SIGNAL( currentSelectionChanged() ),
+  connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
-           this, SLOT( SelectionIntoArgument() ) ) ;
+          this, SLOT(SelectionIntoArgument())) ;
-  SUIT_MessageBox::information( this, tr( "GEOM_FREE_BOUNDS_TLT" ), msg, tr( "Close" ) );
+  SUIT_MessageBox::information(this, tr("GEOM_FREE_BOUNDS_TLT"), msg, tr("Close"));
   updateButtonState();
   activateSelection();
 }
@@ -678,48 +708,48 @@ void RepairGUI_GlueDlg::onDetect()
 //=================================================================================
 void RepairGUI_GlueDlg::activateSelection()
 {
-  erasePreview( false );
+  erasePreview(false);
-  
+
   int anId = getConstructorId();
-  if ( anId == 0 )  { 
+  if (anId == 0) {
     // Case of whole gluing
-    disconnect( myGeomGUI->getApp()->selectionMgr(), SIGNAL( currentSelectionChanged() ),
+    disconnect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
-                this, SLOT( SelectionIntoArgument() ) );
+                this, SLOT(SelectionIntoArgument()));
-    
+
-    globalSelection( GEOM_ALLSHAPES );
+    globalSelection(GEOM_ALLSHAPES);
-    if ( myObject->_is_nil()) 
+    if (myObject->_is_nil())
       SelectionIntoArgument();
 
-    connect( myGeomGUI->getApp()->selectionMgr(), SIGNAL( currentSelectionChanged() ),
+    connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
-             this, SLOT( SelectionIntoArgument() ) );
+             this, SLOT(SelectionIntoArgument()));
-  } 
+  }
   else {
     // Second case of gluing
-    if ( !mySubShapesChk->isChecked() ) 
+    if (!mySubShapesChk->isChecked())
-      globalSelection( GEOM_ALLSHAPES );
+      globalSelection(GEOM_ALLSHAPES);
     else {
-      displayPreview( true, false, false, 2/*line width*/, 1/*display mode*/, Quantity_NOC_RED );
+      displayPreview(true, true, false, false, 2/*line width*/, 1/*display mode*/, Quantity_NOC_RED);
-      disconnect( myGeomGUI->getApp()->selectionMgr(), SIGNAL( currentSelectionChanged() ),
+      disconnect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
-                  this, SLOT( SelectionIntoArgument() ) ) ;
+                  this, SLOT(SelectionIntoArgument())) ;
-      globalSelection( GEOM_PREVIEW );
+      globalSelection(GEOM_PREVIEW);
-      connect( myGeomGUI->getApp()->selectionMgr(), SIGNAL( currentSelectionChanged() ),
+      connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
-               this, SLOT( SelectionIntoArgument() ) ) ;
+               this, SLOT(SelectionIntoArgument())) ;
-    } 
+    }
   }
   updateViewer();
 }
 
 //=================================================================================
 // function : updateButtonState
-// purpose  : Update button state 
+// purpose  : Update button state
 //=================================================================================
 void RepairGUI_GlueDlg::updateButtonState()
 {
   int anId = getConstructorId();
   bool hasMainObj = !myObject->_is_nil();
-  if ( anId == 0 ) {
+  if (anId == 0) {
-    buttonOk()->setEnabled( hasMainObj );
+    buttonOk()->setEnabled(hasMainObj);
-    buttonApply()->setEnabled( hasMainObj );
+    buttonApply()->setEnabled(hasMainObj);
   }
   else
   {
@@ -727,17 +757,15 @@ void RepairGUI_GlueDlg::updateButtonState()
     SALOME_ListIO aSelList;
     aSelMgr->selectedObjects(aSelList);
 
-    bool wasSelected = false;
     SALOME_ListIteratorOfListIO it (aSelList);
-    if (it.More() > 0)
+    bool wasSelected = it.More() > 0;
-      wasSelected = true;
+    bool wasDetected = !myTmpObjs.isEmpty();
-    bool wasDetected = myTmpObjs.size() ? true : false;
+    buttonOk()->setEnabled(hasMainObj && wasDetected && wasSelected);
-    buttonOk()->setEnabled( hasMainObj && wasDetected && wasSelected );
+    buttonApply()->setEnabled(hasMainObj && wasDetected && wasSelected);
-    buttonApply()->setEnabled( hasMainObj && wasDetected && wasSelected );
+    mySubShapesChk->setEnabled(hasMainObj && wasDetected);
-    mySubShapesChk->setEnabled( hasMainObj && wasDetected );
+    myDetectBtn->setEnabled(hasMainObj);
-    myDetectBtn->setEnabled( hasMainObj );
+    if (!hasMainObj || !wasDetected)
-    if ( !hasMainObj || !wasDetected )
+      mySubShapesChk->setChecked(false);
-      mySubShapesChk->setChecked( false );
   }
 }
 
@@ -747,10 +775,6 @@ void RepairGUI_GlueDlg::updateButtonState()
 //=================================================================================
 void RepairGUI_GlueDlg::clearTemporary()
 {
-  ObjectList::iterator anIter;
-  for ( anIter = myTmpObjs.begin(); anIter != myTmpObjs.end(); ++anIter )
-    getGeomEngine()->RemoveObject(*anIter);
-
   myTmpObjs.clear();
 }
 
@@ -758,7 +782,7 @@ void RepairGUI_GlueDlg::clearTemporary()
 // function : onTolerChanged
 // purpose  : Remove temporary objects from engine
 //=================================================================================
-void RepairGUI_GlueDlg::onTolerChanged( double /*theVal*/ )
+void RepairGUI_GlueDlg::onTolerChanged(double /*theVal*/)
 {
   clearTemporary();
   activateSelection();
@@ -771,7 +795,7 @@ void RepairGUI_GlueDlg::onTolerChanged( double /*theVal*/ )
 //=================================================================================
 void RepairGUI_GlueDlg::onSubShapesChk()
 {
-  if ( !mySubShapesChk->isChecked() )
+  if (!mySubShapesChk->isChecked())
     clearTemporary();
   activateSelection();
   updateButtonState();

src/RepairGUI/RepairGUI_GlueDlg.h

@@ -18,17 +18,20 @@
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 //
 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
 
-// GEOM GEOMGUI : GUI for Geometry component
+//  GEOM GEOMGUI : GUI for Geometry component
-// File   : RepairGUI_GlueDlg.h
+//  File   : RepairGUI_GlueDlg.h
-// Author : Lucien PIGNOLONI, Open CASCADE S.A.S.
+//  Author : Lucien PIGNOLONI, Open CASCADE S.A.S.
-//
+
 #ifndef REPAIRGUI_GLUEDLG_H
 #define REPAIRGUI_GLUEDLG_H
 
 #include <GEOMBase_Skeleton.h>
 
+#include <TopAbs.hxx>
+
+#include <QList>
+
 class DlgRef_1SelExt;
 class SalomeApp_DoubleSpinBox;
 class QPushButton;
@@ -43,47 +46,49 @@ class RepairGUI_GlueDlg : public GEOMBase_Skeleton
   Q_OBJECT
 
 public:
-  RepairGUI_GlueDlg( GeometryGUI*, QWidget* = 0, bool = false );
+  RepairGUI_GlueDlg (GeometryGUI*, QWidget* = 0, bool = false, TopAbs_ShapeEnum theGlueMode = TopAbs_FACE);
   ~RepairGUI_GlueDlg();
 
 protected:
   // redefined from GEOMBase_Helper
   virtual GEOM::GEOM_IOperations_ptr createOperation();
-  virtual bool                       isValid( QString& );
+  virtual bool                       isValid (QString&);
-  virtual bool                       execute( ObjectList& );
+  virtual bool                       execute (ObjectList&);
-  virtual void                       restoreSubShapes( SALOMEDS::Study_ptr, SALOMEDS::SObject_ptr );
+  virtual void                       restoreSubShapes (SALOMEDS::Study_ptr, SALOMEDS::SObject_ptr);
 
 private:
   void                               Init();
-  void                               enterEvent( QEvent* );
+  void                               enterEvent (QEvent*);
   void                               initSelection();
-  
+
   void                               clearTemporary();
-  
+
-  bool                               onAcceptLocal();
-  void                               clearShapeBufferLocal( GEOM::GEOM_Object_ptr );
   // Reimplementation of onAccept for local case of this class.
-  
+  bool                               onAcceptLocal();
+  void                               clearShapeBufferLocal (GEOM::GEOM_Object_ptr);
+
   void                               activateSelection();
   void                               updateButtonState();
   void                               selectTmpInViewer();
-    
+
-private:    
+private:
   GEOM::GEOM_Object_var              myObject;
-  ObjectList                         myTmpObjs;
+  QList<GEOM::GeomObjPtr>            myTmpObjs;
-    
+
   DlgRef_1SelExt*                    GroupPoints;
   DlgRef_1SelExt*                    GroupPoints2;
   SalomeApp_DoubleSpinBox*           myTolEdt;
   SalomeApp_DoubleSpinBox*           myTolEdt2;
   QPushButton*                       myDetectBtn;
   QCheckBox*                         mySubShapesChk;
-  
+
   int                                myCurrConstrId;
-    
+
+  TopAbs_ShapeEnum                   myGlueMode;
+
 protected slots:
   virtual void                       ClickOnCancel();
-    
+
 private slots:
   void                               ClickOnOk();
   bool                               ClickOnApply();
@@ -94,11 +99,10 @@ private slots:
   void                               SelectionIntoArgument();
   void                               SetEditCurrentArgument();
 
-  void                               ConstructorsClicked( int );
+  void                               ConstructorsClicked (int);
-  //void                               ValueChangedInSpinBox();
+
-  
   void                               onDetect();
-  void                               onTolerChanged( double );
+  void                               onTolerChanged (double);
   void                               onSubShapesChk();
 };