--- /dev/null
+/*!
+
+\page limit_tolerance_operation_page Limit Tolerance
+
+\n To produce a <b>Limit Tolerance</b> operation in the <b>Main
+ Menu</b> select <b>Repair - > Limit Tolerance</b>.
+
+\n It is possible on all kind of shapes.
+
+\n The \b Result will be a \b GEOM_Object.
+
+\n <b>TUI Command:</b> <em>geompy.LimitTolerance(Shape, Tolerance),</em>
+ where \em Shape is a shape with presumably incorrect tolerance, \em
+ Tolerance is a desired value of tolerance.
+
+\image html limit_tolerance_dlg.png
+
+\n <b>Arguments:</b> Name + 1 shape + 1 value (new tolerance).
+
+Our <b>TUI Scripts</b> provide you with useful examples of the use of
+\ref tui_limit_tolerance "Repairing Operations".
+
+*/
<li>\subpage sewing_operation_page "Sewing" - sews faces or shells.</li>
<li>\subpage glue_faces_operation_page "Glue faces" - unites
coincident faces within the given tolerance.</li>
+<li>\subpage limit_tolerance_operation_page "Limit Tolerance" - tries
+to set new tolerance value for the given shape.</li>
<li>\subpage add_point_on_edge_operation_page "Add point on edge" -
splits an edge in two.</li>
<li>\subpage change_orientation_operation_page "Change orientation" -
gg.setDisplayMode(id_glue,1)
\endcode
+\anchor tui_limit_tolerance
+<br><h2>Limit Tolerance</h2>
+
+\code
+import geompy
+gg = salome.ImportComponentGUI("GEOM")
+
+# import initial topology
+bad_shape = geompy.ImportBREP("my_bad_shape.brep")
+
+# limit tolerance
+tolerance = 1e-07
+good_shape = geompy.LimitTolerance(bad_shape, tolerance)
+
+# add objects in the study
+id_bad_shape = geompy.addToStudy(bad_shape, "My Bad Shape")
+id_good_shape = geompy.addToStudy(good_shape, "My Good Shape")
+
+# display the results
+gg.createAndDisplayGO(id_bad_shape)
+gg.setDisplayMode(id_bad_shape, 1)
+gg.createAndDisplayGO(id_good_shape)
+gg.setDisplayMode(id_good_shape, 1)
+\endcode
+
\anchor tui_add_point_on_edge
<br><h2>Add Point on Edge</h2>
\anchor swig_GetPoint
\until blocksComp (-50, -50, -50)
+\anchor swig_GetVertexNearPoint
+\until near (40, 40, 40)
+
+\anchor swig_GetEdge
+\until by two points
+
\anchor swig_GetEdgeNearPoint
\until edge near point
\anchor swig_GetBlockByParts
\until "b0 image"
+\anchor swig_GetShapesNearPoint
+\until "faces near point"
+
\anchor swig_GetShapesOnPlane
\until Face on Plane
in double theZ,
in double theEpsilon);
+ /*!
+ * Find a vertex of the given shape, which has minimal distance to the given point.
+ * \param theShape Any shape.
+ * \param thePoint Point, close to the desired vertex.
+ * \return New GEOM_Object, containing the found vertex.
+ */
+ GEOM_Object GetVertexNearPoint (in GEOM_Object theShape,
+ in GEOM_Object thePoint);
+
/*!
* Get an edge, found in the given shape by two given vertices.
* \param theShape Block or a compound of blocks.
GEOM_Object GetFaceByNormale (in GEOM_Object theBlock,
in GEOM_Object theVector);
+ /*!
+ * Find all subshapes of type \a theShapeType of the given shape,
+ * which have minimal distance to the given point.
+ * \param theShape Any shape.
+ * \param thePoint Point, close to the desired shape.
+ * \param theShapeType Defines what kind of subshapes is searched.
+ * \param theTolerance The tolerance for distances comparison. All shapes
+ * with distances to the given point in interval
+ * [minimal_distance, minimal_distance + theTolerance] will be gathered.
+ * \return New GEOM_Object, containing a group of all found shapes.
+ */
+ GEOM_Object GetShapesNearPoint (in GEOM_Object theShape,
+ in GEOM_Object thePoint,
+ in long theShapeType,
+ in double theTolerance);
+
/*!
* Extract blocks from blocks compounds
*/
GEOM_Object ChangeOrientation (in GEOM_Object theObject);
GEOM_Object ChangeOrientationCopy (in GEOM_Object theObject);
+ /*!
+ * Try to limit tolerance of the given object by value \a theTolerance.
+ * \param theObject Shape to be processed.
+ * \param theTolerance Required tolerance value.
+ * \return New GEOM_Object, containing processed shape.
+ */
+ GEOM_Object LimitTolerance (in GEOM_Object theObject, in double theTolerance);
+
};
/*!
filling.png \
fuse.png \
geometry.png \
+limit_tolerance.png \
line.png \
line2points.png \
line2faces.png \
<source>ICON_DLG_GLUE_FACES2</source>
<translation>glue2.png</translation>
</message>
+ <message>
+ <source>ICON_DLG_LIMIT_TOLERANCE</source>
+ <translation>limit_tolerance.png</translation>
+ </message>
<message>
<source>ICON_DLG_INERTIA</source>
<translation>axisinertia.png</translation>
<source>ICO_GLUE_FACES</source>
<translation>glue.png</translation>
</message>
+ <message>
+ <source>ICO_LIMIT_TOLERANCE</source>
+ <translation>limit_tolerance.png</translation>
+ </message>
<message>
<source>ICO_GROUP_CREATE</source>
<translation>group_new.png</translation>
<source>GEOM_GLUE_TITLE</source>
<translation>Glue faces</translation>
</message>
+ <message>
+ <source>GEOM_LIMIT_TOLERANCE_TITLE</source>
+ <translation>Limit tolerance</translation>
+ </message>
<message>
<source>GEOM_HEIGHT</source>
<translation>Height :</translation>
<source>GLUE_NEW_OBJ_NAME</source>
<translation>Glue</translation>
</message>
+ <message>
+ <source>LIMIT_TOLERANCE_NEW_OBJ_NAME</source>
+ <translation>Limit_tolerance</translation>
+ </message>
<message>
<source>MEN_ALL_SEL_ONLY</source>
<translation>Select All</translation>
<source>MEN_ISOS</source>
<translation>Isos</translation>
</message>
+ <message>
+ <source>MEN_LIMIT_TOLERANCE</source>
+ <translation>Limit tolerance</translation>
+ </message>
<message>
<source>MEN_LINE</source>
<translation>Line</translation>
<source>STB_LINE</source>
<translation>Create a line</translation>
</message>
+ <message>
+ <source>STB_LIMIT_TOLERANCE</source>
+ <translation>Limit tolerance</translation>
+ </message>
<message>
<source>STB_LOCAL_CS</source>
<translation>Create a local coordinate system</translation>
<source>TOP_LINE</source>
<translation>Create a line</translation>
</message>
+ <message>
+ <source>TOP_LIMIT_TOLERANCE</source>
+ <translation>Limit tolerance</translation>
+ </message>
<message>
<source>TOP_LOCAL_CS</source>
<translation>Create a local coordinate system</translation>
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+// GEOM GEOMGUI : GUI for Geometry component
+// File : GeometryGUI.cxx
+// Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
-// GEOM GEOMGUI : GUI for Geometry component
-// File : GeometryGUI.cxx
-// Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
-//
#include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
#include "Python.h"
#include "GeometryGUI.h"
case GEOMOp::OpFreeFaces: // MENU MEASURE - FREE FACES
case GEOMOp::OpOrientation: // MENU REPAIR - CHANGE ORIENTATION
case GEOMOp::OpGlueFaces: // MENU REPAIR - GLUE FACES
+ case GEOMOp::OpLimitTolerance: // MENU REPAIR - LIMIT TOLERANCE
case GEOMOp::OpRemoveExtraEdges: // MENU REPAIR - REMOVE EXTRA EDGES
libName = "RepairGUI";
break;
createAction( id,
tr( QString( "TOP_%1" ).arg( label ).toLatin1().constData() ),
icon,
- tr( QString( "MEN_%1" ).arg( label ).toLatin1().constData() ),
+ tr( QString( "MEN_%1" ).arg( label ).toLatin1().constData() ),
tr( QString( "STB_%1" ).arg( label ).toLatin1().constData() ),
accel,
application()->desktop(),
createGeomAction( GEOMOp::OpSewing, "SEWING" );
createGeomAction( GEOMOp::OpGlueFaces, "GLUE_FACES" );
+ createGeomAction( GEOMOp::OpLimitTolerance, "LIMIT_TOLERANCE" );
createGeomAction( GEOMOp::OpSuppressFaces, "SUPPRESS_FACES" );
createGeomAction( GEOMOp::OpSuppressHoles, "SUPPERSS_HOLES" );
createGeomAction( GEOMOp::OpShapeProcess, "SHAPE_PROCESS" );
createGeomAction( GEOMOp::OpShowChildren, "POP_SHOW_CHILDREN" );
createGeomAction( GEOMOp::OpHideChildren, "POP_HIDE_CHILDREN" );
createGeomAction( GEOMOp::OpPointMarker, "POP_POINT_MARKER" );
-
+
createGeomAction( GEOMOp::OpPipeTShape, "PIPETSHAPE" );
// createGeomAction( GEOMOp::OpPipeTShapeGroups, "PIPETSHAPEGROUPS" );
//@@ insert new functions before this line @@ do not remove this line @@ do not remove this line @@ do not remove this line @@ do not remove this line @@//
createMenu( GEOMOp::OpSuppressHoles, repairId, -1 );
createMenu( GEOMOp::OpSewing, repairId, -1 );
createMenu( GEOMOp::OpGlueFaces, repairId, -1 );
+ createMenu( GEOMOp::OpLimitTolerance, repairId, -1 );
createMenu( GEOMOp::OpAddPointOnEdge, repairId, -1 );
//createMenu( GEOMOp::OpFreeBoundaries, repairId, -1 );
//createMenu( GEOMOp::OpFreeFaces, repairId, -1 );
SALOME_ListIO selected;
sm->selectedObjects( selected );
sm->clearSelected();
-
+
// disable OCC selectors
getApp()->selectionMgr()->setEnabled( false, OCCViewer_Viewer::Type() );
QListIterator<GEOMGUI_OCCSelector*> itOCCSel( myOCCSelectors );
setPreferenceProperty( genGroup, "columns", 2 );
int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), genGroup,
- LightApp_Preferences::Selector,
+ LightApp_Preferences::Selector,
"Geometry", "display_mode" );
addPreference( tr( "PREF_SHADING_COLOR" ), genGroup,
int defl = addPreference( tr( "PREF_DEFLECTION" ), genGroup,
LightApp_Preferences::DblSpin, "Geometry", "deflection_coeff" );
-
+
// Quantities with individual precision settings
int precGroup = addPreference( tr( "GEOM_PREF_GROUP_PRECISION" ), tabId );
setPreferenceProperty( precGroup, "columns", 2 );
-
+
const int nbQuantities = 8;
int prec[nbQuantities], ii = 0;
prec[ii++] = addPreference( tr( "GEOM_PREF_length_precision" ), precGroup,
- LightApp_Preferences::IntSpin, "Geometry", "length_precision" );
+ LightApp_Preferences::IntSpin, "Geometry", "length_precision" );
prec[ii++] = addPreference( tr( "GEOM_PREF_angle_precision" ), precGroup,
- LightApp_Preferences::IntSpin, "Geometry", "angle_precision" );
+ LightApp_Preferences::IntSpin, "Geometry", "angle_precision" );
prec[ii++] = addPreference( tr( "GEOM_PREF_len_tol_precision" ), precGroup,
- LightApp_Preferences::IntSpin, "Geometry", "len_tol_precision" );
+ LightApp_Preferences::IntSpin, "Geometry", "len_tol_precision" );
prec[ii++] = addPreference( tr( "GEOM_PREF_ang_tol_precision" ), precGroup,
- LightApp_Preferences::IntSpin, "Geometry", "ang_tol_precision" );
+ LightApp_Preferences::IntSpin, "Geometry", "ang_tol_precision" );
prec[ii++] = addPreference( tr( "GEOM_PREF_weight_precision" ), precGroup,
- LightApp_Preferences::IntSpin, "Geometry", "weight_precision" );
+ LightApp_Preferences::IntSpin, "Geometry", "weight_precision" );
prec[ii++] = addPreference( tr( "GEOM_PREF_density_precision" ), precGroup,
- LightApp_Preferences::IntSpin, "Geometry", "density_precision" );
+ LightApp_Preferences::IntSpin, "Geometry", "density_precision" );
prec[ii++] = addPreference( tr( "GEOM_PREF_parametric_precision" ), precGroup,
- LightApp_Preferences::IntSpin, "Geometry", "parametric_precision" );
+ LightApp_Preferences::IntSpin, "Geometry", "parametric_precision" );
prec[ii ] = addPreference( tr( "GEOM_PREF_param_tol_precision" ), precGroup,
- LightApp_Preferences::IntSpin, "Geometry", "param_tol_precision" );
-
+ LightApp_Preferences::IntSpin, "Geometry", "param_tol_precision" );
+
// Set property for precision value for spinboxes
for ( ii = 0; ii < nbQuantities; ii++ ){
setPreferenceProperty( prec[ii], "min", -14 );
setPreferenceProperty( prec[ii], "max", 14 );
setPreferenceProperty( prec[ii], "precision", 2 );
- }
+ }
int VertexGroup = addPreference( tr( "PREF_GROUP_VERTEX" ), tabId );
setPreferenceProperty( VertexGroup, "columns", 2 );
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-
// File : GeometryGUI_Operations.h
// Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
-//
+
#ifndef GEOMETRYGUI_OPERATIONS_H
#define GEOMETRYGUI_OPERATIONS_H
OpOrientation = 4009, // MENU REPAIR - CHANGE ORIENTATION
OpGlueFaces = 4010, // MENU REPAIR - GLUE FACES
OpRemoveExtraEdges = 4011, // MENU REPAIR - REMOVE EXTRA EDGES
+ OpLimitTolerance = 4012, // MENU REPAIR - LIMIT TOLERANCE
// MeasureGUI ----------------//--------------------------------
OpProperties = 5000, // MENU MEASURES - PROPERTIES
OpCenterMass = 5001, // MENU MEASURES - CENTRE OF MASS
// OpPipeTShapeGroups = 10002, // MENU NEW ENTITY - ADVANCED - PIPE TSHAPE GROUPS
//@@ insert new functions before this line @@ do not remove this line @@//
};
-}
+}
#endif // GEOMETRYGUI_OPERATIONS_H
// 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>
#include <TopoDS_Iterator.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
+#include <TColStd_IndexedDataMapOfTransientTransient.hxx>
+#include <TNaming_CopyShape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <ShapeFix_Shape.hxx>
+#include <BRepCheck_Analyzer.hxx>
+
#include <Precision.hxx>
#include <StdFail_NotDone.hxx>
case CHANGE_ORIENTATION:
ChangeOrientation(&HI, anOriginalShape, aShape);
break;
+ case LIMIT_TOLERANCE:
+ LimitTolerance(&HI, anOriginalShape, aShape);
+ break;
default:
return 0;
}
return aResult;
}
+//=======================================================================
+//function : LimitTolerance
+//purpose :
+//=======================================================================
+void GEOMImpl_HealingDriver::LimitTolerance (GEOMImpl_IHealing* theHI,
+ const TopoDS_Shape& theOriginalShape,
+ TopoDS_Shape& theOutShape) const
+{
+ Standard_Real aTol = theHI->GetTolerance();
+ if (aTol < Precision::Confusion())
+ aTol = Precision::Confusion();
+
+ // 1. Make a copy to prevent the original shape changes.
+ TopoDS_Shape aShapeCopy;
+ TColStd_IndexedDataMapOfTransientTransient aMapTShapes;
+ TNaming_CopyShape::CopyTool(theOriginalShape, aMapTShapes, aShapeCopy);
+
+ // 2. Limit tolerance.
+ ShapeFix_ShapeTolerance aSFT;
+ aSFT.LimitTolerance(aShapeCopy, aTol, aTol, TopAbs_SHAPE);
+
+ // 3. Fix obtained shape.
+ Handle(ShapeFix_Shape) aSfs = new ShapeFix_Shape (aShapeCopy);
+ aSfs->Perform();
+ theOutShape = aSfs->Shape();
+
+ BRepCheck_Analyzer ana (theOutShape, Standard_True);
+ if (!ana.IsValid())
+ StdFail_NotDone::Raise("Non valid shape result");
+}
//=======================================================================
//function : GEOMImpl_HealingDriver_Type_
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-
// File : GEOMImpl_HealingDriver.hxx
// Module : GEOMImpl
-//
+
#ifndef _GEOMImpl_HealingDriver_HeaderFile
#define _GEOMImpl_HealingDriver_HeaderFile
//
Standard_EXPORT friend Handle_Standard_Type& GEOMImpl_HealingDriver_Type_();
Standard_EXPORT const Handle(Standard_Type)& DynamicType() const { return STANDARD_TYPE(GEOMImpl_HealingDriver) ; }
-Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)& AType) const { return (STANDARD_TYPE(GEOMImpl_HealingDriver) == AType || TFunction_Driver::IsKind(AType)); }
+Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)& AType) const { return (STANDARD_TYPE(GEOMImpl_HealingDriver) == AType || TFunction_Driver::IsKind(AType)); }
private:
Standard_Boolean ShapeProcess ( GEOMImpl_IHealing*, const TopoDS_Shape&, TopoDS_Shape& ) const;
Standard_Boolean Sew ( GEOMImpl_IHealing*, const TopoDS_Shape&, TopoDS_Shape& ) const;
Standard_Boolean AddPointOnEdge( GEOMImpl_IHealing*, const TopoDS_Shape&, TopoDS_Shape& ) const;
Standard_Boolean ChangeOrientation( GEOMImpl_IHealing*, const TopoDS_Shape&, TopoDS_Shape& ) const;
-
+void LimitTolerance( GEOMImpl_IHealing*, const TopoDS_Shape&, TopoDS_Shape& ) const;
};
return aResult;
}
+//=============================================================================
+/*!
+ * GetVertexNearPoint
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetVertexNearPoint
+ (Handle(GEOM_Object) theShape,
+ Handle(GEOM_Object) thePoint)
+{
+ SetErrorCode(KO);
+
+ // New Point object
+ Handle(GEOM_Object) aResult;
+
+ // Arguments
+ if (theShape.IsNull() || thePoint.IsNull()) return NULL;
+
+ TopoDS_Shape aBlockOrComp = theShape->GetValue();
+ TopoDS_Shape aPoint = thePoint->GetValue();
+ if (aBlockOrComp.IsNull() || aPoint.IsNull()) {
+ SetErrorCode("Given shape is null");
+ return NULL;
+ }
+
+ if (aPoint.ShapeType() != TopAbs_VERTEX) {
+ SetErrorCode("Element for vertex identification is not a vertex");
+ return NULL;
+ }
+
+ TopoDS_Vertex aVert = TopoDS::Vertex(aPoint);
+ gp_Pnt aP = BRep_Tool::Pnt(aVert);
+
+ // Compute the Vertex value
+ TopoDS_Shape V;
+ bool isFound = false;
+ Standard_Real aDist = RealLast();
+ TopTools_MapOfShape mapShape;
+
+ TopExp_Explorer exp (aBlockOrComp, TopAbs_VERTEX);
+ for (; exp.More(); exp.Next()) {
+ if (mapShape.Add(exp.Current())) {
+ TopoDS_Vertex aVi = TopoDS::Vertex(exp.Current());
+ gp_Pnt aPi = BRep_Tool::Pnt(aVi);
+ Standard_Real aDisti = aPi.Distance(aP);
+ if (aDisti < aDist) {
+ V = aVi;
+ aDist = aDisti;
+ isFound = true;
+ }
+ }
+ }
+
+ if (!isFound) {
+ SetErrorCode("Vertex has not been found");
+ return NULL;
+ }
+
+ TopTools_IndexedMapOfShape anIndices;
+ TopExp::MapShapes(aBlockOrComp, anIndices);
+ Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
+ anArray->SetValue(1, anIndices.FindIndex(V));
+ aResult = GetEngine()->AddSubShape(theShape, anArray);
+
+ // The GetPoint() doesn't change object so no new function is required.
+ Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
+
+ // Make a Python command
+ GEOM::TPythonDump(aFunction, /*append=*/true)
+ << aResult << " = geompy.GetVertexNearPoint("
+ << theShape << ", " << thePoint << ")";
+
+ SetErrorCode(OK);
+ return aResult;
+}
+
//=============================================================================
/*!
* GetEdge
return aResult;
}
+//=============================================================================
+/*!
+ * GetShapesNearPoint
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IBlocksOperations::GetShapesNearPoint
+ (Handle(GEOM_Object) theShape,
+ Handle(GEOM_Object) thePoint,
+ const Standard_Integer theShapeType,
+ const Standard_Real theTolerance)
+{
+ SetErrorCode(KO);
+
+ // New object
+ Handle(GEOM_Object) aResult;
+
+ // Arguments
+ if (theShape.IsNull() || thePoint.IsNull()) return NULL;
+
+ TopoDS_Shape aBlockOrComp = theShape->GetValue();
+ if (aBlockOrComp.IsNull()) {
+ SetErrorCode("Block or compound is null");
+ return NULL;
+ }
+
+ TopoDS_Shape anArg = thePoint->GetValue();
+ if (anArg.IsNull()) {
+ SetErrorCode("Null shape is given as argument");
+ return NULL;
+ }
+ if (anArg.ShapeType() != TopAbs_VERTEX) {
+ SetErrorCode("Element for face identification is not a vertex");
+ return NULL;
+ }
+
+ if (theShapeType < TopAbs_SOLID || TopAbs_VERTEX < theShapeType) {
+ SetErrorCode("Invalid type of result is requested");
+ return NULL;
+ }
+
+ if (theTolerance < Precision::Confusion()) {
+ theTolerance == Precision::Confusion();
+ }
+
+ // Compute the result
+ try {
+#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
+ OCC_CATCH_SIGNALS;
+#endif
+ TopoDS_Vertex aVert = TopoDS::Vertex(anArg);
+
+ TopTools_MapOfShape mapShape;
+ Standard_Integer nbEdges = 0;
+ TopExp_Explorer exp (aBlockOrComp, TopAbs_ShapeEnum(theShapeType));
+ for (; exp.More(); exp.Next()) {
+ if (mapShape.Add(exp.Current())) {
+ nbEdges++;
+ }
+ }
+
+ if (nbEdges == 0) {
+ SetErrorCode("Given shape contains no subshapes of requested type");
+ return NULL;
+ }
+
+ // Calculate distances and find min
+ mapShape.Clear();
+ Standard_Integer ind = 1;
+ Standard_Real aMinDist = RealLast();
+ TopTools_Array1OfShape anEdges (1, nbEdges);
+ TColStd_Array1OfReal aDistances (1, nbEdges);
+ for (exp.Init(aBlockOrComp, TopAbs_ShapeEnum(theShapeType)); exp.More(); exp.Next()) {
+ if (mapShape.Add(exp.Current())) {
+ TopoDS_Shape anEdge = exp.Current();
+ anEdges(ind) = anEdge;
+
+ BRepExtrema_DistShapeShape aDistTool (aVert, anEdges(ind));
+ if (!aDistTool.IsDone()) {
+ SetErrorCode("Can not find a distance from the given point to one of subshapes");
+ return NULL;
+ }
+ aDistances(ind) = aDistTool.Value();
+ if (aDistances(ind) < aMinDist) {
+ aMinDist = aDistances(ind);
+ }
+ ind++;
+ }
+ }
+
+ if (aMinDist < RealLast()) {
+ // Collect subshapes with distance < (aMinDist + theTolerance)
+ int nbSubShapes = 0;
+ TopTools_Array1OfShape aNearShapes (1, nbEdges);
+ for (ind = 1; ind <= nbEdges; ind++) {
+ if (aDistances(ind) < aMinDist + theTolerance) {
+ nbSubShapes++;
+ aNearShapes(nbSubShapes) = anEdges(ind);
+ }
+ }
+
+ // Add subshape
+ TopTools_IndexedMapOfShape anIndices;
+ TopExp::MapShapes(aBlockOrComp, anIndices);
+ Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger (1, nbSubShapes);
+ for (ind = 1; ind <= nbSubShapes; ind++) {
+ anArray->SetValue(ind, anIndices.FindIndex(aNearShapes(ind)));
+ }
+ aResult = GetEngine()->AddSubShape(theShape, anArray);
+ }
+ }
+ catch (Standard_Failure) {
+ Handle(Standard_Failure) aFail = Standard_Failure::Caught();
+ SetErrorCode(aFail->GetMessageString());
+ return NULL;
+ }
+
+ if (aResult.IsNull())
+ return NULL;
+
+ Handle(GEOM_Function) aFunction = aResult->GetLastFunction();
+
+ //Make a Python command
+ GEOM::TPythonDump(aFunction)
+ << aResult << " = geompy.GetShapesNearPoint(" << theShape << ", " << thePoint
+ << ", " << TopAbs_ShapeEnum(theShapeType) << ", " << theTolerance << ")";
+
+ SetErrorCode(OK);
+ return aResult;
+}
+
//=============================================================================
/*!
* IsCompoundOfBlocks
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
#ifndef _GEOMImpl_IBlocksOperations_HXX_
#define _GEOMImpl_IBlocksOperations_HXX_
// Creation of blocks and block faces
Standard_EXPORT Handle(GEOM_Object) MakeQuad (Handle(GEOM_Object) theEdge1,
- Handle(GEOM_Object) theEdge2,
- Handle(GEOM_Object) theEdge3,
- Handle(GEOM_Object) theEdge4);
+ Handle(GEOM_Object) theEdge2,
+ Handle(GEOM_Object) theEdge3,
+ Handle(GEOM_Object) theEdge4);
Standard_EXPORT Handle(GEOM_Object) MakeQuad2Edges (Handle(GEOM_Object) theEdge1,
- Handle(GEOM_Object) theEdge2);
+ Handle(GEOM_Object) theEdge2);
Standard_EXPORT Handle(GEOM_Object) MakeQuad4Vertices (Handle(GEOM_Object) thePoint1,
- Handle(GEOM_Object) thePoint2,
- Handle(GEOM_Object) thePoint3,
- Handle(GEOM_Object) thePoint4);
+ Handle(GEOM_Object) thePoint2,
+ Handle(GEOM_Object) thePoint3,
+ Handle(GEOM_Object) thePoint4);
Standard_EXPORT Handle(GEOM_Object) MakeHexa (Handle(GEOM_Object) theFace1,
- Handle(GEOM_Object) theFace2,
- Handle(GEOM_Object) theFace3,
- Handle(GEOM_Object) theFace4,
- Handle(GEOM_Object) theFace5,
- Handle(GEOM_Object) theFace6);
+ Handle(GEOM_Object) theFace2,
+ Handle(GEOM_Object) theFace3,
+ Handle(GEOM_Object) theFace4,
+ Handle(GEOM_Object) theFace5,
+ Handle(GEOM_Object) theFace6);
Standard_EXPORT Handle(GEOM_Object) MakeHexa2Faces (Handle(GEOM_Object) theFace1,
- Handle(GEOM_Object) theFace2);
+ Handle(GEOM_Object) theFace2);
Standard_EXPORT Handle(GEOM_Object) MakeBlockCompound (Handle(GEOM_Object) theCompound);
// Extract elements of blocks and blocks compounds
Standard_EXPORT Handle(GEOM_Object) GetPoint (Handle(GEOM_Object) theShape,
- const Standard_Real theX,
- const Standard_Real theY,
- const Standard_Real theZ,
- const Standard_Real theEpsilon);
+ const Standard_Real theX,
+ const Standard_Real theY,
+ const Standard_Real theZ,
+ const Standard_Real theEpsilon);
+
+ Standard_EXPORT Handle(GEOM_Object) GetVertexNearPoint (Handle(GEOM_Object) theShape,
+ Handle(GEOM_Object) thePoint);
Standard_EXPORT Handle(GEOM_Object) GetEdge (Handle(GEOM_Object) theShape,
- Handle(GEOM_Object) thePoint1,
- Handle(GEOM_Object) thePoint2);
+ Handle(GEOM_Object) thePoint1,
+ Handle(GEOM_Object) thePoint2);
Standard_EXPORT Handle(GEOM_Object) GetEdgeNearPoint (Handle(GEOM_Object) theBlock,
- Handle(GEOM_Object) thePoint);
+ Handle(GEOM_Object) thePoint);
Standard_EXPORT Handle(GEOM_Object) GetFaceByPoints (Handle(GEOM_Object) theShape,
- Handle(GEOM_Object) thePoint1,
- Handle(GEOM_Object) thePoint2,
- Handle(GEOM_Object) thePoint3,
- Handle(GEOM_Object) thePoint4);
+ Handle(GEOM_Object) thePoint1,
+ Handle(GEOM_Object) thePoint2,
+ Handle(GEOM_Object) thePoint3,
+ Handle(GEOM_Object) thePoint4);
Standard_EXPORT Handle(GEOM_Object) GetFaceByEdges (Handle(GEOM_Object) theShape,
- Handle(GEOM_Object) theEdge1,
- Handle(GEOM_Object) theEdge2);
+ Handle(GEOM_Object) theEdge1,
+ Handle(GEOM_Object) theEdge2);
Standard_EXPORT Handle(GEOM_Object) GetOppositeFace (Handle(GEOM_Object) theBlock,
- Handle(GEOM_Object) theFace);
+ Handle(GEOM_Object) theFace);
Standard_EXPORT Handle(GEOM_Object) GetFaceNearPoint (Handle(GEOM_Object) theBlock,
- Handle(GEOM_Object) thePoint);
+ Handle(GEOM_Object) thePoint);
Standard_EXPORT Handle(GEOM_Object) GetFaceByNormale (Handle(GEOM_Object) theBlock,
- Handle(GEOM_Object) theVector);
+ Handle(GEOM_Object) theVector);
+
+ Standard_EXPORT Handle(GEOM_Object) GetShapesNearPoint (Handle(GEOM_Object) theShape,
+ Handle(GEOM_Object) thePoint,
+ const Standard_Integer theShapeType,
+ const Standard_Real theTolerance);
// Check blocks compounds
Standard_EXPORT Standard_Boolean IsCompoundOfBlocks (Handle(GEOM_Object) theCompound,
- const Standard_Integer theMinNbFaces,
- const Standard_Integer theMaxNbFaces,
- Standard_Integer& theNbBlocks);
+ const Standard_Integer theMinNbFaces,
+ const Standard_Integer theMaxNbFaces,
+ Standard_Integer& theNbBlocks);
enum BCErrorType {
NOT_BLOCK,
};
Standard_EXPORT Standard_Boolean CheckCompoundOfBlocksOld (Handle(GEOM_Object) theCompound,
- std::list<BCError>& theErrors);
+ std::list<BCError>& theErrors);
Standard_EXPORT Standard_Boolean CheckCompoundOfBlocks (Handle(GEOM_Object) theCompound,
- std::list<BCError>& theErrors);
+ std::list<BCError>& theErrors);
Standard_EXPORT TCollection_AsciiString PrintBCErrors (Handle(GEOM_Object) theCompound,
- const std::list<BCError>& theErrors);
+ const std::list<BCError>& theErrors);
Standard_EXPORT Handle(GEOM_Object) RemoveExtraEdges (Handle(GEOM_Object) theShape,
const Standard_Integer theOptimumNbFaces = 6);
Standard_EXPORT Handle(GEOM_Object) CheckAndImprove (Handle(GEOM_Object) theCompound);
Standard_EXPORT static void AddBlocksFrom (const TopoDS_Shape& theShape,
- TopTools_ListOfShape& BLO,
- TopTools_ListOfShape& NOT,
- TopTools_ListOfShape& EXT);
+ TopTools_ListOfShape& BLO,
+ TopTools_ListOfShape& NOT,
+ TopTools_ListOfShape& EXT);
// Extract blocks from blocks compounds
Standard_EXPORT Handle(TColStd_HSequenceOfTransient) ExplodeCompoundOfBlocks
const Standard_Integer theMaxNbFaces);
Standard_EXPORT Handle(GEOM_Object) GetBlockNearPoint (Handle(GEOM_Object) theCompound,
- Handle(GEOM_Object) thePoint);
+ Handle(GEOM_Object) thePoint);
Standard_EXPORT Handle(GEOM_Object) GetBlockByParts
(Handle(GEOM_Object) theCompound,
// Operations on blocks with gluing of result
Standard_EXPORT Handle(GEOM_Object) MakeMultiTransformation1D (Handle(GEOM_Object) theBlock,
- const Standard_Integer theDirFace1,
- const Standard_Integer theDirFace2,
- const Standard_Integer theNbTimes);
+ const Standard_Integer theDirFace1,
+ const Standard_Integer theDirFace2,
+ const Standard_Integer theNbTimes);
Standard_EXPORT Handle(GEOM_Object) MakeMultiTransformation2D (Handle(GEOM_Object) theBlock,
- const Standard_Integer theDirFace1U,
- const Standard_Integer theDirFace2U,
- const Standard_Integer theNbTimesU,
- const Standard_Integer theDirFace1V,
- const Standard_Integer theDirFace2V,
- const Standard_Integer theNbTimesV);
+ const Standard_Integer theDirFace1U,
+ const Standard_Integer theDirFace2U,
+ const Standard_Integer theNbTimesU,
+ const Standard_Integer theDirFace1V,
+ const Standard_Integer theDirFace2V,
+ const Standard_Integer theNbTimesV);
// Build groups for Propagation of 1D hypotheses
Standard_EXPORT Handle(TColStd_HSequenceOfTransient) Propagate (Handle(GEOM_Object) theShape);
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+// NOTE: This is an intreface to a function for the Healing creation.
-//NOTE: This is an intreface to a function for the Healing creation.
-//
#include "GEOM_Function.hxx"
#include <TColStd_HArray1OfInteger.hxx>
void SetIndex( Standard_Integer val ) { _func->SetInteger(ARG_SUBSHAPE_INDEX, val); }
Standard_Integer GetIndex() { return _func->GetInteger(ARG_SUBSHAPE_INDEX); }
-
+
private:
- Handle(GEOM_Function) _func;
+ Handle(GEOM_Function) _func;
};
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
#ifdef WNT
#pragma warning( disable:4786 )
return theObject;
}
-
//=============================================================================
/*!
* ChangeOrientationCopy
SetErrorCode(OK);
return aNewObject;
}
+
+//=============================================================================
+/*!
+ * LimitTolerance
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IHealingOperations::LimitTolerance (Handle(GEOM_Object) theObject,
+ double theTolerance)
+{
+ // Set error code, check parameters
+ SetErrorCode(KO);
+
+ if (theObject.IsNull())
+ return NULL;
+
+ Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
+ if (aLastFunction.IsNull())
+ return NULL; // There is no function which creates an object to be processed
+
+ // Add a new object
+ Handle(GEOM_Object) aNewObject = GetEngine()->AddObject(GetDocID(), theObject->GetType());
+
+ // Add the function
+ aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), LIMIT_TOLERANCE);
+
+ if (aFunction.IsNull())
+ return NULL;
+
+ // Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
+
+ // Prepare "data container" class IHealing
+ GEOMImpl_IHealing HI (aFunction);
+ HI.SetOriginal(aLastFunction);
+ HI.SetTolerance(theTolerance);
+
+ // Compute
+ try {
+#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
+ OCC_CATCH_SIGNALS;
+#endif
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Healing driver failed");
+ return NULL;
+ }
+ }
+ catch (Standard_Failure) {
+ Handle(Standard_Failure) aFail = Standard_Failure::Caught();
+ SetErrorCode(aFail->GetMessageString());
+ return NULL;
+ }
+
+ // Make a Python command
+ GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.LimitTolerance("
+ << theObject << ", " << theTolerance << ")";
+
+ SetErrorCode(OK);
+ return aNewObject;
+}
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
#ifndef _GEOMImpl_IHealingOperations_HXX_
#define _GEOMImpl_IHealingOperations_HXX_
// Apply Shape Processing to the selected Object
Standard_EXPORT Handle(GEOM_Object) ShapeProcess( Handle(GEOM_Object) theObject,
- const Handle(TColStd_HArray1OfExtendedString)& theOperations,
- const Handle(TColStd_HArray1OfExtendedString)& theParams,
- const Handle(TColStd_HArray1OfExtendedString)& theValues );
+ const Handle(TColStd_HArray1OfExtendedString)& theOperations,
+ const Handle(TColStd_HArray1OfExtendedString)& theParams,
+ const Handle(TColStd_HArray1OfExtendedString)& theValues );
// Retrieve default Shape Process parameters (from resource file)
Standard_EXPORT void GetShapeProcessParameters( std::list<std::string>& theOperations,
std::list<std::string>& theValues );
// Retrieve default Shape Process parameters for given operator
- Standard_EXPORT bool GetOperatorParameters( const std::string theOperation,
+ Standard_EXPORT bool GetOperatorParameters( const std::string theOperation,
std::list<std::string>& theParams,
std::list<std::string>& theValues );
// returns all parameters that are valid for the given operation (Shape Process operator)
- Standard_EXPORT static bool GetParameters( const std::string theOperation, std::list<std::string>& theParams );
+ Standard_EXPORT static bool GetParameters( const std::string theOperation,
+ std::list<std::string>& theParams );
Standard_EXPORT Handle(GEOM_Object) SuppressFaces( Handle(GEOM_Object) theObject,
const Handle(TColStd_HArray1OfInteger)& theFaces);
Standard_EXPORT Handle(GEOM_Object) FillHoles( Handle(GEOM_Object) theObject,
const Handle(TColStd_HArray1OfInteger)& theWires);
-
+
Standard_EXPORT Handle(GEOM_Object) Sew( Handle(GEOM_Object) theObject,
double theTolerance );
Standard_EXPORT Handle(GEOM_Object) DivideEdge( Handle(GEOM_Object) theObject,
- int theIndex,
- double theValue,
- bool isByParameter );
+ int theIndex,
+ double theValue,
+ bool isByParameter );
// this function does not use Function-Driver mechanism, it just computes the free
// boundary edges and returns them in the sequence. It is called just for information reasons
// and it's not intended for history/undo/redo/etc..
- Standard_EXPORT bool GetFreeBoundary ( Handle(GEOM_Object) theObject,
- Handle(TColStd_HSequenceOfTransient)& theOutClosedWires,
+ Standard_EXPORT bool GetFreeBoundary ( Handle(GEOM_Object) theObject,
+ Handle(TColStd_HSequenceOfTransient)& theOutClosedWires,
Handle(TColStd_HSequenceOfTransient)& theOutOpenWires );
Standard_EXPORT Handle(GEOM_Object) ChangeOrientation( Handle(GEOM_Object) theObject);
Standard_EXPORT Handle(GEOM_Object) ChangeOrientationCopy( Handle(GEOM_Object) theObject);
+ Standard_EXPORT Handle(GEOM_Object) LimitTolerance( Handle(GEOM_Object) theObject,
+ double theTolerance );
+
};
#endif
#define SEWING 6
#define DIVIDE_EDGE 7
#define CHANGE_ORIENTATION 8
+#define LIMIT_TOLERANCE 9
#define BASIC_FILLING 1
return GetObject(anObject);
}
+//=============================================================================
+/*!
+ * GetVertexNearPoint
+ */
+//=============================================================================
+GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetVertexNearPoint
+ (GEOM::GEOM_Object_ptr theShape,
+ GEOM::GEOM_Object_ptr thePoint)
+{
+ GEOM::GEOM_Object_var aGEOMObject;
+
+ // Set a not done flag
+ GetOperations()->SetNotDone();
+
+ // Get the reference Objects
+ Handle(GEOM_Object) aShape = GetObjectImpl(theShape);
+ Handle(GEOM_Object) aPoint = GetObjectImpl(thePoint);
+ if (aShape.IsNull() || aPoint.IsNull()) return aGEOMObject._retn();
+
+ // Create the Point
+ Handle(GEOM_Object) anObject =
+ GetOperations()->GetVertexNearPoint(aShape, aPoint);
+ if (!GetOperations()->IsDone() || anObject.IsNull())
+ return aGEOMObject._retn();
+
+ return GetObject(anObject);
+}
+
//=============================================================================
/*!
* GetEdge
return GetObject(anObject);
}
+//=============================================================================
+/*!
+ * GetShapesNearPoint
+ */
+//=============================================================================
+GEOM::GEOM_Object_ptr GEOM_IBlocksOperations_i::GetShapesNearPoint
+ (GEOM::GEOM_Object_ptr theShape,
+ GEOM::GEOM_Object_ptr thePoint,
+ CORBA::Long theShapeType,
+ 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);
+ Handle(GEOM_Object) aPoint = GetObjectImpl(thePoint);
+
+ if (aShape.IsNull() || aPoint.IsNull()) return aGEOMObject._retn();
+
+ // Create the Shape
+ Handle(GEOM_Object) anObject =
+ GetOperations()->GetShapesNearPoint(aShape, aPoint, theShapeType, theTolerance);
+ if (!GetOperations()->IsDone() || anObject.IsNull())
+ return aGEOMObject._retn();
+
+ return GetObject(anObject);
+}
+
//=============================================================================
/*!
* ExplodeCompoundOfBlocks
CORBA::Double theZ,
CORBA::Double theEpsilon);
+ GEOM::GEOM_Object_ptr GetVertexNearPoint (GEOM::GEOM_Object_ptr theShape,
+ GEOM::GEOM_Object_ptr thePoint);
+
GEOM::GEOM_Object_ptr GetEdge (GEOM::GEOM_Object_ptr theShape,
GEOM::GEOM_Object_ptr thePoint1,
GEOM::GEOM_Object_ptr thePoint2);
GEOM::GEOM_Object_ptr GetFaceByNormale (GEOM::GEOM_Object_ptr theBlock,
GEOM::GEOM_Object_ptr theVector);
+ GEOM::GEOM_Object_ptr GetShapesNearPoint (GEOM::GEOM_Object_ptr theShape,
+ GEOM::GEOM_Object_ptr thePoint,
+ CORBA::Long theShapeType,
+ CORBA::Double theTolerance);
+
// Check blocks compound
CORBA::Boolean IsCompoundOfBlocks (GEOM::GEOM_Object_ptr theCompound,
- CORBA::Long theMinNbFaces,
- CORBA::Long theMaxNbFaces,
+ CORBA::Long theMinNbFaces,
+ CORBA::Long theMaxNbFaces,
CORBA::Long& theNbBlocks);
CORBA::Boolean CheckCompoundOfBlocks (GEOM::GEOM_Object_ptr theCompound,
// 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>
return GetObject(aNewObject);
}
+
+//=============================================================================
+/*!
+ * LimitTolerance
+ */
+//=============================================================================
+GEOM::GEOM_Object_ptr GEOM_IHealingOperations_i::LimitTolerance (GEOM::GEOM_Object_ptr theObject,
+ CORBA::Double theTolerance)
+{
+ GEOM::GEOM_Object_var aGEOMObject;
+
+ // Set a not done flag
+ GetOperations()->SetNotDone();
+
+ // Get the object itself
+ Handle(GEOM_Object) anObject = GetObjectImpl(theObject);
+ if (anObject.IsNull())
+ return aGEOMObject._retn();
+
+ // Perform
+ Handle(GEOM_Object) aNewObject =
+ GetOperations()->LimitTolerance(anObject, theTolerance);
+ if (!GetOperations()->IsDone() || aNewObject.IsNull())
+ return aGEOMObject._retn();
+
+ return GetObject(aNewObject);
+}
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
+
#ifndef _GEOM_IHealingOperations_i_HeaderFile
#define _GEOM_IHealingOperations_i_HeaderFile
#include <TColStd_HArray1OfExtendedString.hxx>
#include <TColStd_HArray1OfInteger.hxx>
-class GEOM_I_EXPORT GEOM_IHealingOperations_i :
+class GEOM_I_EXPORT GEOM_IHealingOperations_i :
public virtual POA_GEOM::GEOM_IHealingOperations,
public virtual GEOM_IOperations_i
{
public:
- GEOM_IHealingOperations_i(PortableServer::POA_ptr thePOA, GEOM::GEOM_Gen_ptr theEngine, ::GEOMImpl_IHealingOperations* theImpl);
+ GEOM_IHealingOperations_i(PortableServer::POA_ptr thePOA,
+ GEOM::GEOM_Gen_ptr theEngine,
+ ::GEOMImpl_IHealingOperations* theImpl);
~GEOM_IHealingOperations_i();
-
- GEOM::GEOM_Object_ptr ProcessShape(GEOM::GEOM_Object_ptr theObject, const GEOM::string_array& theOperations, const GEOM::string_array& theParams, const GEOM::string_array& theValues);
- void GetShapeProcessParameters(GEOM::string_array_out theOperations, GEOM::string_array_out theParams, GEOM::string_array_out theValues);
+ GEOM::GEOM_Object_ptr ProcessShape(GEOM::GEOM_Object_ptr theObject,
+ const GEOM::string_array& theOperations,
+ const GEOM::string_array& theParams,
+ const GEOM::string_array& theValues);
+
+ void GetShapeProcessParameters(GEOM::string_array_out theOperations,
+ GEOM::string_array_out theParams,
+ GEOM::string_array_out theValues);
- void GetOperatorParameters (const char* theOperator, GEOM::string_array_out theParams, GEOM::string_array_out theValues);
+ void GetOperatorParameters (const char* theOperator,
+ GEOM::string_array_out theParams,
+ GEOM::string_array_out theValues);
- GEOM::GEOM_Object_ptr SuppressFaces(GEOM::GEOM_Object_ptr theObject, const GEOM::short_array& theFaces);
+ GEOM::GEOM_Object_ptr SuppressFaces(GEOM::GEOM_Object_ptr theObject,
+ const GEOM::short_array& theFaces);
- GEOM::GEOM_Object_ptr CloseContour (GEOM::GEOM_Object_ptr theObject, const GEOM::short_array& theWires, CORBA::Boolean isCommonVertex);
+ GEOM::GEOM_Object_ptr CloseContour (GEOM::GEOM_Object_ptr theObject,
+ const GEOM::short_array& theWires,
+ CORBA::Boolean isCommonVertex);
- GEOM::GEOM_Object_ptr RemoveIntWires (GEOM::GEOM_Object_ptr theObject, const GEOM::short_array& theWires);
-
- GEOM::GEOM_Object_ptr FillHoles (GEOM::GEOM_Object_ptr theObject, const GEOM::short_array& theWires);
+ GEOM::GEOM_Object_ptr RemoveIntWires (GEOM::GEOM_Object_ptr theObject,
+ const GEOM::short_array& theWires);
- GEOM::GEOM_Object_ptr Sew (GEOM::GEOM_Object_ptr theObject, CORBA::Double theTolerance);
+ GEOM::GEOM_Object_ptr FillHoles (GEOM::GEOM_Object_ptr theObject,
+ const GEOM::short_array& theWires);
- GEOM::GEOM_Object_ptr DivideEdge (GEOM::GEOM_Object_ptr theObject, CORBA::Short theIndex, CORBA::Double theValue, CORBA::Boolean isByParameter);
+ GEOM::GEOM_Object_ptr Sew (GEOM::GEOM_Object_ptr theObject,
+ CORBA::Double theTolerance);
+
+ GEOM::GEOM_Object_ptr DivideEdge (GEOM::GEOM_Object_ptr theObject,
+ CORBA::Short theIndex,
+ CORBA::Double theValue,
+ CORBA::Boolean isByParameter);
+
+ CORBA::Boolean GetFreeBoundary(GEOM::GEOM_Object_ptr theObject,
+ GEOM::ListOfGO_out theClosedWires,
+ GEOM::ListOfGO_out theOpenWires );
- CORBA::Boolean GetFreeBoundary(GEOM::GEOM_Object_ptr theObject, GEOM::ListOfGO_out theClosedWires, GEOM::ListOfGO_out theOpenWires );
-
GEOM::GEOM_Object_ptr ChangeOrientation (GEOM::GEOM_Object_ptr theObject);
GEOM::GEOM_Object_ptr ChangeOrientationCopy (GEOM::GEOM_Object_ptr theObject);
+ GEOM::GEOM_Object_ptr LimitTolerance (GEOM::GEOM_Object_ptr theObject,
+ CORBA::Double theTolerance);
+
::GEOMImpl_IHealingOperations* GetOperations() { return (::GEOMImpl_IHealingOperations*)GetImpl(); }
private:
- Handle(TColStd_HArray1OfExtendedString) Convert( const GEOM::string_array& );
- Handle(TColStd_HArray1OfInteger) Convert( const GEOM::short_array& );
+ Handle(TColStd_HArray1OfExtendedString) Convert( const GEOM::string_array& );
+ Handle(TColStd_HArray1OfInteger) Convert( const GEOM::short_array& );
};
geompy.addToStudyInFather(blocksComp, pb0_top_1, "point from blocksComp (-50, 50, 50)")
geompy.addToStudyInFather(blocksComp, pb0_bot_1, "point from blocksComp (-50, -50, -50)")
+ # GetVertexNearPoint(theShape, thePoint)
+ pb0_top_2_near = geompy.MakeVertex(40, 40, 40)
+ pb0_top_2 = geompy.GetVertexNearPoint(blocksComp, pb0_top_2_near)
+
+ geompy.addToStudyInFather(blocksComp, pb0_top_2, "point from blocksComp near (40, 40, 40)")
+
+ # GetEdge(theShape, thePoint1, thePoint2)
+ edge_top_y50 = geompy.GetEdge(blocksComp, pb0_top_1, pb0_top_2)
+
+ geompy.addToStudyInFather(blocksComp, edge_top_y50, "edge from blocksComp by two points")
+
# GetEdgeNearPoint(theShape, thePoint)
pmidle = geompy.MakeVertex(50, 0, 50)
edge1 = geompy.GetEdgeNearPoint(blocksComp, pmidle)
geompy.addToStudyInFather(blocksComp, b0_image, "b0 image")
+ # GetShapesNearPoint(theShape, thePoint, theShapeType, theTolerance)
+ b0_faces_plus = geompy.GetShapesNearPoint(blocksComp, pb0_top_2_near, geompy.ShapeType["FACE"], 0.01)
+
+ geompy.addToStudyInFather(blocksComp, b0_faces_plus, "faces near point (40, 40, 40)")
+
# GetShapesOnPlane
faces_on_pln = geompy.GetShapesOnPlane(blocksComp, geompy.ShapeType["FACE"],
v_0pp, geompy.GEOM.ST_ONIN)
# @return New GEOM_Object, containing the created point.
#
# @ref tui_creation_point "Example"
- def MakeVertex(self,theX, theY, theZ):
+ def MakeVertex(self, theX, theY, theZ):
# Example: see GEOM_TestAll.py
theX,theY,theZ,Parameters = ParseParameters(theX, theY, theZ)
anObj = self.BasicOp.MakePointXYZ(theX, theY, theZ)
# @return New GEOM_Object, containing processed shape.
#
# @ref swig_todo "Example"
- def ChangeOrientationShellCopy(self,theObject):
+ def ChangeOrientationShellCopy(self, theObject):
anObj = self.HealOp.ChangeOrientationCopy(theObject)
RaiseIfFailed("ChangeOrientationCopy", self.HealOp)
return anObj
+ ## Try to limit tolerance of the given object by value \a theTolerance.
+ # @param theObject Shape to be processed.
+ # @param theTolerance Required tolerance value.
+ # @return New GEOM_Object, containing processed shape.
+ #
+ # @ref tui_limit_tolerance "Example"
+ def LimitTolerance(self, theObject, theTolerance = 1e-07):
+ anObj = self.HealOp.LimitTolerance(theObject, theTolerance)
+ RaiseIfFailed("LimitTolerance", self.HealOp)
+ return anObj
+
## Get a list of wires (wrapped in GEOM_Object-s),
# that constitute a free boundary of the given shape.
# @param theObject Shape to get free boundary of.
# theOpenWires: Open wires on the free boundary of the given shape.
#
# @ref tui_measurement_tools_page "Example"
- def GetFreeBoundary(self,theObject):
+ def GetFreeBoundary(self, theObject):
# Example: see GEOM_TestHealing.py
anObj = self.HealOp.GetFreeBoundary(theObject)
RaiseIfFailed("GetFreeBoundary", self.HealOp)
# @return New GEOM_Object, containing the found vertex.
#
# @ref swig_GetPoint "Example"
- def GetPoint(self,theShape, theX, theY, theZ, theEpsilon):
+ def GetPoint(self, theShape, theX, theY, theZ, theEpsilon):
# Example: see GEOM_TestOthers.py
anObj = self.BlocksOp.GetPoint(theShape, theX, theY, theZ, theEpsilon)
RaiseIfFailed("GetPoint", self.BlocksOp)
return anObj
+ ## Find a vertex of the given shape, which has minimal distance to the given point.
+ # @param theShape Any shape.
+ # @param thePoint Point, close to the desired vertex.
+ # @return New GEOM_Object, containing the found vertex.
+ #
+ # @ref swig_GetVertexNearPoint "Example"
+ def GetVertexNearPoint(self, theShape, thePoint):
+ # Example: see GEOM_TestOthers.py
+ anObj = self.BlocksOp.GetVertexNearPoint(theShape, thePoint)
+ RaiseIfFailed("GetVertexNearPoint", self.BlocksOp)
+ return anObj
+
## Get an edge, found in the given shape by two given vertices.
# @param theShape Block or a compound of blocks.
# @param thePoint1,thePoint2 Points, close to the ends of the desired edge.
# @return New GEOM_Object, containing the found edge.
#
- # @ref swig_todo "Example"
- def GetEdge(self,theShape, thePoint1, thePoint2):
+ # @ref swig_GetEdge "Example"
+ def GetEdge(self, theShape, thePoint1, thePoint2):
# Example: see GEOM_Spanner.py
anObj = self.BlocksOp.GetEdge(theShape, thePoint1, thePoint2)
RaiseIfFailed("GetEdge", self.BlocksOp)
# @return New GEOM_Object, containing the found edge.
#
# @ref swig_GetEdgeNearPoint "Example"
- def GetEdgeNearPoint(self,theShape, thePoint):
+ def GetEdgeNearPoint(self, theShape, thePoint):
# Example: see GEOM_TestOthers.py
anObj = self.BlocksOp.GetEdgeNearPoint(theShape, thePoint)
RaiseIfFailed("GetEdgeNearPoint", self.BlocksOp)
# @return New GEOM_Object, containing the found face.
#
# @ref swig_GetFaceNearPoint "Example"
- def GetFaceNearPoint(self,theShape, thePoint):
+ def GetFaceNearPoint(self, theShape, thePoint):
# Example: see GEOM_Spanner.py
anObj = self.BlocksOp.GetFaceNearPoint(theShape, thePoint)
RaiseIfFailed("GetFaceNearPoint", self.BlocksOp)
RaiseIfFailed("GetFaceByNormale", self.BlocksOp)
return anObj
+ ## Find all subshapes of type \a theShapeType of the given shape,
+ # which have minimal distance to the given point.
+ # @param theShape Any shape.
+ # @param thePoint Point, close to the desired shape.
+ # @param theShapeType Defines what kind of subshapes is searched.
+ # @param theTolerance The tolerance for distances comparison. All shapes
+ # with distances to the given point in interval
+ # [minimal_distance, minimal_distance + theTolerance] will be gathered.
+ # @return New GEOM_Object, containing a group of all found shapes.
+ #
+ # @ref swig_GetShapesNearPoint "Example"
+ def GetShapesNearPoint(self, theShape, thePoint, theShapeType, theTolerance = 1e-07):
+ # Example: see GEOM_TestOthers.py
+ anObj = self.BlocksOp.GetShapesNearPoint(theShape, thePoint, theShapeType, theTolerance)
+ RaiseIfFailed("GetShapesNearPoint", self.BlocksOp)
+ return anObj
+
# end of l3_blocks_op
## @}
RepairGUI_FreeFacesDlg.h \
RepairGUI_ChangeOrientationDlg.h \
RepairGUI_GlueDlg.h \
+ RepairGUI_LimitToleranceDlg.h \
RepairGUI_RemoveExtraEdgesDlg.h
# Libraries targets
RepairGUI_FreeFacesDlg.h \
RepairGUI_ChangeOrientationDlg.h \
RepairGUI_GlueDlg.h \
+ RepairGUI_LimitToleranceDlg.h \
RepairGUI_RemoveExtraEdgesDlg.h \
\
RepairGUI.cxx \
RepairGUI_FreeFacesDlg.cxx \
RepairGUI_ChangeOrientationDlg.cxx \
RepairGUI_GlueDlg.cxx \
+ RepairGUI_LimitToleranceDlg.cxx \
RepairGUI_RemoveExtraEdgesDlg.cxx
MOC_FILES = \
RepairGUI_FreeFacesDlg_moc.cxx \
RepairGUI_ChangeOrientationDlg_moc.cxx \
RepairGUI_GlueDlg_moc.cxx \
+ RepairGUI_LimitToleranceDlg_moc.cxx \
RepairGUI_RemoveExtraEdgesDlg_moc.cxx
nodist_libRepairGUI_la_SOURCES = \
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+// GEOM GEOMGUI : GUI for Geometry component
+// File : RepairGUI.cxx
+// Author : Damien COQUERET, Open CASCADE S.A.S.
-// GEOM GEOMGUI : GUI for Geometry component
-// File : RepairGUI.cxx
-// Author : Damien COQUERET, Open CASCADE S.A.S.
-//
#include "RepairGUI.h"
#include <GeometryGUI.h>
#include "RepairGUI_FreeBoundDlg.h" // Method FREE BOUNDARIES
#include "RepairGUI_FreeFacesDlg.h" // Method FREE FACES
#include "RepairGUI_GlueDlg.h" // Method GLUE FACES
+#include "RepairGUI_LimitToleranceDlg.h" // Method LIMIT TOLERANCE
#include "RepairGUI_ChangeOrientationDlg.h" // Method CHANGE ORIENTATION
-#include "RepairGUI_RemoveExtraEdgesDlg.h" // Method REMOVE EXTRA EDGES
+#include "RepairGUI_RemoveExtraEdgesDlg.h" // Method REMOVE EXTRA EDGES
//=======================================================================
// function : RepairGUI()
//=======================================================================
// function : OnGUIEvent()
-// purpose :
+// purpose :
//=======================================================================
bool RepairGUI::OnGUIEvent( int theCommandID, SUIT_Desktop* parent )
{
QDialog* aDlg = NULL;
switch ( theCommandID ) {
- case GEOMOp::OpSewing: aDlg = new RepairGUI_SewingDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpGlueFaces: aDlg = new RepairGUI_GlueDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpSuppressFaces: aDlg = new RepairGUI_SuppressFacesDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpSuppressHoles: aDlg = new RepairGUI_RemoveHolesDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpShapeProcess: aDlg = new RepairGUI_ShapeProcessDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpCloseContour: aDlg = new RepairGUI_CloseContourDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpRemoveIntWires: aDlg = new RepairGUI_RemoveIntWiresDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpAddPointOnEdge: aDlg = new RepairGUI_DivideEdgeDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpFreeBoundaries: aDlg = new RepairGUI_FreeBoundDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpFreeFaces: aDlg = new RepairGUI_FreeFacesDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpOrientation: aDlg = new RepairGUI_ChangeOrientationDlg ( getGeometryGUI(), parent ); break;
- case GEOMOp::OpRemoveExtraEdges: aDlg = new RepairGUI_RemoveExtraEdgesDlg ( getGeometryGUI(), parent ); break;
+ case GEOMOp::OpSewing: aDlg = new RepairGUI_SewingDlg (getGeometryGUI(), parent); break;
+ case GEOMOp::OpGlueFaces: aDlg = new RepairGUI_GlueDlg (getGeometryGUI(), parent); 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;
+ case GEOMOp::OpShapeProcess: aDlg = new RepairGUI_ShapeProcessDlg (getGeometryGUI(), parent); break;
+ case GEOMOp::OpCloseContour: aDlg = new RepairGUI_CloseContourDlg (getGeometryGUI(), parent); break;
+ case GEOMOp::OpRemoveIntWires: aDlg = new RepairGUI_RemoveIntWiresDlg (getGeometryGUI(), parent); break;
+ case GEOMOp::OpAddPointOnEdge: aDlg = new RepairGUI_DivideEdgeDlg (getGeometryGUI(), parent); break;
+ case GEOMOp::OpFreeBoundaries: aDlg = new RepairGUI_FreeBoundDlg (getGeometryGUI(), parent); break;
+ case GEOMOp::OpFreeFaces: aDlg = new RepairGUI_FreeFacesDlg (getGeometryGUI(), parent); break;
+ 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 ) );
break;
--- /dev/null
+// 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
+//
+// GEOM RepairGUI : GUI for Geometry component
+// File : RepairGUI_LimitToleranceDlg.cxx
+
+#include "RepairGUI_LimitToleranceDlg.h"
+
+#include <DlgRef.h>
+#include <GeometryGUI.h>
+#include <GEOMBase.h>
+#include <SalomeApp_DoubleSpinBox.h>
+
+#include <SalomeApp_Application.h>
+#include <LightApp_SelectionMgr.h>
+#include <SalomeApp_Study.h>
+#include <SalomeApp_Tools.h>
+#include <SUIT_Session.h>
+#include <SUIT_Desktop.h>
+#include <SUIT_MessageBox.h>
+#include <SUIT_OverrideCursor.h>
+#include <SUIT_ResourceMgr.h>
+#include <SUIT_ViewWindow.h>
+#include <SUIT_ViewManager.h>
+#include <OCCViewer_ViewModel.h>
+#include <SALOME_ListIteratorOfListIO.hxx>
+
+#include <GEOMImpl_Types.hxx>
+
+#include <TCollection_AsciiString.hxx>
+
+#define DEFAULT_TOLERANCE_VALUE 1e-07
+
+//=================================================================================
+// class : RepairGUI_LimitToleranceDlg()
+// purpose : Constructs a RepairGUI_LimitToleranceDlg which is a child of 'parent', with the
+// name 'name' and widget flags set to 'f'.
+// The dialog will by default be modeless, unless you set 'modal' to
+// TRUE to construct a modal dialog.
+//=================================================================================
+RepairGUI_LimitToleranceDlg::RepairGUI_LimitToleranceDlg(GeometryGUI* theGeometryGUI,
+ QWidget* parent, bool modal)
+ : GEOMBase_Skeleton(theGeometryGUI, parent, modal)
+{
+ QPixmap image0 (SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_DLG_LIMIT_TOLERANCE")));
+ QPixmap image1 (SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_SELECT")));
+
+ setWindowTitle(tr("GEOM_LIMIT_TOLERANCE_TITLE"));
+
+ /***************************************************************/
+ mainFrame()->GroupConstructors->setTitle(tr("GEOM_LIMIT_TOLERANCE_TITLE"));
+ mainFrame()->RadioButton1->setIcon(image0);
+ mainFrame()->RadioButton2->setAttribute(Qt::WA_DeleteOnClose);
+ mainFrame()->RadioButton3->setAttribute(Qt::WA_DeleteOnClose);
+ mainFrame()->RadioButton2->close();
+ mainFrame()->RadioButton3->close();
+
+ GroupPoints = new DlgRef_1SelExt(centralWidget());
+ GroupPoints->GroupBox1->setTitle(tr("GEOM_ARGUMENTS"));
+ GroupPoints->TextLabel1->setText(tr("GEOM_SELECTED_SHAPE"));
+ GroupPoints->PushButton1->setIcon(image1);
+ 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);
+ boxLayout->setMargin(0); boxLayout->setSpacing(6);
+ boxLayout->addWidget(aTolLab, 0, 0);
+ boxLayout->addWidget(myTolEdt, 0, 2);
+
+ QVBoxLayout* layout = new QVBoxLayout(centralWidget());
+ layout->setMargin(0); layout->setSpacing(6);
+ layout->addWidget(GroupPoints);
+
+ setHelpFileName("limit_tolerance_operation_page.html");
+
+ Init();
+}
+
+
+//=================================================================================
+// function : ~RepairGUI_LimitToleranceDlg()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+RepairGUI_LimitToleranceDlg::~RepairGUI_LimitToleranceDlg()
+{
+}
+
+
+//=================================================================================
+// function : Init()
+// purpose :
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::Init()
+{
+ /* init variables */
+ myEditCurrentArgument = GroupPoints->LineEdit1;
+
+ myObject = GEOM::GEOM_Object::_nil();
+
+ //myGeomGUI->SetState(0);
+ //globalSelection(GEOM_COMPOUND);
+
+ mainFrame()->GroupBoxPublish->show();
+
+ /* signals and slots connections */
+ connect(buttonOk(), SIGNAL(clicked()), this, SLOT(ClickOnOk()));
+ connect(buttonApply(), SIGNAL(clicked()), this, SLOT(ClickOnApply()));
+
+ connect(GroupPoints->PushButton1, SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
+ connect(GroupPoints->LineEdit1, SIGNAL(returnPressed()), this, SLOT(LineEditReturnPressed()));
+
+ connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
+ this, SLOT(SelectionIntoArgument()));
+
+ initName(tr("LIMIT_TOLERANCE_NEW_OBJ_NAME"));
+
+ ConstructorsClicked(0);
+
+ activateSelection();
+ updateButtonState();
+}
+
+
+//=================================================================================
+// function : ConstructorsClicked()
+// purpose : Radio button management
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::ConstructorsClicked(int constructorId)
+{
+ disconnect(myGeomGUI->getApp()->selectionMgr(), 0, this, 0);
+
+ GroupPoints->show();
+ GroupPoints->LineEdit1->setText("");
+ myEditCurrentArgument = GroupPoints->LineEdit1;
+ myEditCurrentArgument->setFocus();
+
+ connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
+ this, SLOT(SelectionIntoArgument()));
+
+ qApp->processEvents();
+ updateGeometry();
+ resize(minimumSizeHint());
+
+ updateButtonState();
+ activateSelection();
+ SelectionIntoArgument();
+}
+
+
+//=================================================================================
+// function : ClickOnOk()
+// purpose : Same than click on apply but close this dialog.
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::ClickOnOk()
+{
+ if (ClickOnApply())
+ ClickOnCancel();
+}
+
+//=================================================================================
+// function : ClickOnApply()
+// purpose :
+//=================================================================================
+bool RepairGUI_LimitToleranceDlg::ClickOnApply()
+{
+ if (!onAcceptLocal())
+ return false;
+
+ initName();
+
+ ConstructorsClicked(0);
+
+ return true;
+}
+
+//=================================================================================
+// function : SelectionIntoArgument()
+// purpose : Called when selection
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::SelectionIntoArgument()
+{
+ myEditCurrentArgument->setText("");
+ myObject = GEOM::GEOM_Object::_nil();
+
+ LightApp_SelectionMgr* aSelMgr = myGeomGUI->getApp()->selectionMgr();
+ SALOME_ListIO aSelList;
+ aSelMgr->selectedObjects(aSelList);
+
+ if (aSelList.Extent() == 1) {
+ Handle(SALOME_InteractiveObject) anIO = aSelList.First();
+ Standard_Boolean aRes;
+ myObject = GEOMBase::ConvertIOinGEOMObject(anIO, aRes);
+ if (aRes)
+ myEditCurrentArgument->setText(GEOMBase::GetName(myObject));
+ }
+ updateButtonState();
+}
+
+//=================================================================================
+// function : SetEditCurrentArgument()
+// purpose :
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::SetEditCurrentArgument()
+{
+ const QObject* send = sender();
+ if (send == GroupPoints->PushButton1) {
+ myEditCurrentArgument->setFocus();
+ SelectionIntoArgument();
+ }
+}
+
+//=================================================================================
+// function : LineEditReturnPressed()
+// purpose :
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::LineEditReturnPressed()
+{
+ const QObject* send = sender();
+ if (send == GroupPoints->LineEdit1) {
+ myEditCurrentArgument = GroupPoints->LineEdit1;
+ GEOMBase_Skeleton::LineEditReturnPressed();
+ }
+}
+
+//=================================================================================
+// function : ActivateThisDialog()
+// purpose :
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::ActivateThisDialog()
+{
+ GEOMBase_Skeleton::ActivateThisDialog();
+ connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
+ this, SLOT(SelectionIntoArgument()));
+ activateSelection();
+}
+
+//=================================================================================
+// function : enterEvent()
+// purpose : Mouse enter onto the dialog to activate it
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::enterEvent(QEvent*)
+{
+ if (!mainFrame()->GroupConstructors->isEnabled())
+ ActivateThisDialog();
+}
+
+//=================================================================================
+// function : createOperation
+// purpose :
+//=================================================================================
+GEOM::GEOM_IOperations_ptr RepairGUI_LimitToleranceDlg::createOperation()
+{
+ return getGeomEngine()->GetIHealingOperations(getStudyId());
+}
+
+//=================================================================================
+// function : isValid
+// purpose :
+//=================================================================================
+bool RepairGUI_LimitToleranceDlg::isValid(QString& msg)
+{
+ double v = myTolEdt->value();
+ bool ok = myTolEdt->isValid(msg, true);
+ return !myObject->_is_nil() && (v > 0.) && ok;
+}
+
+//=================================================================================
+// function : execute
+// purpose :
+//=================================================================================
+bool RepairGUI_LimitToleranceDlg::execute(ObjectList& objects)
+{
+ bool aResult = false;
+ objects.clear();
+
+ GEOM::GEOM_IHealingOperations_var anOper = GEOM::GEOM_IHealingOperations::_narrow(getOperation());
+ GEOM::GEOM_Object_var anObj = anOper->LimitTolerance(myObject, myTolEdt->value());
+ aResult = !anObj->_is_nil();
+ if (aResult) {
+ QStringList aParameters;
+ aParameters << myTolEdt->text();
+ anObj->SetParameters(aParameters.join(":").toLatin1().constData());
+ objects.push_back(anObj._retn());
+ }
+
+ return aResult;
+}
+
+//================================================================
+// Function : onAccept
+// Purpose : This method should be called from dialog's slots onOk() and onApply()
+// It perfroms user input validation, then it
+// performs a proper operation and manages transactions, etc.
+//================================================================
+bool RepairGUI_LimitToleranceDlg::onAcceptLocal()
+{
+ if (!getStudy() || !(getStudy()->studyDS()))
+ return false;
+
+ _PTR(Study) aStudy = getStudy()->studyDS();
+
+ bool aLocked = aStudy->GetProperties()->IsLocked();
+ if (aLocked) {
+ MESSAGE("GEOMBase_Helper::onAccept - ActiveStudy is locked");
+ SUIT_MessageBox::warning(this, tr("WRN_WARNING"), tr("WRN_STUDY_LOCKED"), tr("BUT_OK"));
+ return false;
+ }
+
+ QString msg;
+ if (!isValid(msg)) {
+ showError(msg);
+ return false;
+ }
+
+ try {
+ if (openCommand()) {
+ SUIT_OverrideCursor wc;
+
+ myGeomGUI->getApp()->putInfo("");
+ ObjectList objects;
+
+ if (!execute(objects)) {
+ wc.suspend();
+ abortCommand();
+ showError();
+ }
+ else {
+ const int nbObjs = objects.size();
+ for (ObjectList::iterator it = objects.begin(); it != objects.end(); ++it) {
+ QString aName = getNewObjectName();
+ if (nbObjs > 1) {
+ if (aName.isEmpty())
+ aName = getPrefix(*it);
+ aName = GEOMBase::GetDefaultName(aName);
+ }
+ else {
+ // PAL6521: use a prefix, if some dialog box doesn't reimplement getNewObjectName()
+ if (aName.isEmpty())
+ aName = GEOMBase::GetDefaultName(getPrefix(*it));
+ }
+ addInStudy(*it, aName.toLatin1().data());
+ display(*it, false);
+ }
+
+ if (nbObjs) {
+ commitCommand();
+ updateObjBrowser();
+ myGeomGUI->getApp()->putInfo(QObject::tr("GEOM_PRP_DONE"));
+ }
+ else {
+ abortCommand();
+ }
+
+ // JFA 28.12.2004 BEGIN // To enable warnings
+ GEOM::GEOM_IHealingOperations_var anOper = GEOM::GEOM_IHealingOperations::_narrow(getOperation());
+ if (!CORBA::is_nil(anOper) && !anOper->IsDone()) {
+ wc.suspend();
+ QString msgw = QObject::tr(anOper->GetErrorCode());
+ SUIT_MessageBox::warning(this, tr("WRN_WARNING"), msgw, tr("BUT_OK"));
+ }
+ // JFA 28.12.2004 END
+ }
+ }
+ }
+ catch(const SALOME::SALOME_Exception& e) {
+ SalomeApp_Tools::QtCatchCorbaException(e);
+ abortCommand();
+ }
+
+ updateViewer();
+ activateSelection();
+ updateButtonState();
+
+ return true;
+}
+
+//=================================================================================
+// function : activateSelection
+// purpose : Activate selection
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::activateSelection()
+{
+ disconnect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
+ this, SLOT(SelectionIntoArgument()));
+
+ globalSelection(GEOM_ALLSHAPES);
+ if (myObject->_is_nil())
+ SelectionIntoArgument();
+
+ connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()),
+ this, SLOT(SelectionIntoArgument()));
+ updateViewer();
+}
+
+//=================================================================================
+// function : updateButtonState
+// purpose : Update button state
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::updateButtonState()
+{
+ bool hasMainObj = !myObject->_is_nil();
+ buttonOk()->setEnabled(hasMainObj);
+ buttonApply()->setEnabled(hasMainObj);
+}
+
+//=================================================================================
+// function : restoreSubShapes
+// purpose :
+//=================================================================================
+void RepairGUI_LimitToleranceDlg::restoreSubShapes(SALOMEDS::Study_ptr theStudy,
+ SALOMEDS::SObject_ptr theSObject)
+{
+ if (mainFrame()->CheckBoxRestoreSS->isChecked()) {
+ // empty list of arguments means that all arguments should be restored
+ getGeomEngine()->RestoreSubShapesSO(theStudy, theSObject, GEOM::ListOfGO(),
+ GEOM::FSM_GetInPlace, /*theInheritFirstArg=*/true,
+ mainFrame()->CheckBoxAddPrefix->isChecked());
+ }
+}
--- /dev/null
+// 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
+//
+// GEOM GEOMGUI : GUI for Geometry component
+// File : RepairGUI_LimitToleranceDlg.h
+
+#ifndef REPAIRGUI_LIMITTOLERANCEDLG_H
+#define REPAIRGUI_LIMITTOLERANCEDLG_H
+
+#include <GEOMBase_Skeleton.h>
+
+class DlgRef_1SelExt;
+class SalomeApp_DoubleSpinBox;
+class QPushButton;
+class QCheckBox;
+
+//=================================================================================
+// class : RepairGUI_LimitToleranceDlg
+// purpose :
+//=================================================================================
+class RepairGUI_LimitToleranceDlg : public GEOMBase_Skeleton
+{
+ Q_OBJECT
+
+public:
+ RepairGUI_LimitToleranceDlg (GeometryGUI*, QWidget* = 0, bool = false);
+ ~RepairGUI_LimitToleranceDlg();
+
+protected:
+ // redefined from GEOMBase_Helper
+ virtual GEOM::GEOM_IOperations_ptr createOperation();
+ virtual bool isValid (QString&);
+ virtual bool execute (ObjectList&);
+ virtual void restoreSubShapes (SALOMEDS::Study_ptr, SALOMEDS::SObject_ptr);
+
+private:
+ void Init();
+ void enterEvent (QEvent*);
+ void initSelection();
+
+ bool onAcceptLocal();
+
+ void activateSelection();
+ void updateButtonState();
+
+private:
+ GEOM::GEOM_Object_var myObject;
+
+ DlgRef_1SelExt* GroupPoints;
+ SalomeApp_DoubleSpinBox* myTolEdt;
+
+private slots:
+ void ClickOnOk();
+ bool ClickOnApply();
+
+ void ActivateThisDialog();
+
+ void LineEditReturnPressed();
+ void SelectionIntoArgument();
+ void SetEditCurrentArgument();
+
+ void ConstructorsClicked( int );
+};
+
+#endif // REPAIRGUI_LIMITTOLERANCEDLG_H
