SMESH_MeshEditor_i Class Reference

#include <SMESH_MeshEditor_i.hxx>

Inheritance diagram for SMESH_MeshEditor_i:

Public Member Functions
	SMESH_MeshEditor_i (SMESH_Mesh_i *theMesh, bool isPreview)
virtual	~SMESH_MeshEditor_i ()
	Destructor.
SMESH::SMESH_IDSource_ptr	MakeIDSource (const SMESH::long_array &IDsOfElements, SMESH::ElementType type)
	Wrap a sequence of ids in a SMESH_IDSource.
CORBA::Boolean	RemoveElements (const SMESH::long_array &IDsOfElements)
CORBA::Boolean	RemoveNodes (const SMESH::long_array &IDsOfNodes)
CORBA::Long	RemoveOrphanNodes ()
CORBA::Long	AddNode (CORBA::Double x, CORBA::Double y, CORBA::Double z)
	Methods for creation new elements.
CORBA::Long	Add0DElement (CORBA::Long IDOfNode)
CORBA::Long	AddEdge (const SMESH::long_array &IDsOfNodes)
CORBA::Long	AddFace (const SMESH::long_array &IDsOfNodes)
	AddFace.
CORBA::Long	AddPolygonalFace (const SMESH::long_array &IDsOfNodes)
	AddPolygonalFace.
CORBA::Long	AddVolume (const SMESH::long_array &IDsOfNodes)
CORBA::Long	AddPolyhedralVolume (const SMESH::long_array &IDsOfNodes, const SMESH::long_array &Quantities)
	AddPolyhedralVolume.
CORBA::Long	AddPolyhedralVolumeByFaces (const SMESH::long_array &IdsOfFaces)
	AddPolyhedralVolumeByFaces.
void	SetNodeOnVertex (CORBA::Long NodeID, CORBA::Long VertexID) throw (SALOME::SALOME_Exception)
	Bind a node to a vertex.
void	SetNodeOnEdge (CORBA::Long NodeID, CORBA::Long EdgeID, CORBA::Double paramOnEdge) throw (SALOME::SALOME_Exception)
	Store node position on an edge.
void	SetNodeOnFace (CORBA::Long NodeID, CORBA::Long FaceID, CORBA::Double u, CORBA::Double v) throw (SALOME::SALOME_Exception)
	Store node position on a face.
void	SetNodeInVolume (CORBA::Long NodeID, CORBA::Long SolidID) throw (SALOME::SALOME_Exception)
	Bind a node to a solid.
void	SetMeshElementOnShape (CORBA::Long ElementID, CORBA::Long ShapeID) throw (SALOME::SALOME_Exception)
	Bind an element to a shape.
CORBA::Boolean	MoveNode (CORBA::Long NodeID, CORBA::Double x, CORBA::Double y, CORBA::Double z)
	Move the node to a given point.
CORBA::Boolean	InverseDiag (CORBA::Long NodeID1, CORBA::Long NodeID2)
CORBA::Boolean	DeleteDiag (CORBA::Long NodeID1, CORBA::Long NodeID2)
CORBA::Boolean	Reorient (const SMESH::long_array &IDsOfElements)
CORBA::Boolean	ReorientObject (SMESH::SMESH_IDSource_ptr theObject)
CORBA::Boolean	TriToQuad (const SMESH::long_array &IDsOfElements, SMESH::NumericalFunctor_ptr Criterion, CORBA::Double MaxAngle)
CORBA::Boolean	TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject, SMESH::NumericalFunctor_ptr Criterion, CORBA::Double MaxAngle)
CORBA::Boolean	QuadToTri (const SMESH::long_array &IDsOfElements, SMESH::NumericalFunctor_ptr Criterion)
CORBA::Boolean	QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject, SMESH::NumericalFunctor_ptr Criterion)
CORBA::Boolean	SplitQuad (const SMESH::long_array &IDsOfElements, CORBA::Boolean Diag13)
CORBA::Boolean	SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean Diag13)
CORBA::Long	BestSplit (CORBA::Long IDOfQuad, SMESH::NumericalFunctor_ptr Criterion)
	BestSplit.
void	SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems, CORBA::Short methodFlags) throw (SALOME::SALOME_Exception)
	Split volumic elements into tetrahedrons.
CORBA::Boolean	Smooth (const SMESH::long_array &IDsOfElements, const SMESH::long_array &IDsOfFixedNodes, CORBA::Long MaxNbOfIterations, CORBA::Double MaxAspectRatio, SMESH::SMESH_MeshEditor::Smooth_Method Method)
CORBA::Boolean	SmoothObject (SMESH::SMESH_IDSource_ptr theObject, const SMESH::long_array &IDsOfFixedNodes, CORBA::Long MaxNbOfIterations, CORBA::Double MaxAspectRatio, SMESH::SMESH_MeshEditor::Smooth_Method Method)
CORBA::Boolean	SmoothParametric (const SMESH::long_array &IDsOfElements, const SMESH::long_array &IDsOfFixedNodes, CORBA::Long MaxNbOfIterations, CORBA::Double MaxAspectRatio, SMESH::SMESH_MeshEditor::Smooth_Method Method)
CORBA::Boolean	SmoothParametricObject (SMESH::SMESH_IDSource_ptr theObject, const SMESH::long_array &IDsOfFixedNodes, CORBA::Long MaxNbOfIterations, CORBA::Double MaxAspectRatio, SMESH::SMESH_MeshEditor::Smooth_Method Method)
CORBA::Boolean	smooth (const SMESH::long_array &IDsOfElements, const SMESH::long_array &IDsOfFixedNodes, CORBA::Long MaxNbOfIterations, CORBA::Double MaxAspectRatio, SMESH::SMESH_MeshEditor::Smooth_Method Method, bool IsParametric)
CORBA::Boolean	smoothObject (SMESH::SMESH_IDSource_ptr theObject, const SMESH::long_array &IDsOfFixedNodes, CORBA::Long MaxNbOfIterations, CORBA::Double MaxAspectRatio, SMESH::SMESH_MeshEditor::Smooth_Method Method, bool IsParametric)
void	ConvertToQuadratic (CORBA::Boolean Force3d)
CORBA::Boolean	ConvertFromQuadratic ()
void	ConvertToQuadraticObject (CORBA::Boolean theForce3d, SMESH::SMESH_IDSource_ptr theObject) throw (SALOME::SALOME_Exception)
	Makes a part of the mesh quadratic.
void	ConvertFromQuadraticObject (SMESH::SMESH_IDSource_ptr theObject) throw (SALOME::SALOME_Exception)
	Makes a part of the mesh linear.
void	RenumberNodes ()
void	RenumberElements ()
void	RotationSweep (const SMESH::long_array &IDsOfElements, const SMESH::AxisStruct &Axis, CORBA::Double AngleInRadians, CORBA::Long NbOfSteps, CORBA::Double Tolerance)
void	RotationSweepObject (SMESH::SMESH_IDSource_ptr theObject, const SMESH::AxisStruct &Axis, CORBA::Double AngleInRadians, CORBA::Long NbOfSteps, CORBA::Double Tolerance)
void	RotationSweepObject1D (SMESH::SMESH_IDSource_ptr theObject, const SMESH::AxisStruct &Axis, CORBA::Double AngleInRadians, CORBA::Long NbOfSteps, CORBA::Double Tolerance)
void	RotationSweepObject2D (SMESH::SMESH_IDSource_ptr theObject, const SMESH::AxisStruct &Axis, CORBA::Double AngleInRadians, CORBA::Long NbOfSteps, CORBA::Double Tolerance)
void	ExtrusionSweep (const SMESH::long_array &IDsOfElements, const SMESH::DirStruct &StepVector, CORBA::Long NbOfSteps)
void	ExtrusionSweepObject (SMESH::SMESH_IDSource_ptr theObject, const SMESH::DirStruct &StepVector, CORBA::Long NbOfSteps)
void	ExtrusionSweepObject1D (SMESH::SMESH_IDSource_ptr theObject, const SMESH::DirStruct &StepVector, CORBA::Long NbOfSteps)
void	ExtrusionSweepObject2D (SMESH::SMESH_IDSource_ptr theObject, const SMESH::DirStruct &StepVector, CORBA::Long NbOfSteps)
void	AdvancedExtrusion (const SMESH::long_array &theIDsOfElements, const SMESH::DirStruct &theStepVector, CORBA::Long theNbOfSteps, CORBA::Long theExtrFlags, CORBA::Double theSewTolerance)
SMESH::SMESH_MeshEditor::Extrusion_Error	ExtrusionAlongPath (const SMESH::long_array &IDsOfElements, SMESH::SMESH_Mesh_ptr PathMesh, GEOM::GEOM_Object_ptr PathShape, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint)
SMESH::SMESH_MeshEditor::Extrusion_Error	ExtrusionAlongPathObject (SMESH::SMESH_IDSource_ptr theObject, SMESH::SMESH_Mesh_ptr PathMesh, GEOM::GEOM_Object_ptr PathShape, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint)
SMESH::SMESH_MeshEditor::Extrusion_Error	ExtrusionAlongPathObject1D (SMESH::SMESH_IDSource_ptr theObject, SMESH::SMESH_Mesh_ptr PathMesh, GEOM::GEOM_Object_ptr PathShape, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint)
SMESH::SMESH_MeshEditor::Extrusion_Error	ExtrusionAlongPathObject2D (SMESH::SMESH_IDSource_ptr theObject, SMESH::SMESH_Mesh_ptr PathMesh, GEOM::GEOM_Object_ptr PathShape, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint)
SMESH::double_array *	LinearAnglesVariation (SMESH::SMESH_Mesh_ptr PathMesh, GEOM::GEOM_Object_ptr PathShape, const SMESH::double_array &Angles)
	Compute rotation angles for ExtrusionAlongPath as linear variation of given angles along path steps.
void	Mirror (const SMESH::long_array &IDsOfElements, const SMESH::AxisStruct &Axis, SMESH::SMESH_MeshEditor::MirrorType MirrorType, CORBA::Boolean Copy)
void	MirrorObject (SMESH::SMESH_IDSource_ptr theObject, const SMESH::AxisStruct &Axis, SMESH::SMESH_MeshEditor::MirrorType MirrorType, CORBA::Boolean Copy)
void	Translate (const SMESH::long_array &IDsOfElements, const SMESH::DirStruct &Vector, CORBA::Boolean Copy)
void	TranslateObject (SMESH::SMESH_IDSource_ptr theObject, const SMESH::DirStruct &Vector, CORBA::Boolean Copy)
void	Rotate (const SMESH::long_array &IDsOfElements, const SMESH::AxisStruct &Axis, CORBA::Double Angle, CORBA::Boolean Copy)
void	RotateObject (SMESH::SMESH_IDSource_ptr theObject, const SMESH::AxisStruct &Axis, CORBA::Double Angle, CORBA::Boolean Copy)
SMESH::ListOfGroups *	RotationSweepMakeGroups (const SMESH::long_array &IDsOfElements, const SMESH::AxisStruct &Axix, CORBA::Double AngleInRadians, CORBA::Long NbOfSteps, CORBA::Double Tolerance)
SMESH::ListOfGroups *	RotationSweepObjectMakeGroups (SMESH::SMESH_IDSource_ptr Object, const SMESH::AxisStruct &Axix, CORBA::Double AngleInRadians, CORBA::Long NbOfSteps, CORBA::Double Tolerance)
SMESH::ListOfGroups *	RotationSweepObject1DMakeGroups (SMESH::SMESH_IDSource_ptr Object, const SMESH::AxisStruct &Axix, CORBA::Double AngleInRadians, CORBA::Long NbOfSteps, CORBA::Double Tolerance)
SMESH::ListOfGroups *	RotationSweepObject2DMakeGroups (SMESH::SMESH_IDSource_ptr Object, const SMESH::AxisStruct &Axix, CORBA::Double AngleInRadians, CORBA::Long NbOfSteps, CORBA::Double Tolerance)
SMESH::ListOfGroups *	ExtrusionSweepMakeGroups (const SMESH::long_array &IDsOfElements, const SMESH::DirStruct &StepVector, CORBA::Long NbOfSteps)
SMESH::ListOfGroups *	AdvancedExtrusionMakeGroups (const SMESH::long_array &IDsOfElements, const SMESH::DirStruct &StepVector, CORBA::Long NbOfSteps, CORBA::Long ExtrFlags, CORBA::Double SewTolerance)
SMESH::ListOfGroups *	ExtrusionSweepObjectMakeGroups (SMESH::SMESH_IDSource_ptr Object, const SMESH::DirStruct &StepVector, CORBA::Long NbOfSteps)
SMESH::ListOfGroups *	ExtrusionSweepObject1DMakeGroups (SMESH::SMESH_IDSource_ptr Object, const SMESH::DirStruct &StepVector, CORBA::Long NbOfSteps)
SMESH::ListOfGroups *	ExtrusionSweepObject2DMakeGroups (SMESH::SMESH_IDSource_ptr Object, const SMESH::DirStruct &StepVector, CORBA::Long NbOfSteps)
SMESH::ListOfGroups *	ExtrusionAlongPathMakeGroups (const SMESH::long_array &IDsOfElements, SMESH::SMESH_Mesh_ptr PathMesh, GEOM::GEOM_Object_ptr PathShape, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint, SMESH::SMESH_MeshEditor::Extrusion_Error &Error)
SMESH::ListOfGroups *	ExtrusionAlongPathObjectMakeGroups (SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr PathMesh, GEOM::GEOM_Object_ptr PathShape, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint, SMESH::SMESH_MeshEditor::Extrusion_Error &Error)
SMESH::ListOfGroups *	ExtrusionAlongPathObject1DMakeGroups (SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr PathMesh, GEOM::GEOM_Object_ptr PathShape, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint, SMESH::SMESH_MeshEditor::Extrusion_Error &Error)
SMESH::ListOfGroups *	ExtrusionAlongPathObject2DMakeGroups (SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr PathMesh, GEOM::GEOM_Object_ptr PathShape, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint, SMESH::SMESH_MeshEditor::Extrusion_Error &Error)
SMESH::ListOfGroups *	ExtrusionAlongPathObjX (SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_IDSource_ptr Path, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean LinearVariation, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint, CORBA::Boolean MakeGroups, SMESH::ElementType ElemType, SMESH::SMESH_MeshEditor::Extrusion_Error &Error)
SMESH::ListOfGroups *	ExtrusionAlongPathX (const SMESH::long_array &IDsOfElements, SMESH::SMESH_IDSource_ptr Path, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean LinearVariation, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint, CORBA::Boolean MakeGroups, SMESH::ElementType ElemType, SMESH::SMESH_MeshEditor::Extrusion_Error &Error)
SMESH::ListOfGroups *	MirrorMakeGroups (const SMESH::long_array &IDsOfElements, const SMESH::AxisStruct &Mirror, SMESH::SMESH_MeshEditor::MirrorType MirrorType)
SMESH::ListOfGroups *	MirrorObjectMakeGroups (SMESH::SMESH_IDSource_ptr Object, const SMESH::AxisStruct &Mirror, SMESH::SMESH_MeshEditor::MirrorType MirrorType)
SMESH::ListOfGroups *	TranslateMakeGroups (const SMESH::long_array &IDsOfElements, const SMESH::DirStruct &Vector)
SMESH::ListOfGroups *	TranslateObjectMakeGroups (SMESH::SMESH_IDSource_ptr Object, const SMESH::DirStruct &Vector)
SMESH::ListOfGroups *	RotateMakeGroups (const SMESH::long_array &IDsOfElements, const SMESH::AxisStruct &Axis, CORBA::Double AngleInRadians)
SMESH::ListOfGroups *	RotateObjectMakeGroups (SMESH::SMESH_IDSource_ptr Object, const SMESH::AxisStruct &Axis, CORBA::Double AngleInRadians)
SMESH::SMESH_Mesh_ptr	MirrorMakeMesh (const SMESH::long_array &IDsOfElements, const SMESH::AxisStruct &Mirror, SMESH::SMESH_MeshEditor::MirrorType MirrorType, CORBA::Boolean CopyGroups, const char *MeshName)
SMESH::SMESH_Mesh_ptr	MirrorObjectMakeMesh (SMESH::SMESH_IDSource_ptr Object, const SMESH::AxisStruct &Mirror, SMESH::SMESH_MeshEditor::MirrorType MirrorType, CORBA::Boolean CopyGroups, const char *MeshName)
SMESH::SMESH_Mesh_ptr	TranslateMakeMesh (const SMESH::long_array &IDsOfElements, const SMESH::DirStruct &Vector, CORBA::Boolean CopyGroups, const char *MeshName)
SMESH::SMESH_Mesh_ptr	TranslateObjectMakeMesh (SMESH::SMESH_IDSource_ptr Object, const SMESH::DirStruct &Vector, CORBA::Boolean CopyGroups, const char *MeshName)
SMESH::SMESH_Mesh_ptr	RotateMakeMesh (const SMESH::long_array &IDsOfElements, const SMESH::AxisStruct &Axis, CORBA::Double AngleInRadians, CORBA::Boolean CopyGroups, const char *MeshName)
SMESH::SMESH_Mesh_ptr	RotateObjectMakeMesh (SMESH::SMESH_IDSource_ptr Object, const SMESH::AxisStruct &Axis, CORBA::Double AngleInRadians, CORBA::Boolean CopyGroups, const char *MeshName)
void	Scale (SMESH::SMESH_IDSource_ptr theObject, const SMESH::PointStruct &thePoint, const SMESH::double_array &theScaleFact, CORBA::Boolean theCopy)
SMESH::ListOfGroups *	ScaleMakeGroups (SMESH::SMESH_IDSource_ptr theObject, const SMESH::PointStruct &thePoint, const SMESH::double_array &theScaleFact)
SMESH::SMESH_Mesh_ptr	ScaleMakeMesh (SMESH::SMESH_IDSource_ptr Object, const SMESH::PointStruct &Point, const SMESH::double_array &theScaleFact, CORBA::Boolean CopyGroups, const char *MeshName)
void	FindCoincidentNodes (CORBA::Double Tolerance, SMESH::array_of_long_array_out GroupsOfNodes)
void	FindCoincidentNodesOnPart (SMESH::SMESH_IDSource_ptr Object, CORBA::Double Tolerance, SMESH::array_of_long_array_out GroupsOfNodes)
void	FindCoincidentNodesOnPartBut (SMESH::SMESH_IDSource_ptr Object, CORBA::Double Tolerance, SMESH::array_of_long_array_out GroupsOfNodes, const SMESH::ListOfIDSources &ExceptSubMeshOrGroups)
	Finds nodes coinsident with Tolerance within Object excluding nodes within ExceptSubMeshOrGroups.
void	MergeNodes (const SMESH::array_of_long_array &GroupsOfNodes)
void	FindEqualElements (SMESH::SMESH_IDSource_ptr Object, SMESH::array_of_long_array_out GroupsOfElementsID)
void	MergeElements (const SMESH::array_of_long_array &GroupsOfElementsID)
void	MergeEqualElements ()
CORBA::Long	MoveClosestNodeToPoint (CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Long nodeID)
	If the given ID is a valid node ID (nodeID > 0), just move this node, else move the node closest to the point to point's location and return ID of the node.
CORBA::Long	FindNodeClosestTo (CORBA::Double x, CORBA::Double y, CORBA::Double z)
	Return ID of node closest to a given point.
SMESH::long_array *	FindElementsByPoint (CORBA::Double x, CORBA::Double y, CORBA::Double z, SMESH::ElementType type)
	Return elements of given type where the given point is IN or ON.
CORBA::Short	GetPointState (CORBA::Double x, CORBA::Double y, CORBA::Double z)
	Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
SMESH::SMESH_MeshEditor::Sew_Error	SewFreeBorders (CORBA::Long FirstNodeID1, CORBA::Long SecondNodeID1, CORBA::Long LastNodeID1, CORBA::Long FirstNodeID2, CORBA::Long SecondNodeID2, CORBA::Long LastNodeID2, CORBA::Boolean CreatePolygons, CORBA::Boolean CreatePolyedrs)
SMESH::SMESH_MeshEditor::Sew_Error	SewConformFreeBorders (CORBA::Long FirstNodeID1, CORBA::Long SecondNodeID1, CORBA::Long LastNodeID1, CORBA::Long FirstNodeID2, CORBA::Long SecondNodeID2)
SMESH::SMESH_MeshEditor::Sew_Error	SewBorderToSide (CORBA::Long FirstNodeIDOnFreeBorder, CORBA::Long SecondNodeIDOnFreeBorder, CORBA::Long LastNodeIDOnFreeBorder, CORBA::Long FirstNodeIDOnSide, CORBA::Long LastNodeIDOnSide, CORBA::Boolean CreatePolygons, CORBA::Boolean CreatePolyedrs)
SMESH::SMESH_MeshEditor::Sew_Error	SewSideElements (const SMESH::long_array &IDsOfSide1Elements, const SMESH::long_array &IDsOfSide2Elements, CORBA::Long NodeID1OfSide1ToMerge, CORBA::Long NodeID1OfSide2ToMerge, CORBA::Long NodeID2OfSide1ToMerge, CORBA::Long NodeID2OfSide2ToMerge)
CORBA::Boolean	ChangeElemNodes (CORBA::Long ide, const SMESH::long_array &newIDs)
	Set new nodes for given element.
SMESH::MeshPreviewStruct *	GetPreviewData ()
	Return data of mesh edition preview.
SMESH::long_array *	GetLastCreatedNodes ()
	If during last operation of MeshEditor some nodes were created this method returns list of it's IDs, if new nodes not creared - returns empty list.
SMESH::long_array *	GetLastCreatedElems ()
	If during last operation of MeshEditor some elements were created this method returns list of it's IDs, if new elements not creared - returns empty list.
int	GetMeshId () const
	Return edited mesh ID.
CORBA::Boolean	DoubleNodes (const SMESH::long_array &theNodes, const SMESH::long_array &theModifiedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements.
CORBA::Boolean	DoubleNode (CORBA::Long theNodeId, const SMESH::long_array &theModifiedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements This method provided for convenience works as DoubleNodes() described above.
CORBA::Boolean	DoubleNodeGroup (SMESH::SMESH_GroupBase_ptr theNodes, SMESH::SMESH_GroupBase_ptr theModifiedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements This method provided for convenience works as DoubleNodes() described above.
SMESH::SMESH_Group_ptr	DoubleNodeGroupNew (SMESH::SMESH_GroupBase_ptr theNodes, SMESH::SMESH_GroupBase_ptr theModifiedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements.
CORBA::Boolean	DoubleNodeGroups (const SMESH::ListOfGroups &theNodes, const SMESH::ListOfGroups &theModifiedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements This method provided for convenience works as DoubleNodes() described above.
SMESH::SMESH_Group_ptr	DoubleNodeGroupsNew (const SMESH::ListOfGroups &theNodes, const SMESH::ListOfGroups &theModifiedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements.
CORBA::Boolean	DoubleNodeElem (const SMESH::long_array &theElems, const SMESH::long_array &theNodesNot, const SMESH::long_array &theAffectedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements.
CORBA::Boolean	DoubleNodeElemInRegion (const SMESH::long_array &theElems, const SMESH::long_array &theNodesNot, GEOM::GEOM_Object_ptr theShape)
	Creates a hole in a mesh by doubling the nodes of some particular elements.
CORBA::Boolean	DoubleNodeElemGroup (SMESH::SMESH_GroupBase_ptr theElems, SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theAffectedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements.
SMESH::SMESH_Group_ptr	DoubleNodeElemGroupNew (SMESH::SMESH_GroupBase_ptr theElems, SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theAffectedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements Works as DoubleNodeElemGroup(), but returns a new group with newly created elements.
CORBA::Boolean	DoubleNodeElemGroupInRegion (SMESH::SMESH_GroupBase_ptr theElems, SMESH::SMESH_GroupBase_ptr theNodesNot, GEOM::GEOM_Object_ptr theShape)
	Creates a hole in a mesh by doubling the nodes of some particular elements.
CORBA::Boolean	DoubleNodeElemGroups (const SMESH::ListOfGroups &theElems, const SMESH::ListOfGroups &theNodesNot, const SMESH::ListOfGroups &theAffectedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements This method provided for convenience works as DoubleNodes() described above.
SMESH::SMESH_Group_ptr	DoubleNodeElemGroupsNew (const SMESH::ListOfGroups &theElems, const SMESH::ListOfGroups &theNodesNot, const SMESH::ListOfGroups &theAffectedElems)
	Creates a hole in a mesh by doubling the nodes of some particular elements Works as DoubleNodeElemGroups(), but returns a new group with newly created elements.
CORBA::Boolean	DoubleNodeElemGroupsInRegion (const SMESH::ListOfGroups &theElems, const SMESH::ListOfGroups &theNodesNot, GEOM::GEOM_Object_ptr theShape)
	Creates a hole in a mesh by doubling the nodes of some particular elements This method provided for convenience works as DoubleNodes() described above.
CORBA::Boolean	DoubleNodesOnGroupBoundaries (const SMESH::ListOfGroups &theDomains, CORBA::Boolean createJointElems)
	Double nodes on shared faces between groups of volumes and create flat elements on demand.
CORBA::Boolean	CreateFlatElementsOnFacesGroups (const SMESH::ListOfGroups &theGroupsOfFaces)
	Double nodes on some external faces and create flat elements.
CORBA::Boolean	Make2DMeshFrom3D ()
	Generated skin mesh (containing 2D cells) from 3D mesh The created 2D mesh elements based on nodes of free faces of boundary volumes.
SMESH::SMESH_Mesh_ptr	MakeBoundaryMesh (SMESH::SMESH_IDSource_ptr elements, SMESH::Bnd_Dimension dimension, const char *groupName, const char *meshName, CORBA::Boolean toCopyElements, CORBA::Boolean toCopyMissingBondary, SMESH::SMESH_Group_out group)
	Creates missing boundary elements.
CORBA::Long	MakeBoundaryElements (SMESH::Bnd_Dimension dimension, const char *groupName, const char *meshName, CORBA::Boolean toCopyAll, const SMESH::ListOfIDSources &groups, SMESH::SMESH_Mesh_out mesh, SMESH::SMESH_Group_out group) throw (SALOME::SALOME_Exception)
	Creates missing boundary elements.
Private Member Functions
SMESHDS_Mesh *	GetMeshDS ()
	< private methods
void	storeResult (::SMESH_MeshEditor &anEditor)
	Update myLastCreated* or myPreviewData.
void	initData (bool deleteSearchers=true)
	Clear myLastCreated* or myPreviewData.
SMESH::ListOfGroups *	getGroups (const std::list< int > *groupIDs)
	Return groups by their IDs.
SMESH::ListOfGroups *	rotationSweep (const SMESH::long_array &IDsOfElements, const SMESH::AxisStruct &Axis, CORBA::Double AngleInRadians, CORBA::Long NbOfSteps, CORBA::Double Tolerance, const bool MakeGroups, const SMDSAbs_ElementType ElementType=SMDSAbs_All)
SMESH::ListOfGroups *	extrusionSweep (const SMESH::long_array &IDsOfElements, const SMESH::DirStruct &StepVector, CORBA::Long NbOfSteps, bool MakeGroups, const SMDSAbs_ElementType ElementType=SMDSAbs_All)
SMESH::ListOfGroups *	advancedExtrusion (const SMESH::long_array &theIDsOfElements, const SMESH::DirStruct &theStepVector, CORBA::Long theNbOfSteps, CORBA::Long theExtrFlags, CORBA::Double theSewTolerance, const bool MakeGroups)
SMESH::ListOfGroups *	extrusionAlongPath (const SMESH::long_array &IDsOfElements, SMESH::SMESH_Mesh_ptr PathMesh, GEOM::GEOM_Object_ptr PathShape, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint, const bool MakeGroups, SMESH::SMESH_MeshEditor::Extrusion_Error &Error, const SMDSAbs_ElementType ElementType=SMDSAbs_All)
SMESH::ListOfGroups *	extrusionAlongPathX (const SMESH::long_array &IDsOfElements, SMESH::SMESH_IDSource_ptr Path, CORBA::Long NodeStart, CORBA::Boolean HasAngles, const SMESH::double_array &Angles, CORBA::Boolean LinearVariation, CORBA::Boolean HasRefPoint, const SMESH::PointStruct &RefPoint, bool MakeGroups, const SMDSAbs_ElementType ElementType, SMESH::SMESH_MeshEditor::Extrusion_Error &theError)
SMESH::ListOfGroups *	mirror (TIDSortedElemSet &IDsOfElements, const SMESH::AxisStruct &Axis, SMESH::SMESH_MeshEditor::MirrorType MirrorType, CORBA::Boolean Copy, bool MakeGroups,::SMESH_Mesh *TargetMesh=0)
SMESH::ListOfGroups *	translate (TIDSortedElemSet &IDsOfElements, const SMESH::DirStruct &Vector, CORBA::Boolean Copy, bool MakeGroups,::SMESH_Mesh *TargetMesh=0)
SMESH::ListOfGroups *	rotate (TIDSortedElemSet &IDsOfElements, const SMESH::AxisStruct &Axis, CORBA::Double Angle, CORBA::Boolean Copy, bool MakeGroups,::SMESH_Mesh *TargetMesh=0)
SMESH::ListOfGroups *	scale (SMESH::SMESH_IDSource_ptr theObject, const SMESH::PointStruct &thePoint, const SMESH::double_array &theScaleFact, CORBA::Boolean theCopy, bool theMakeGroups,::SMESH_Mesh *theTargetMesh=0)
SMESH::SMESH_Mesh_ptr	makeMesh (const char *theMeshName)
void	DumpGroupsList (SMESH::TPythonDump &theDumpPython, const SMESH::ListOfGroups *theGroupList)
string	generateGroupName (const string &thePrefix)
	Generates the unique group name.
Private Attributes
SMESH_Mesh_i *	myMesh_i
	< fields
SMESH_Mesh *	myMesh
SMESH::long_array_var	myLastCreatedElems
SMESH::long_array_var	myLastCreatedNodes
SMESH::MeshPreviewStruct_var	myPreviewData
bool	myPreviewMode

---

Detailed Description

Definition at line 44 of file SMESH_MeshEditor_i.hxx.

---

Constructor & Destructor Documentation

SMESH_MeshEditor_i::SMESH_MeshEditor_i	(	SMESH_Mesh_i *	theMesh,
		bool	isPreview
	)

Definition at line 379 of file SMESH_MeshEditor_i.cxx.

References SMESH_Mesh_i.GetImpl().

{
  myMesh_i = theMesh;
  myMesh = & theMesh->GetImpl();
  myPreviewMode = isPreview;
}

SMESH_MeshEditor_i::~SMESH_MeshEditor_i

(

)

[virtual]

Destructor.

Definition at line 392 of file SMESH_MeshEditor_i.cxx.

{
}

---

Member Function Documentation

CORBA::Long SMESH_MeshEditor_i::Add0DElement

(

CORBA::Long

IDOfNode

)

Definition at line 564 of file SMESH_MeshEditor_i.cxx.

References SMDS_MeshElement.GetID().

{
  initData();

  const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(IDOfNode);
  SMDS_MeshElement* elem = GetMeshDS()->Add0DElement(aNode);

  // Update Python script
  TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";

  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true ); // issue 0020693

  if (elem)
    return elem->GetID();

  return 0;
}

CORBA::Long SMESH_MeshEditor_i::AddEdge

(

const SMESH::long_array &

IDsOfNodes

)

Definition at line 589 of file SMESH_MeshEditor_i.cxx.

References FindNode(), SMDS_MeshElement.GetID(), SMESH_AdvancedEditor.n1, and SMESH_AdvancedEditor.n2.

{
  initData();

  int NbNodes = IDsOfNodes.length();
  SMDS_MeshElement* elem = 0;
  if (NbNodes == 2)
  {
    CORBA::Long index1 = IDsOfNodes[0];
    CORBA::Long index2 = IDsOfNodes[1];
    elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(index1), GetMeshDS()->FindNode(index2));

    // Update Python script
    TPythonDump() << "edge = " << this << ".AddEdge([ "
                  << index1 << ", " << index2 <<" ])";
  }
  if (NbNodes == 3) {
    CORBA::Long n1 = IDsOfNodes[0];
    CORBA::Long n2 = IDsOfNodes[1];
    CORBA::Long n12 = IDsOfNodes[2];
    elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(n1),
                                GetMeshDS()->FindNode(n2),
                                GetMeshDS()->FindNode(n12));
    // Update Python script
    TPythonDump() << "edgeID = " << this << ".AddEdge([ "
                  <<n1<<", "<<n2<<", "<<n12<<" ])";
  }

  myMesh->GetMeshDS()->Modified();
  if(elem)
    return myMesh->SetIsModified( true ), elem->GetID();

  return 0;
}

CORBA::Long SMESH_MeshEditor_i::AddFace

(

const SMESH::long_array &

IDsOfNodes

)

AddFace.

Definition at line 630 of file SMESH_MeshEditor_i.cxx.

References SMDS_MeshElement.GetID(), and SMESH_AdvancedEditor.nodes.

{
  initData();

  int NbNodes = IDsOfNodes.length();
  if (NbNodes < 3)
  {
    return 0;
  }

  std::vector<const SMDS_MeshNode*> nodes (NbNodes);
  for (int i = 0; i < NbNodes; i++)
    nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);

  SMDS_MeshElement* elem = 0;
  if (NbNodes == 3) {
    elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]);
  }
  else if (NbNodes == 4) {
    elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]);
  }
  else if (NbNodes == 6) {
    elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
                                nodes[4], nodes[5]);
  }
  else if (NbNodes == 8) {
    elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
                                nodes[4], nodes[5], nodes[6], nodes[7]);
  }
  else if (NbNodes > 2) {
    elem = GetMeshDS()->AddPolygonalFace(nodes);
  }

  // Update Python script
  TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";

  myMesh->GetMeshDS()->Modified();
  if(elem)
    return myMesh->SetIsModified( true ), elem->GetID();

  return 0;
}

CORBA::Long SMESH_MeshEditor_i::AddNode	(	CORBA::Double	x,
		CORBA::Double	y,
		CORBA::Double	z
	)

Methods for creation new elements.

Returns ID of created element or 0 if element not created

Definition at line 543 of file SMESH_MeshEditor_i.cxx.

References SMDS_MeshElement.GetID().

{
  initData();

  const SMDS_MeshNode* N = GetMeshDS()->AddNode(x, y, z);

  // Update Python script
  TPythonDump() << "nodeID = " << this << ".AddNode( "
                << x << ", " << y << ", " << z << " )";

  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true ); // issue 0020693
  return N->GetID();
}

CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace

(

const SMESH::long_array &

IDsOfNodes

)

AddPolygonalFace.

Definition at line 678 of file SMESH_MeshEditor_i.cxx.

References SMDS_MeshElement.GetID(), and SMESH_AdvancedEditor.nodes.

{
  initData();

  int NbNodes = IDsOfNodes.length();
  std::vector<const SMDS_MeshNode*> nodes (NbNodes);
  for (int i = 0; i < NbNodes; i++)
    nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);

  const SMDS_MeshElement* elem = GetMeshDS()->AddPolygonalFace(nodes);

  // Update Python script
  TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";

  myMesh->GetMeshDS()->Modified();
  return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
}

CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume	(	const SMESH::long_array &	IDsOfNodes,
		const SMESH::long_array &	Quantities
	)

AddPolyhedralVolume.

Definition at line 748 of file SMESH_MeshEditor_i.cxx.

References SMDS_MeshElement.GetID().

{
  initData();

  int NbNodes = IDsOfNodes.length();
  std::vector<const SMDS_MeshNode*> n (NbNodes);
  for (int i = 0; i < NbNodes; i++)
    {
      const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(IDsOfNodes[i]);
      if (!aNode) return 0;
      n[i] = aNode;
    }

  int NbFaces = Quantities.length();
  std::vector<int> q (NbFaces);
  for (int j = 0; j < NbFaces; j++)
    q[j] = Quantities[j];

  const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(n, q);

  // Update Python script
  TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
                << IDsOfNodes << ", " << Quantities << " )";
  myMesh->GetMeshDS()->Modified();

  return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
}

CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces

(

const SMESH::long_array &

IdsOfFaces

)

AddPolyhedralVolumeByFaces.

Definition at line 782 of file SMESH_MeshEditor_i.cxx.

References SMDS_MeshElement.GetID(), SMDS_MeshElement.NbNodes(), and SMDS_MeshElement.nodesIterator().

{
  initData();

  int NbFaces = IdsOfFaces.length();
  std::vector<const SMDS_MeshNode*> poly_nodes;
  std::vector<int> quantities (NbFaces);

  for (int i = 0; i < NbFaces; i++) {
    const SMDS_MeshElement* aFace = GetMeshDS()->FindElement(IdsOfFaces[i]);
    quantities[i] = aFace->NbNodes();

    SMDS_ElemIteratorPtr It = aFace->nodesIterator();
    while (It->more()) {
      poly_nodes.push_back(static_cast<const SMDS_MeshNode *>(It->next()));
    }
  }

  const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);

  // Update Python script
  TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
                << IdsOfFaces << " )";
  myMesh->GetMeshDS()->Modified();

  return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
}

CORBA::Long SMESH_MeshEditor_i::AddVolume

(

const SMESH::long_array &

IDsOfNodes

)

Definition at line 702 of file SMESH_MeshEditor_i.cxx.

References SMDS_MeshElement.GetID().

{
  initData();

  int NbNodes = IDsOfNodes.length();
  vector< const SMDS_MeshNode*> n(NbNodes);
  for(int i=0;i<NbNodes;i++)
    n[i]=GetMeshDS()->FindNode(IDsOfNodes[i]);

  SMDS_MeshElement* elem = 0;
  switch(NbNodes)
  {
  case 4 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3]); break;
  case 5 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4]); break;
  case 6 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5]); break;
  case 8 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7]); break;
  case 10:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
                                        n[6],n[7],n[8],n[9]);
    break;
  case 13:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
                                        n[7],n[8],n[9],n[10],n[11],n[12]);
    break;
  case 15:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],
                                        n[9],n[10],n[11],n[12],n[13],n[14]);
    break;
  case 20:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
                                        n[8],n[9],n[10],n[11],n[12],n[13],n[14],
                                        n[15],n[16],n[17],n[18],n[19]);
    break;
  }

  // Update Python script
  TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";

  myMesh->GetMeshDS()->Modified();
  if(elem)
    return myMesh->SetIsModified( true ), elem->GetID();

  return 0;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::advancedExtrusion	(	const SMESH::long_array &	theIDsOfElements,
		const SMESH::DirStruct &	theStepVector,
		CORBA::Long	theNbOfSteps,
		CORBA::Long	theExtrFlags,
		CORBA::Double	theSewTolerance,
		const bool	MakeGroups
	)		[private]

Definition at line 2065 of file SMESH_MeshEditor_i.cxx.

References SMESH.DirStruct.PS, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  initData();

  TIDSortedElemSet elements;
  arrayToSet(theIDsOfElements, GetMeshDS(), elements);

  const SMESH::PointStruct * P = &theStepVector.PS;
  gp_Vec stepVec( P->x, P->y, P->z );

  ::SMESH_MeshEditor anEditor( myMesh );
  TElemOfElemListMap aHystory;
  ::SMESH_MeshEditor::PGroupIDs groupIds =
      anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory,
                               theMakeGroups, theExtrFlags, theSewTolerance);
  storeResult(anEditor);

  return theMakeGroups ? getGroups(groupIds.get()) : 0;
}

void SMESH_MeshEditor_i::AdvancedExtrusion	(	const SMESH::long_array &	theIDsOfElements,
		const SMESH::DirStruct &	theStepVector,
		CORBA::Long	theNbOfSteps,
		CORBA::Long	theExtrFlags,
		CORBA::Double	theSewTolerance
	)

Definition at line 2095 of file SMESH_MeshEditor_i.cxx.

{
  if ( !myPreviewMode ) {
    TPythonDump() << "stepVector = " << theStepVector;
    TPythonDump() << this << ".AdvancedExtrusion("
                  << theIDsOfElements
                  << ", stepVector, "
                  << theNbOfSteps << ","
                  << theExtrFlags << ", "
                  << theSewTolerance <<  " )";
  }
  advancedExtrusion( theIDsOfElements,
                     theStepVector,
                     theNbOfSteps,
                     theExtrFlags,
                     theSewTolerance,
                     false);
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::DirStruct &	StepVector,
		CORBA::Long	NbOfSteps,
		CORBA::Long	ExtrFlags,
		CORBA::Double	SewTolerance
	)

Definition at line 2123 of file SMESH_MeshEditor_i.cxx.

{
  if (!myPreviewMode) {
    TPythonDump() << "stepVector = " << theStepVector;
  }
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups * aGroups = advancedExtrusion( theIDsOfElements,
                                                     theStepVector,
                                                     theNbOfSteps,
                                                     theExtrFlags,
                                                     theSewTolerance,
                                                     true);

  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".AdvancedExtrusionMakeGroups("
                << theIDsOfElements
                << ", stepVector, "
                << theNbOfSteps << ","
                << theExtrFlags << ", "
                << theSewTolerance <<  " )";
  }
  return aGroups;
}

CORBA::Long SMESH_MeshEditor_i::BestSplit	(	CORBA::Long	IDOfQuad,
		SMESH::NumericalFunctor_ptr	Criterion
	)

BestSplit.

Definition at line 1295 of file SMESH_MeshEditor_i.cxx.

References SMESH.NumericalFunctor_i.GetNumericalFunctor(), SMESH_Gen_i.GetServant(), SMDS_MeshElement.GetType(), SMDS_MeshElement.NbNodes(), and SMDSAbs_Face.

{
  initData();

  const SMDS_MeshElement* quad = GetMeshDS()->FindElement(IDOfQuad);
  if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4)
  {
    SMESH::NumericalFunctor_i* aNumericalFunctor =
      dynamic_cast<SMESH::NumericalFunctor_i*>(SMESH_Gen_i::GetServant(Criterion).in());
    SMESH::Controls::NumericalFunctorPtr aCrit;
    if (aNumericalFunctor)
      aCrit = aNumericalFunctor->GetNumericalFunctor();
    else
      aCrit.reset(new SMESH::Controls::AspectRatio());

    ::SMESH_MeshEditor anEditor (myMesh);
    return anEditor.BestSplit(quad, aCrit);
  }
  return -1;
}

CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes	(	CORBA::Long	ide,
		const SMESH::long_array &	newIDs
	)

Set new nodes for given element.

If number of nodes is not corresponded to type of element - returns false

Parameters:

ide	- element id
newIDs	- new node ids

Return values:

CORBA.Boolean

- true if result is OK

Definition at line 4597 of file SMESH_MeshEditor_i.cxx.

References MESSAGE, SMESH_AdvancedEditor.nbn, and SMESH_AdvancedEditor.res.

{
  initData();

  const SMDS_MeshElement* elem = GetMeshDS()->FindElement(ide);
  if(!elem) return false;

  int nbn = newIDs.length();
  int i=0;
  vector<const SMDS_MeshNode*> aNodes(nbn);
  int nbn1=-1;
  for(; i<nbn; i++) {
    const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(newIDs[i]);
    if(aNode) {
      nbn1++;
      aNodes[nbn1] = aNode;
    }
  }
  TPythonDump() << "isDone = " << this << ".ChangeElemNodes( "
                << ide << ", " << newIDs << " )";

  MESSAGE("ChangeElementNodes");
  bool res = GetMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );

  myMesh->GetMeshDS()->Modified();
  if ( res )
    myMesh->SetIsModified( true );

  return res;
}

CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic

(

)

Definition at line 4787 of file SMESH_MeshEditor_i.cxx.

References ex30_groupsOp.isDone.

{
  ::SMESH_MeshEditor anEditor( myMesh );
  CORBA::Boolean isDone = anEditor.ConvertFromQuadratic();
  TPythonDump() << this << ".ConvertFromQuadratic()";
  myMesh->GetMeshDS()->Modified();
  if ( isDone )
    myMesh->SetIsModified( true );
  return isDone;
}

void SMESH_MeshEditor_i::ConvertFromQuadraticObject

(

SMESH::SMESH_IDSource_ptr

theObject

)

throw (SALOME::SALOME_Exception)

Makes a part of the mesh linear.

Definition at line 4838 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_All, and SMDSAbs_Node.

{
  Unexpect aCatch(SALOME_SalomeException);
  TPythonDump pyDump;
  TIDSortedElemSet elems;
  if ( idSourceToSet( theObject, GetMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
  {
    if ( elems.empty() )
    {
      ConvertFromQuadratic();
    }
    else if ( (*elems.begin())->GetType() == SMDSAbs_Node )
    {
      THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM);
    }
    else
    {
      ::SMESH_MeshEditor anEditor( myMesh );
      anEditor.ConvertFromQuadratic(elems);
    }
  }
  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true );

  pyDump << this << ".ConvertFromQuadraticObject( "<<theObject<<" )";
}

void SMESH_MeshEditor_i::ConvertToQuadratic

(

CORBA::Boolean

Force3d

)

Definition at line 4773 of file SMESH_MeshEditor_i.cxx.

{
  ::SMESH_MeshEditor anEditor( myMesh );
  anEditor.ConvertToQuadratic(theForce3d);
  TPythonDump() << this << ".ConvertToQuadratic( " << theForce3d << " )";
  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true );
}

void SMESH_MeshEditor_i::ConvertToQuadraticObject	(	CORBA::Boolean	theForce3d,
		SMESH::SMESH_IDSource_ptr	theObject
	)		throw (SALOME::SALOME_Exception)

Makes a part of the mesh quadratic.

Definition at line 4803 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_All, and SMDSAbs_Node.

{
  Unexpect aCatch(SALOME_SalomeException);
  TPythonDump pyDump;
  TIDSortedElemSet elems;
  if ( idSourceToSet( theObject, GetMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
  {
    if ( elems.empty() )
    {
      ConvertToQuadratic( theForce3d );
    }
    else if ( (*elems.begin())->GetType() == SMDSAbs_Node )
    {
      THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM);
    }
    else
    {
      ::SMESH_MeshEditor anEditor( myMesh );
      anEditor.ConvertToQuadratic(theForce3d, elems);
    }
  }
  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true );

  pyDump << this << ".ConvertToQuadraticObject( "<<theForce3d<<", "<<theObject<<" )";
}

CORBA::Boolean SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups

(

const SMESH::ListOfGroups &

theGroupsOfFaces

)

Double nodes on some external faces and create flat elements.

Flat elements are mainly used by some types of mechanic calculations.

Each group of the list must be constituted of faces. Triangles are transformed in prisms, and quadrangles in hexahedrons.

Parameters:

theGroupsOfFaces

- list of groups of faces

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

Definition at line 5648 of file SMESH_MeshEditor_i.cxx.

References SMESH.NODE, and SMDSAbs_All.

{
  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  SMESHDS_Mesh* aMeshDS = GetMeshDS();

  vector<TIDSortedElemSet> faceGroups;
  faceGroups.clear();

  for ( int i = 0, n = theGroupsOfFaces.length(); i < n; i++ )
  {
    SMESH::SMESH_GroupBase_var aGrp = theGroupsOfFaces[ i ];
    if ( !CORBA::is_nil( aGrp ) && ( aGrp->GetType() != SMESH::NODE ) )
    {
      TIDSortedElemSet faceGroup;
      faceGroup.clear();
      faceGroups.push_back(faceGroup);
      SMESH::long_array_var anIDs = aGrp->GetIDs();
      arrayToSet( anIDs, aMeshDS, faceGroups[ i ], SMDSAbs_All );
    }
  }

  bool aResult = aMeshEditor.CreateFlatElementsOnFacesGroups( faceGroups );
  // TODO publish the groups of flat elements in study

  storeResult( aMeshEditor) ;
  myMesh->GetMeshDS()->Modified();

  // Update Python script
  TPythonDump() << "isDone = " << this << ".CreateFlatElementsOnFacesGroups( " << &theGroupsOfFaces << " )";
  return aResult;
}

CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag	(	CORBA::Long	NodeID1,
		CORBA::Long	NodeID2
	)

Definition at line 1030 of file SMESH_MeshEditor_i.cxx.

References SMESH_AdvancedEditor.n1, and SMESH_AdvancedEditor.n2.

{
  initData();

  const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
  const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
  if ( !n1 || !n2 )
    return false;

  // Update Python script
  TPythonDump() << "isDone = " << this << ".DeleteDiag( "
                << NodeID1 << ", " << NodeID2 <<  " )";

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  bool stat = aMeshEditor.DeleteDiag ( n1, n2 );

  myMesh->GetMeshDS()->Modified();
  if ( stat )
    myMesh->SetIsModified( true ); // issue 0020693

  storeResult(aMeshEditor);

  return stat;
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNode	(	CORBA::Long	theNodeId,
		const SMESH::long_array &	theModifiedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements This method provided for convenience works as DoubleNodes() described above.

Parameters:

theNodeId	- identifier of node to be doubled.
theModifiedElems	- identifiers of elements to be updated.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()

Definition at line 4987 of file SMESH_MeshEditor_i.cxx.

{
  SMESH::long_array_var aNodes = new SMESH::long_array;
  aNodes->length( 1 );
  aNodes[ 0 ] = theNodeId;

  TPythonDump pyDump; // suppress dump by the next line

  CORBA::Boolean done = DoubleNodes( aNodes, theModifiedElems );

  pyDump << this << ".DoubleNode( " << theNodeId << ", " << theModifiedElems << " )";

  return done;
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem	(	const SMESH::long_array &	theElems,
		const SMESH::long_array &	theNodesNot,
		const SMESH::long_array &	theAffectedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements.

Parameters:

theElems	- the list of elements (edges or faces) to be replicated The nodes for duplication could be found from these elements
theNodesNot	- list of nodes to NOT replicate
theAffectedElems	- the list of elements (cells and edges) to which the replicated nodes should be associated to.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNodeGroup(), DoubleNodeGroups()

Definition at line 5196 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_All, and SMDSAbs_Node.

{
  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  SMESHDS_Mesh* aMeshDS = GetMeshDS();
  TIDSortedElemSet anElems, aNodes, anAffected;
  arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
  arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
  arrayToSet(theAffectedElems, aMeshDS, anAffected, SMDSAbs_All);

  bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );

  storeResult( aMeshEditor) ;

  myMesh->GetMeshDS()->Modified();
  if ( aResult )
    myMesh->SetIsModified( true );

  // Update Python script
  TPythonDump() << this << ".DoubleNodeElem( " << theElems << ", "
                << theNodesNot << ", " << theAffectedElems << " )";
  return aResult;
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroup	(	SMESH::SMESH_GroupBase_ptr	theElems,
		SMESH::SMESH_GroupBase_ptr	theNodesNot,
		SMESH::SMESH_GroupBase_ptr	theAffectedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements.

Parameters:

theElems	- group of of elements (edges or faces) to be replicated
theNodesNot	- group of nodes not to replicated
theAffectedElems	- group of elements to which the replicated nodes should be associated to.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNodes(), DoubleNodeGroups(), DoubleNodeElemGroupNew()

Parameters:

theElems	- group of of elements (edges or faces) to be replicated
theNodesNot	- group of nodes not to replicated
theAffectedElems	- group of elements to which the replicated nodes should be associated to.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNodes(), DoubleNodeGroups()

Definition at line 5280 of file SMESH_MeshEditor_i.cxx.

References SMESH.NODE, SMDSAbs_All, and SMDSAbs_Node.

{
  if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
    return false;

  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  SMESHDS_Mesh* aMeshDS = GetMeshDS();
  TIDSortedElemSet anElems, aNodes, anAffected;
  idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
  idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
  idSourceToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All );

  bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );

  storeResult( aMeshEditor) ;

  myMesh->GetMeshDS()->Modified();
  if ( aResult )
    myMesh->SetIsModified( true );

  // Update Python script
  TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroup( " << theElems << ", "
                << theNodesNot << ", " << theAffectedElems << " )";
  return aResult;
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion	(	SMESH::SMESH_GroupBase_ptr	theElems,
		SMESH::SMESH_GroupBase_ptr	theNodesNot,
		GEOM::GEOM_Object_ptr	theShape
	)

Creates a hole in a mesh by doubling the nodes of some particular elements.

Parameters:

theElems	- group of of elements (edges or faces) to be replicated
theNodesNot	- group of nodes not to replicated
theShape	- shape to detect affected elements (element which geometric center located on or inside shape). The replicated nodes should be associated to affected elements.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNodesInRegion(), DoubleNodeGroupsInRegion()

Definition at line 5378 of file SMESH_MeshEditor_i.cxx.

References SMESH_fixation.aShape, SMESH_Gen_i.GeomObjectToShape(), SMESH_Gen_i.GetSMESHGen(), SMESH.NODE, SMDSAbs_All, and SMDSAbs_Node.

{
  if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
    return false;

  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  SMESHDS_Mesh* aMeshDS = GetMeshDS();
  TIDSortedElemSet anElems, aNodes, anAffected;
  idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
  idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );

  TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
  bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape );

  storeResult( aMeshEditor) ;

  myMesh->GetMeshDS()->Modified();
  if ( aResult )
    myMesh->SetIsModified( true );

  // Update Python script
  TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupInRegion( " << theElems << ", "
                << theNodesNot << ", " << theShape << " )";
  return aResult;
}

SMESH::SMESH_Group_ptr SMESH_MeshEditor_i::DoubleNodeElemGroupNew	(	SMESH::SMESH_GroupBase_ptr	theElems,
		SMESH::SMESH_GroupBase_ptr	theNodesNot,
		SMESH::SMESH_GroupBase_ptr	theAffectedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements Works as DoubleNodeElemGroup(), but returns a new group with newly created elements.

Parameters:

theElems	- group of of elements (edges or faces) to be replicated
theNodesNot	- group of nodes not to replicated
theAffectedElems	- group of elements to which the replicated nodes should be associated to.

Returns:

a new group with newly created elements

See also:

DoubleNodeElemGroup()

Definition at line 5321 of file SMESH_MeshEditor_i.cxx.

References SMESH_BelongToGeom.anIds, SMESH.NODE, SMDSAbs_All, and SMDSAbs_Node.

{
  if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
    return false;

  SMESH::SMESH_Group_var aNewGroup;

  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  SMESHDS_Mesh* aMeshDS = GetMeshDS();
  TIDSortedElemSet anElems, aNodes, anAffected;
  idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
  idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
  idSourceToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All );


  bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );

  storeResult( aMeshEditor) ;

  if ( aResult ) {
    myMesh->SetIsModified( true );

    // Create group with newly created elements
    SMESH::long_array_var anIds = GetLastCreatedElems();
    if (anIds->length() > 0) {
      SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
      string anUnindexedName (theElems->GetName());
      string aNewName = generateGroupName(anUnindexedName + "_double");
      aNewGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
      aNewGroup->Add(anIds);
    }
  }

  // Update Python script
  TPythonDump() << "createdElems = " << this << ".DoubleNodeElemGroupNew( " << theElems << ", "
    << theNodesNot << ", " << theAffectedElems << " )";
  return aNewGroup._retn();
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroups	(	const SMESH::ListOfGroups &	theElems,
		const SMESH::ListOfGroups &	theNodesNot,
		const SMESH::ListOfGroups &	theAffectedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements This method provided for convenience works as DoubleNodes() described above.

Parameters:

theElems	- list of groups of elements (edges or faces) to be replicated
theNodesNot	- list of groups of nodes not to replicated
theAffectedElems	- group of elements to which the replicated nodes should be associated to.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()

Definition at line 5440 of file SMESH_MeshEditor_i.cxx.

References listOfGroupToSet().

{
  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  SMESHDS_Mesh* aMeshDS = GetMeshDS();
  TIDSortedElemSet anElems, aNodes, anAffected;
  listOfGroupToSet(theElems, aMeshDS, anElems, false );
  listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
  listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );

  bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );

  storeResult( aMeshEditor) ;

  myMesh->GetMeshDS()->Modified();
  if ( aResult )
    myMesh->SetIsModified( true );

  // Update Python script
  TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroups( " << &theElems << ", "
                << &theNodesNot << ", " << &theAffectedElems << " )";
  return aResult;
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion	(	const SMESH::ListOfGroups &	theElems,
		const SMESH::ListOfGroups &	theNodesNot,
		GEOM::GEOM_Object_ptr	theShape
	)

Creates a hole in a mesh by doubling the nodes of some particular elements This method provided for convenience works as DoubleNodes() described above.

Parameters:

theElems	- list of groups of elements (edges or faces) to be replicated
theNodesNot	- list of groups of nodes not to replicated
theShape	- shape to detect affected elements (element which geometric center located on or inside shape). The replicated nodes should be associated to affected elements.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNodeGroupInRegion(), DoubleNodesInRegion()

Definition at line 5537 of file SMESH_MeshEditor_i.cxx.

References SMESH_fixation.aShape, SMESH_Gen_i.GeomObjectToShape(), SMESH_Gen_i.GetSMESHGen(), and listOfGroupToSet().

{
  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  SMESHDS_Mesh* aMeshDS = GetMeshDS();
  TIDSortedElemSet anElems, aNodes;
  listOfGroupToSet(theElems, aMeshDS, anElems,false );
  listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );

  TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
  bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape );

  storeResult( aMeshEditor) ;

  myMesh->GetMeshDS()->Modified();
  if ( aResult )
    myMesh->SetIsModified( true );

  // Update Python script
  TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupsInRegion( " << &theElems << ", "
                << &theNodesNot << ", " << theShape << " )";
  return aResult;
}

SMESH::SMESH_Group_ptr SMESH_MeshEditor_i::DoubleNodeElemGroupsNew	(	const SMESH::ListOfGroups &	theElems,
		const SMESH::ListOfGroups &	theNodesNot,
		const SMESH::ListOfGroups &	theAffectedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements Works as DoubleNodeElemGroups(), but returns a new group with newly created elements.

Parameters:

theElems	- list of groups of elements (edges or faces) to be replicated
theNodesNot	- list of groups of nodes not to replicated
theAffectedElems	- group of elements to which the replicated nodes should be associated to.

Returns:

a new group with newly created elements

See also:

DoubleNodeElemGroups()

Definition at line 5481 of file SMESH_MeshEditor_i.cxx.

References SMESH_BelongToGeom.anIds, smeshDC.GetName(), and listOfGroupToSet().

{
  SMESH::SMESH_Group_var aNewGroup;
  
  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  SMESHDS_Mesh* aMeshDS = GetMeshDS();
  TIDSortedElemSet anElems, aNodes, anAffected;
  listOfGroupToSet(theElems, aMeshDS, anElems, false );
  listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
  listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );

  bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );

  storeResult( aMeshEditor) ;

  myMesh->GetMeshDS()->Modified();
  if ( aResult ) {
    myMesh->SetIsModified( true );

    // Create group with newly created elements
    SMESH::long_array_var anIds = GetLastCreatedElems();
    if (anIds->length() > 0) {
      SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
      string anUnindexedName (theElems[0]->GetName());
      string aNewName = generateGroupName(anUnindexedName + "_double");
      aNewGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
      aNewGroup->Add(anIds);
    }
  }

  // Update Python script
  TPythonDump() << "createdElems = " << this << ".DoubleNodeElemGroupsNew( " << &theElems << ", "
                << &theNodesNot << ", " << &theAffectedElems << " )";
  return aNewGroup._retn();
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion	(	const SMESH::long_array &	theElems,
		const SMESH::long_array &	theNodesNot,
		GEOM::GEOM_Object_ptr	theShape
	)

Creates a hole in a mesh by doubling the nodes of some particular elements.

Parameters:

theElems	- the list of elements (edges or faces) to be replicated The nodes for duplication could be found from these elements
theNodesNot	- list of nodes to NOT replicate
theShape	- shape to detect affected elements (element which geometric center located on or inside shape). The replicated nodes should be associated to affected elements.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()

Definition at line 5239 of file SMESH_MeshEditor_i.cxx.

References SMESH_fixation.aShape, SMESH_Gen_i.GeomObjectToShape(), SMESH_Gen_i.GetSMESHGen(), SMDSAbs_All, and SMDSAbs_Node.

{
  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  SMESHDS_Mesh* aMeshDS = GetMeshDS();
  TIDSortedElemSet anElems, aNodes;
  arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
  arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);

  TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
  bool aResult = aMeshEditor.DoubleNodesInRegion( anElems, aNodes, aShape );

  storeResult( aMeshEditor) ;

  myMesh->GetMeshDS()->Modified();
  if ( aResult )
    myMesh->SetIsModified( true );

  // Update Python script
  TPythonDump() << "isDone = " << this << ".DoubleNodeElemInRegion( " << theElems << ", "
                << theNodesNot << ", " << theShape << " )";
  return aResult;
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup	(	SMESH::SMESH_GroupBase_ptr	theNodes,
		SMESH::SMESH_GroupBase_ptr	theModifiedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements This method provided for convenience works as DoubleNodes() described above.

Parameters:

theNodes	- group of nodes to be doubled.
theModifiedElems	- group of elements to be updated.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNode(), DoubleNodes(), DoubleNodeGroups()

Definition at line 5014 of file SMESH_MeshEditor_i.cxx.

References SMESH.NODE.

{
  if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
    return false;

  SMESH::long_array_var aNodes = theNodes->GetListOfID();
  SMESH::long_array_var aModifiedElems;
  if ( !CORBA::is_nil( theModifiedElems ) )
    aModifiedElems = theModifiedElems->GetListOfID();
  else
  {
    aModifiedElems = new SMESH::long_array;
    aModifiedElems->length( 0 );
  }

  TPythonDump pyDump; // suppress dump by the next line

  bool done = DoubleNodes( aNodes, aModifiedElems );

  pyDump << this << ".DoubleNodeGroup( " << theNodes << ", " << theModifiedElems << " )";

  return done;
}

SMESH::SMESH_Group_ptr SMESH_MeshEditor_i::DoubleNodeGroupNew	(	SMESH::SMESH_GroupBase_ptr	theNodes,
		SMESH::SMESH_GroupBase_ptr	theModifiedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements.

Works as DoubleNodeGroup(), but returns a new group with newly created nodes.

Parameters:

theNodes	- group of nodes to be doubled.
theModifiedElems	- group of elements to be updated.

Returns:

a new group with newly created nodes

See also:

DoubleNodeGroup()

Definition at line 5047 of file SMESH_MeshEditor_i.cxx.

References SMESH_BelongToGeom.anIds, and SMESH.NODE.

{
  if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
    return false;

  SMESH::SMESH_Group_var aNewGroup;

  // Duplicate nodes
  SMESH::long_array_var aNodes = theNodes->GetListOfID();
  SMESH::long_array_var aModifiedElems;
  if ( !CORBA::is_nil( theModifiedElems ) )
    aModifiedElems = theModifiedElems->GetListOfID();
  else {
    aModifiedElems = new SMESH::long_array;
    aModifiedElems->length( 0 );
  }

  TPythonDump pyDump; // suppress dump by the next line

  bool aResult = DoubleNodes( aNodes, aModifiedElems );

  if ( aResult )
  {
    // Create group with newly created nodes
    SMESH::long_array_var anIds = GetLastCreatedNodes();
    if (anIds->length() > 0) {
      string anUnindexedName (theNodes->GetName());
      string aNewName = generateGroupName(anUnindexedName + "_double");
      aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
      aNewGroup->Add(anIds);
    }
  }

  pyDump << "createdNodes = " << this << ".DoubleNodeGroupNew( " << theNodes << ", "
    << theModifiedElems << " )";

  return aNewGroup._retn();
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups	(	const SMESH::ListOfGroups &	theNodes,
		const SMESH::ListOfGroups &	theModifiedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements This method provided for convenience works as DoubleNodes() described above.

Parameters:

theNodes	- list of groups of nodes to be doubled
theModifiedElems	- list of groups of elements to be updated.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNode(), DoubleNodeGroup(), DoubleNodes()

Definition at line 5098 of file SMESH_MeshEditor_i.cxx.

References ex30_tepal.m, and SMESH.NODE.

{
  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  std::list< int > aNodes;
  int i, n, j, m;
  for ( i = 0, n = theNodes.length(); i < n; i++ )
  {
    SMESH::SMESH_GroupBase_var aGrp = theNodes[ i ];
    if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() == SMESH::NODE )
    {
      SMESH::long_array_var aCurr = aGrp->GetListOfID();
      for ( j = 0, m = aCurr->length(); j < m; j++ )
        aNodes.push_back( aCurr[ j ] );
    }
  }

  std::list< int > anElems;
  for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
  {
    SMESH::SMESH_GroupBase_var aGrp = theModifiedElems[ i ];
    if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() != SMESH::NODE )
    {
      SMESH::long_array_var aCurr = aGrp->GetListOfID();
      for ( j = 0, m = aCurr->length(); j < m; j++ )
        anElems.push_back( aCurr[ j ] );
    }
  }

  bool aResult = aMeshEditor.DoubleNodes( aNodes, anElems );

  storeResult( aMeshEditor) ;

  myMesh->GetMeshDS()->Modified();
  if ( aResult )
    myMesh->SetIsModified( true );


  TPythonDump() << this << ".DoubleNodeGroups( " << theNodes << ", " << theModifiedElems << " )";

  return aResult;
}

SMESH::SMESH_Group_ptr SMESH_MeshEditor_i::DoubleNodeGroupsNew	(	const SMESH::ListOfGroups &	theNodes,
		const SMESH::ListOfGroups &	theModifiedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements.

Works as DoubleNodeGroups(), but returns a new group with newly created nodes.

Parameters:

theNodes	- group of nodes to be doubled.
theModifiedElems	- group of elements to be updated.

Returns:

a new group with newly created nodes

See also:

DoubleNodeGroups()

Definition at line 5155 of file SMESH_MeshEditor_i.cxx.

References SMESH_BelongToGeom.anIds, smeshDC.GetName(), and SMESH.NODE.

{
  SMESH::SMESH_Group_var aNewGroup;

  TPythonDump pyDump; // suppress dump by the next line

  bool aResult = DoubleNodeGroups( theNodes, theModifiedElems );

  if ( aResult )
  {
    // Create group with newly created nodes
    SMESH::long_array_var anIds = GetLastCreatedNodes();
    if (anIds->length() > 0) {
      string anUnindexedName (theNodes[0]->GetName());
      string aNewName = generateGroupName(anUnindexedName + "_double");
      aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
      aNewGroup->Add(anIds);
    }
  }

  pyDump << "createdNodes = " << this << ".DoubleNodeGroupsNew( " << theNodes << ", "
    << theModifiedElems << " )";

  return aNewGroup._retn();
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes	(	const SMESH::long_array &	theNodes,
		const SMESH::long_array &	theModifiedElems
	)

Creates a hole in a mesh by doubling the nodes of some particular elements.

Parameters:

theNodes	- identifiers of nodes to be doubled
theModifiedElems	- identifiers of elements to be updated by the new (doubled) nodes. If list of element identifiers is empty then nodes are doubled but they not assigned to elements

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

See also:

DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()

Definition at line 4948 of file SMESH_MeshEditor_i.cxx.

References ex30_groupsOp.aListOfElems.

{
  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );
  list< int > aListOfNodes;
  int i, n;
  for ( i = 0, n = theNodes.length(); i < n; i++ )
    aListOfNodes.push_back( theNodes[ i ] );

  list< int > aListOfElems;
  for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
    aListOfElems.push_back( theModifiedElems[ i ] );

  bool aResult = aMeshEditor.DoubleNodes( aListOfNodes, aListOfElems );

  myMesh->GetMeshDS()->Modified();
  storeResult( aMeshEditor) ;
  if ( aResult )
    myMesh->SetIsModified( true );

  // Update Python script
  TPythonDump() << this << ".DoubleNodes( " << theNodes << ", "<< theModifiedElems << " )";

  return aResult;
}

CORBA::Boolean SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries	(	const SMESH::ListOfGroups &	theDomains,
		CORBA::Boolean	createJointElems
	)

Double nodes on shared faces between groups of volumes and create flat elements on demand.

The list of groups must describe a partition of the mesh volumes. The nodes of the internal faces at the boundaries of the groups are doubled. In option, the internal faces are replaced by flat elements. Triangles are transformed in prisms, and quadrangles in hexahedrons.

Parameters:

theDomains	- list of groups of volumes
createJointElems	- if TRUE, create the elements

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

The list of groups must describe a partition of the mesh volumes. The nodes of the internal faces at the boundaries of the groups are doubled. In option, the internal faces are replaced by flat elements. Triangles are transformed in prisms, and quadrangles in hexahedrons. The flat elements are stored in groups of volumes.

Parameters:

theDomains	- list of groups of volumes
createJointElems	- if TRUE, create the elements

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

Definition at line 5599 of file SMESH_MeshEditor_i.cxx.

References SMESH.NODE, and SMDSAbs_All.

{
  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );

  SMESHDS_Mesh* aMeshDS = GetMeshDS();

  vector<TIDSortedElemSet> domains;
  domains.clear();

  for ( int i = 0, n = theDomains.length(); i < n; i++ )
  {
    SMESH::SMESH_GroupBase_var aGrp = theDomains[ i ];
    if ( !CORBA::is_nil( aGrp ) && ( aGrp->GetType() != SMESH::NODE ) )
    {
      TIDSortedElemSet domain;
      domain.clear();
      domains.push_back(domain);
      SMESH::long_array_var anIDs = aGrp->GetIDs();
      arrayToSet( anIDs, aMeshDS, domains[ i ], SMDSAbs_All );
    }
  }

  bool aResult = aMeshEditor.DoubleNodesOnGroupBoundaries( domains, createJointElems );
  // TODO publish the groups of flat elements in study

  storeResult( aMeshEditor) ;
  myMesh->GetMeshDS()->Modified();

  // Update Python script
  TPythonDump() << "isDone = " << this << ".DoubleNodesOnGroupBoundaries( " << &theDomains
      << ", " << createJointElems << " )";
  return aResult;
}

void SMESH_MeshEditor_i::DumpGroupsList	(	SMESH::TPythonDump &	theDumpPython,
		const SMESH::ListOfGroups *	theGroupList
	)		[private]

Definition at line 4887 of file SMESH_MeshEditor_i.cxx.

{
  bool isDumpGroupList = theGroupList && theGroupList->length() > 0;
  if(isDumpGroupList) {
    theDumpPython << theGroupList << " = ";
  }
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::extrusionAlongPath	(	const SMESH::long_array &	IDsOfElements,
		SMESH::SMESH_Mesh_ptr	PathMesh,
		GEOM::GEOM_Object_ptr	PathShape,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint,
		const bool	MakeGroups,
		SMESH::SMESH_MeshEditor::Extrusion_Error &	Error,
		const SMDSAbs_ElementType	ElementType = SMDSAbs_All
	)		[private]

Definition at line 2182 of file SMESH_MeshEditor_i.cxx.

References SMESH_fixation.aShape, convExtrError(), SMESH.SMESH_MeshEditor.EXTR_BAD_PATH_SHAPE, SMESH.SMESH_MeshEditor.EXTR_BAD_STARTING_NODE, SMESH_Gen_i.GeomObjectToShape(), SMESH_Mesh_i.GetImpl(), SMESH_Gen_i.GetSMESHGen(), MESSAGE, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  MESSAGE("extrusionAlongPath");
  initData();

  if ( thePathMesh->_is_nil() || thePathShape->_is_nil() ) {
    theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
    return 0;
  }
  SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );

  TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
  SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );

  if ( !aSubMesh || !aSubMesh->GetSubMeshDS()) {
    theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
    return 0;
  }

  SMDS_MeshNode* nodeStart = (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
  if ( !nodeStart ) {
    theError = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
    return 0;
  }

  TIDSortedElemSet elements;
  arrayToSet(theIDsOfElements, GetMeshDS(), elements, theElementType);

  list<double> angles;
  for (int i = 0; i < theAngles.length(); i++) {
    angles.push_back( theAngles[i] );
  }

  gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );

  int nbOldGroups = myMesh->NbGroup();

  ::SMESH_MeshEditor anEditor( myMesh );
  ::SMESH_MeshEditor::Extrusion_Error error =
      anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
                                    theHasAngles, angles, false,
                                    theHasRefPoint, refPnt, theMakeGroups );
  myMesh->GetMeshDS()->Modified();
  storeResult(anEditor);
  theError = convExtrError( error );

  if ( theMakeGroups ) {
    list<int> groupIDs = myMesh->GetGroupIds();
    list<int>::iterator newBegin = groupIDs.begin();
    std::advance( newBegin, nbOldGroups ); // skip old groups
    groupIDs.erase( groupIDs.begin(), newBegin );
    return getGroups( & groupIDs );
  }
  return 0;
}

SMESH::SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor_i::ExtrusionAlongPath	(	const SMESH::long_array &	IDsOfElements,
		SMESH::SMESH_Mesh_ptr	PathMesh,
		GEOM::GEOM_Object_ptr	PathShape,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint
	)

Definition at line 2364 of file SMESH_MeshEditor_i.cxx.

References MESSAGE, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  MESSAGE("ExtrusionAlongPath");
  if ( !myPreviewMode ) {
    TPythonDump() << "error = " << this << ".ExtrusionAlongPath( "
                  << theIDsOfElements << ", "
                  << thePathMesh      << ", "
                  << thePathShape     << ", "
                  << theNodeStart     << ", "
                  << theHasAngles     << ", "
                  << theAngles        << ", "
                  << theHasRefPoint   << ", "
                  << "SMESH.PointStruct( "
                  << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
                  << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
                  << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
  }
  SMESH::SMESH_MeshEditor::Extrusion_Error anError;
  extrusionAlongPath( theIDsOfElements,
                      thePathMesh,
                      thePathShape,
                      theNodeStart,
                      theHasAngles,
                      theAngles,
                      theHasRefPoint,
                      theRefPoint,
                      false,
                      anError);
  return anError;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups	(	const SMESH::long_array &	IDsOfElements,
		SMESH::SMESH_Mesh_ptr	PathMesh,
		GEOM::GEOM_Object_ptr	PathShape,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint,
		SMESH::SMESH_MeshEditor::Extrusion_Error &	Error
	)

Definition at line 2539 of file SMESH_MeshEditor_i.cxx.

References SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups * aGroups =  extrusionAlongPath( theIDsOfElements,
                                                       thePathMesh,
                                                       thePathShape,
                                                       theNodeStart,
                                                       theHasAngles,
                                                       theAngles,
                                                       theHasRefPoint,
                                                       theRefPoint,
                                                       true,
                                                       Error);
  if (!myPreviewMode) {
    bool isDumpGroups = aGroups && aGroups->length() > 0;
    if (isDumpGroups)
      aPythonDump << "(" << aGroups << ", error)";
    else
      aPythonDump <<"error";

    aPythonDump<<" = "<< this << ".ExtrusionAlongPathMakeGroups( "
               << theIDsOfElements << ", "
               << thePathMesh      << ", "
               << thePathShape     << ", "
               << theNodeStart     << ", "
               << theHasAngles     << ", "
               << theAngles        << ", "
               << theHasRefPoint   << ", "
               << "SMESH.PointStruct( "
               << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
               << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
               << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
  }
  return aGroups;
}

SMESH::SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor_i::ExtrusionAlongPathObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		SMESH::SMESH_Mesh_ptr	PathMesh,
		GEOM::GEOM_Object_ptr	PathShape,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint
	)

Definition at line 2407 of file SMESH_MeshEditor_i.cxx.

References SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  if ( !myPreviewMode ) {
    TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject( "
                  << theObject        << ", "
                  << thePathMesh      << ", "
                  << thePathShape     << ", "
                  << theNodeStart     << ", "
                  << theHasAngles     << ", "
                  << theAngles        << ", "
                  << theHasRefPoint   << ", "
                  << "SMESH.PointStruct( "
                  << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
                  << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
                  << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
  }
  SMESH::SMESH_MeshEditor::Extrusion_Error anError;
  SMESH::long_array_var anElementsId = theObject->GetIDs();
  extrusionAlongPath( anElementsId,
                      thePathMesh,
                      thePathShape,
                      theNodeStart,
                      theHasAngles,
                      theAngles,
                      theHasRefPoint,
                      theRefPoint,
                      false,
                      anError);
  return anError;
}

SMESH::SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor_i::ExtrusionAlongPathObject1D	(	SMESH::SMESH_IDSource_ptr	theObject,
		SMESH::SMESH_Mesh_ptr	PathMesh,
		GEOM::GEOM_Object_ptr	PathShape,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint
	)

Definition at line 2450 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Edge, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  if ( !myPreviewMode ) {
    TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject1D( "
                  << theObject        << ", "
                  << thePathMesh      << ", "
                  << thePathShape     << ", "
                  << theNodeStart     << ", "
                  << theHasAngles     << ", "
                  << theAngles        << ", "
                  << theHasRefPoint   << ", "
                  << "SMESH.PointStruct( "
                  << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
                  << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
                  << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
  }
  SMESH::SMESH_MeshEditor::Extrusion_Error anError;
  SMESH::long_array_var anElementsId = theObject->GetIDs();
  extrusionAlongPath( anElementsId,
                      thePathMesh,
                      thePathShape,
                      theNodeStart,
                      theHasAngles,
                      theAngles,
                      theHasRefPoint,
                      theRefPoint,
                      false,
                      anError,
                      SMDSAbs_Edge);
  return anError;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ExtrusionAlongPathObject1DMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		SMESH::SMESH_Mesh_ptr	PathMesh,
		GEOM::GEOM_Object_ptr	PathShape,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint,
		SMESH::SMESH_MeshEditor::Extrusion_Error &	Error
	)

Definition at line 2641 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Edge, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
                                                      thePathMesh,
                                                      thePathShape,
                                                      theNodeStart,
                                                      theHasAngles,
                                                      theAngles,
                                                      theHasRefPoint,
                                                      theRefPoint,
                                                      true,
                                                      Error,
                                                      SMDSAbs_Edge);

  if (!myPreviewMode) {
    bool isDumpGroups = aGroups && aGroups->length() > 0;
    if (isDumpGroups)
      aPythonDump << "(" << aGroups << ", error)";
    else
      aPythonDump << "error";

    aPythonDump << " = " << this << ".ExtrusionAlongPathObject1DMakeGroups( "
                << theObject << ", "
                << thePathMesh      << ", "
                << thePathShape     << ", "
                << theNodeStart     << ", "
                << theHasAngles     << ", "
                << theAngles        << ", "
                << theHasRefPoint   << ", "
                << "SMESH.PointStruct( "
                << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
                << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
                << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
  }
  return aGroups;
}

SMESH::SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor_i::ExtrusionAlongPathObject2D	(	SMESH::SMESH_IDSource_ptr	theObject,
		SMESH::SMESH_Mesh_ptr	PathMesh,
		GEOM::GEOM_Object_ptr	PathShape,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint
	)

Definition at line 2494 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Face, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  if ( !myPreviewMode ) {
    TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject2D( "
                  << theObject        << ", "
                  << thePathMesh      << ", "
                  << thePathShape     << ", "
                  << theNodeStart     << ", "
                  << theHasAngles     << ", "
                  << theAngles        << ", "
                  << theHasRefPoint   << ", "
                  << "SMESH.PointStruct( "
                  << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
                  << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
                  << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
  }
  SMESH::SMESH_MeshEditor::Extrusion_Error anError;
  SMESH::long_array_var anElementsId = theObject->GetIDs();
  extrusionAlongPath( anElementsId,
                      thePathMesh,
                      thePathShape,
                      theNodeStart,
                      theHasAngles,
                      theAngles,
                      theHasRefPoint,
                      theRefPoint,
                      false,
                      anError,
                      SMDSAbs_Face);
  return anError;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ExtrusionAlongPathObject2DMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		SMESH::SMESH_Mesh_ptr	PathMesh,
		GEOM::GEOM_Object_ptr	PathShape,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint,
		SMESH::SMESH_MeshEditor::Extrusion_Error &	Error
	)

Definition at line 2694 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Face, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
                                                      thePathMesh,
                                                      thePathShape,
                                                      theNodeStart,
                                                      theHasAngles,
                                                      theAngles,
                                                      theHasRefPoint,
                                                      theRefPoint,
                                                      true,
                                                      Error,
                                                      SMDSAbs_Face);

  if (!myPreviewMode) {
    bool isDumpGroups = aGroups && aGroups->length() > 0;
    if (isDumpGroups)
      aPythonDump << "(" << aGroups << ", error)";
    else
      aPythonDump << "error";

    aPythonDump << " = " << this << ".ExtrusionAlongPathObject2DMakeGroups( "
                << theObject << ", "
                << thePathMesh      << ", "
                << thePathShape     << ", "
                << theNodeStart     << ", "
                << theHasAngles     << ", "
                << theAngles        << ", "
                << theHasRefPoint   << ", "
                << "SMESH.PointStruct( "
                << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
                << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
                << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
  }
  return aGroups;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ExtrusionAlongPathObjectMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		SMESH::SMESH_Mesh_ptr	PathMesh,
		GEOM::GEOM_Object_ptr	PathShape,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint,
		SMESH::SMESH_MeshEditor::Extrusion_Error &	Error
	)

Definition at line 2589 of file SMESH_MeshEditor_i.cxx.

References SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
                                                      thePathMesh,
                                                      thePathShape,
                                                      theNodeStart,
                                                      theHasAngles,
                                                      theAngles,
                                                      theHasRefPoint,
                                                      theRefPoint,
                                                      true,
                                                      Error);

  if (!myPreviewMode) {
    bool isDumpGroups = aGroups && aGroups->length() > 0;
    if (isDumpGroups)
      aPythonDump << "(" << aGroups << ", error)";
    else
      aPythonDump <<"error";

    aPythonDump << " = " << this << ".ExtrusionAlongPathObjectMakeGroups( "
                << theObject << ", "
                << thePathMesh      << ", "
                << thePathShape     << ", "
                << theNodeStart     << ", "
                << theHasAngles     << ", "
                << theAngles        << ", "
                << theHasRefPoint   << ", "
                << "SMESH.PointStruct( "
                << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
                << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
                << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
  }
  return aGroups;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ExtrusionAlongPathObjX	(	SMESH::SMESH_IDSource_ptr	Object,
		SMESH::SMESH_IDSource_ptr	Path,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	LinearVariation,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint,
		CORBA::Boolean	MakeGroups,
		SMESH::ElementType	ElemType,
		SMESH::SMESH_MeshEditor::Extrusion_Error &	Error
	)

Definition at line 2748 of file SMESH_MeshEditor_i.cxx.

References SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::long_array_var anElementsId = Object->GetIDs();
  SMESH::ListOfGroups * aGroups = extrusionAlongPathX(anElementsId,
                                                      Path,
                                                      NodeStart,
                                                      HasAngles,
                                                      Angles,
                                                      LinearVariation,
                                                      HasRefPoint,
                                                      RefPoint,
                                                      MakeGroups,
                                                      (SMDSAbs_ElementType)ElemType,
                                                      Error);

  if (!myPreviewMode) {
    bool isDumpGroups = aGroups && aGroups->length() > 0;
    if (isDumpGroups)
      aPythonDump << "(" << *aGroups << ", error)";
    else
      aPythonDump << "error";

    aPythonDump << " = " << this << ".ExtrusionAlongPathObjX( "
                << Object      << ", "
                << Path        << ", "
                << NodeStart   << ", "
                << HasAngles   << ", "
                << Angles      << ", "
                << LinearVariation << ", "
                << HasRefPoint << ", "
                << "SMESH.PointStruct( "
                << ( HasRefPoint ? RefPoint.x : 0 ) << ", "
                << ( HasRefPoint ? RefPoint.y : 0 ) << ", "
                << ( HasRefPoint ? RefPoint.z : 0 ) << " ), "
                << MakeGroups << ", "
                << ElemType << " )";
  }
  return aGroups;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::extrusionAlongPathX	(	const SMESH::long_array &	IDsOfElements,
		SMESH::SMESH_IDSource_ptr	Path,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	LinearVariation,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint,
		bool	MakeGroups,
		const SMDSAbs_ElementType	ElementType,
		SMESH::SMESH_MeshEditor::Extrusion_Error &	theError
	)		[private]

Definition at line 2254 of file SMESH_MeshEditor_i.cxx.

References convExtrError(), SMESH.SMESH_MeshEditor.EXTR_BAD_PATH_SHAPE, SMESH.SMESH_MeshEditor.EXTR_BAD_STARTING_NODE, PAL_MESH_041_mesh.mesh, SMDSAbs_All, SMDSAbs_Face, SMDSAbs_Volume, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  SMESH::ListOfGroups* EmptyGr = new SMESH::ListOfGroups;

  initData();

  list<double> angles;
  for (int i = 0; i < Angles.length(); i++) {
    angles.push_back( Angles[i] );
  }
  gp_Pnt refPnt( RefPoint.x, RefPoint.y, RefPoint.z );
  int nbOldGroups = myMesh->NbGroup();

  if ( Path->_is_nil() ) {
    Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
    return EmptyGr;
  }

  TIDSortedElemSet elements, copyElements;
  arrayToSet(IDsOfElements, GetMeshDS(), elements, ElementType);

  TIDSortedElemSet* workElements = &elements;
  TPreviewMesh      tmpMesh( SMDSAbs_Face );
  SMESH_Mesh*       mesh = myMesh;

  if ( myPreviewMode )
  {
    SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
    tmpMesh.Copy( elements, copyElements, select, avoid );
    mesh = &tmpMesh;
    workElements = & copyElements;
    MakeGroups = false;
  }

  ::SMESH_MeshEditor anEditor( mesh );
  ::SMESH_MeshEditor::Extrusion_Error error;

  if ( SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( Path ))
  {
    // path as mesh
    SMDS_MeshNode* aNodeStart =
      (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart);
    if ( !aNodeStart ) {
      Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
      return EmptyGr;
    }
    error = anEditor.ExtrusionAlongTrack( *workElements, &(aMeshImp->GetImpl()), aNodeStart,
                                          HasAngles, angles, LinearVariation,
                                          HasRefPoint, refPnt, MakeGroups );
    myMesh->GetMeshDS()->Modified();
  }
  else if ( SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast<SMESH_subMesh_i*>( Path ))
  {
    // path as submesh
    SMESH::SMESH_Mesh_ptr aPathMesh = aSubMeshImp->GetFather();
    aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( aPathMesh );
    SMDS_MeshNode* aNodeStart =
      (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart);
    if ( !aNodeStart ) {
      Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
      return EmptyGr;
    }
    SMESH_subMesh* aSubMesh =
      aMeshImp->GetImpl().GetSubMeshContaining(aSubMeshImp->GetId());
    error = anEditor.ExtrusionAlongTrack( *workElements, aSubMesh, aNodeStart,
                                          HasAngles, angles, LinearVariation,
                                          HasRefPoint, refPnt, MakeGroups );
    myMesh->GetMeshDS()->Modified();
  }
  else if ( SMESH::DownCast<SMESH_Group_i*>( Path ))
  {
    // path as group of 1D elements
    // ????????
  }
  else
  {
    // invalid path
    Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
    return EmptyGr;
  }

  storeResult(anEditor);
  Error = convExtrError( error );

  if ( MakeGroups ) {
    list<int> groupIDs = myMesh->GetGroupIds();
    list<int>::iterator newBegin = groupIDs.begin();
    std::advance( newBegin, nbOldGroups ); // skip old groups
    groupIDs.erase( groupIDs.begin(), newBegin );
    return getGroups( & groupIDs );
  }
  return EmptyGr;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ExtrusionAlongPathX	(	const SMESH::long_array &	IDsOfElements,
		SMESH::SMESH_IDSource_ptr	Path,
		CORBA::Long	NodeStart,
		CORBA::Boolean	HasAngles,
		const SMESH::double_array &	Angles,
		CORBA::Boolean	LinearVariation,
		CORBA::Boolean	HasRefPoint,
		const SMESH::PointStruct &	RefPoint,
		CORBA::Boolean	MakeGroups,
		SMESH::ElementType	ElemType,
		SMESH::SMESH_MeshEditor::Extrusion_Error &	Error
	)

Definition at line 2806 of file SMESH_MeshEditor_i.cxx.

References SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups * aGroups = extrusionAlongPathX(IDsOfElements,
                                                      Path,
                                                      NodeStart,
                                                      HasAngles,
                                                      Angles,
                                                      LinearVariation,
                                                      HasRefPoint,
                                                      RefPoint,
                                                      MakeGroups,
                                                      (SMDSAbs_ElementType)ElemType,
                                                      Error);

  if (!myPreviewMode) {
    bool isDumpGroups = aGroups && aGroups->length() > 0;
    if (isDumpGroups)
      aPythonDump << "(" << *aGroups << ", error)";
    else
      aPythonDump <<"error";

    aPythonDump << " = " << this << ".ExtrusionAlongPathX( "
                << IDsOfElements << ", "
                << Path        << ", "
                << NodeStart   << ", "
                << HasAngles   << ", "
                << Angles      << ", "
                << LinearVariation << ", "
                << HasRefPoint << ", "
                << "SMESH.PointStruct( "
                << ( HasRefPoint ? RefPoint.x : 0 ) << ", "
                << ( HasRefPoint ? RefPoint.y : 0 ) << ", "
                << ( HasRefPoint ? RefPoint.z : 0 ) << " ), "
                << MakeGroups << ", "
                << ElemType << " )";
  }
  return aGroups;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::extrusionSweep	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::DirStruct &	StepVector,
		CORBA::Long	NbOfSteps,
		bool	MakeGroups,
		const SMDSAbs_ElementType	ElementType = SMDSAbs_All
	)		[private]

Definition at line 1852 of file SMESH_MeshEditor_i.cxx.

References Handle(), PAL_MESH_041_mesh.mesh, SMESH.DirStruct.PS, SMDSAbs_All, SMDSAbs_Face, SMDSAbs_Volume, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  initData();

  try {
#ifdef NO_CAS_CATCH
    OCC_CATCH_SIGNALS;
#endif
    TIDSortedElemSet elements, copyElements;
    arrayToSet(theIDsOfElements, GetMeshDS(), elements, theElementType);

    const SMESH::PointStruct * P = &theStepVector.PS;
    gp_Vec stepVec( P->x, P->y, P->z );

    TIDSortedElemSet* workElements = & elements;
    TPreviewMesh      tmpMesh( SMDSAbs_Face );
    SMESH_Mesh*       mesh = myMesh;
    
    if ( myPreviewMode ) {
      SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
      tmpMesh.Copy( elements, copyElements, select, avoid );
      mesh = &tmpMesh;
      workElements = & copyElements;
      theMakeGroups = false;
    }

    TElemOfElemListMap aHystory;
    ::SMESH_MeshEditor anEditor( mesh );
    ::SMESH_MeshEditor::PGroupIDs groupIds =
        anEditor.ExtrusionSweep (*workElements, stepVec, theNbOfSteps, aHystory, theMakeGroups);

    myMesh->GetMeshDS()->Modified();
    storeResult(anEditor);

    return theMakeGroups ? getGroups(groupIds.get()) : 0;

  } catch(Standard_Failure) {
    Handle(Standard_Failure) aFail = Standard_Failure::Caught();
    INFOS( "SMESH_MeshEditor_i::ExtrusionSweep fails - "<< aFail->GetMessageString() );
  }
  return 0;
}

void SMESH_MeshEditor_i::ExtrusionSweep	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::DirStruct &	StepVector,
		CORBA::Long	NbOfSteps
	)

Definition at line 1904 of file SMESH_MeshEditor_i.cxx.

{
  extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false );
  if (!myPreviewMode) {
    TPythonDump() << this << ".ExtrusionSweep( "
                  << theIDsOfElements << ", " << theStepVector <<", " << theNbOfSteps << " )";
  }
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ExtrusionSweepMakeGroups	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::DirStruct &	StepVector,
		CORBA::Long	NbOfSteps
	)

Definition at line 1973 of file SMESH_MeshEditor_i.cxx.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups* aGroups = extrusionSweep(theIDsOfElements, theStepVector, theNbOfSteps, true);

  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".ExtrusionSweepMakeGroups( " << theIDsOfElements
                << ", " << theStepVector <<", " << theNbOfSteps << " )";
  }
  return aGroups;
}

void SMESH_MeshEditor_i::ExtrusionSweepObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::DirStruct &	StepVector,
		CORBA::Long	NbOfSteps
	)

Definition at line 1921 of file SMESH_MeshEditor_i.cxx.

{
  SMESH::long_array_var anElementsId = theObject->GetIDs();
  extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false );
  if (!myPreviewMode) {
    TPythonDump() << this << ".ExtrusionSweepObject( "
                  << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
  }
}

void SMESH_MeshEditor_i::ExtrusionSweepObject1D	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::DirStruct &	StepVector,
		CORBA::Long	NbOfSteps
	)

Definition at line 1938 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Edge.

{
  SMESH::long_array_var anElementsId = theObject->GetIDs();
  extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Edge );
  if ( !myPreviewMode ) {
    TPythonDump() << this << ".ExtrusionSweepObject1D( "
                  << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
  }
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ExtrusionSweepObject1DMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::DirStruct &	StepVector,
		CORBA::Long	NbOfSteps
	)

Definition at line 2018 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Edge.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
                                                 theNbOfSteps, true, SMDSAbs_Edge);
  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( " << theObject
                << ", " << theStepVector << ", " << theNbOfSteps << " )";
  }
  return aGroups;
}

void SMESH_MeshEditor_i::ExtrusionSweepObject2D	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::DirStruct &	StepVector,
		CORBA::Long	NbOfSteps
	)

Definition at line 1955 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Face.

{
  SMESH::long_array_var anElementsId = theObject->GetIDs();
  extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Face );
  if ( !myPreviewMode ) {
    TPythonDump() << this << ".ExtrusionSweepObject2D( "
                  << theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
  }
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ExtrusionSweepObject2DMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::DirStruct &	StepVector,
		CORBA::Long	NbOfSteps
	)

Definition at line 2041 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Face.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
                                                 theNbOfSteps, true, SMDSAbs_Face);
  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( " << theObject
                << ", " << theStepVector << ", " << theNbOfSteps << " )";
  }
  return aGroups;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ExtrusionSweepObjectMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::DirStruct &	StepVector,
		CORBA::Long	NbOfSteps
	)

Definition at line 1995 of file SMESH_MeshEditor_i.cxx.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector, theNbOfSteps, true);

  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".ExtrusionSweepObjectMakeGroups( " << theObject
                << ", " << theStepVector << ", " << theNbOfSteps << " )";
  }
  return aGroups;
}

void SMESH_MeshEditor_i::FindCoincidentNodes	(	CORBA::Double	Tolerance,
		SMESH::array_of_long_array_out	GroupsOfNodes
	)

Definition at line 3860 of file SMESH_MeshEditor_i.cxx.

References SMESH_controls.aGroup, and SMESH_AdvancedEditor.nodes.

{
  initData();

  ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
  ::SMESH_MeshEditor anEditor( myMesh );
  TIDSortedNodeSet nodes; // no input nodes
  anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );

  GroupsOfNodes = new SMESH::array_of_long_array;
  GroupsOfNodes->length( aListOfListOfNodes.size() );
  ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
  for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) {
    list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
    list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
    SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
    aGroup.length( aListOfNodes.size() );
    for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
      aGroup[ j ] = (*lIt)->GetID();
  }
  TPythonDump() << "coincident_nodes = " << this << ".FindCoincidentNodes( "
                << Tolerance << " )";
}

void SMESH_MeshEditor_i::FindCoincidentNodesOnPart	(	SMESH::SMESH_IDSource_ptr	Object,
		CORBA::Double	Tolerance,
		SMESH::array_of_long_array_out	GroupsOfNodes
	)

Definition at line 3889 of file SMESH_MeshEditor_i.cxx.

References SMESH_controls.aGroup, and SMESH_AdvancedEditor.nodes.

{
  initData();

  TIDSortedNodeSet nodes;
  idSourceToNodeSet( theObject, GetMeshDS(), nodes );

  ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
  ::SMESH_MeshEditor anEditor( myMesh );
  if(!nodes.empty())
    anEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );

  GroupsOfNodes = new SMESH::array_of_long_array;
  GroupsOfNodes->length( aListOfListOfNodes.size() );
  ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
  for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ )
  {
    list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
    list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
    SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
    aGroup.length( aListOfNodes.size() );
    for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
      aGroup[ j ] = (*lIt)->GetID();
  }
  TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPart( "
                <<theObject<<", "
                << Tolerance << " )";
}

void SMESH_MeshEditor_i::FindCoincidentNodesOnPartBut	(	SMESH::SMESH_IDSource_ptr	Object,
		CORBA::Double	Tolerance,
		SMESH::array_of_long_array_out	GroupsOfNodes,
		const SMESH::ListOfIDSources &	ExceptSubMeshOrGroups
	)

Finds nodes coinsident with Tolerance within Object excluding nodes within ExceptSubMeshOrGroups.

Definition at line 3928 of file SMESH_MeshEditor_i.cxx.

References SMESH_controls.aGroup, and SMESH_AdvancedEditor.nodes.

{
  initData();

  TIDSortedNodeSet nodes;
  idSourceToNodeSet( theObject, GetMeshDS(), nodes );

  for ( int i = 0; i < theExceptSubMeshOrGroups.length(); ++i )
  {
    TIDSortedNodeSet exceptNodes;
    idSourceToNodeSet( theExceptSubMeshOrGroups[i], GetMeshDS(), exceptNodes );
    TIDSortedNodeSet::iterator avoidNode = exceptNodes.begin();
    for ( ; avoidNode != exceptNodes.end(); ++avoidNode)
      nodes.erase( *avoidNode );
  }
  ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
  ::SMESH_MeshEditor anEditor( myMesh );
  if(!nodes.empty())
    anEditor.FindCoincidentNodes( nodes, theTolerance, aListOfListOfNodes );

  theGroupsOfNodes = new SMESH::array_of_long_array;
  theGroupsOfNodes->length( aListOfListOfNodes.size() );
  ::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
  for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ )
  {
    list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
    list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
    SMESH::long_array& aGroup = (*theGroupsOfNodes)[ i ];
    aGroup.length( aListOfNodes.size() );
    for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
      aGroup[ j ] = (*lIt)->GetID();
  }
  TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPartBut( "
                << theObject<<", "
                << theTolerance << ", "
                << theExceptSubMeshOrGroups << " )";
}

SMESH::long_array * SMESH_MeshEditor_i::FindElementsByPoint	(	CORBA::Double	x,
		CORBA::Double	y,
		CORBA::Double	z,
		SMESH::ElementType	type
	)

Return elements of given type where the given point is IN or ON.

'ALL' type means elements of any type excluding nodes

Definition at line 4272 of file SMESH_MeshEditor_i.cxx.

References SMESH_AdvancedEditor.res.

{
  SMESH::long_array_var res = new SMESH::long_array;
  vector< const SMDS_MeshElement* > foundElems;

  theSearchersDeleter.Set( myMesh );
  if ( !theElementSearcher ) {
    ::SMESH_MeshEditor anEditor( myMesh );
    theElementSearcher = anEditor.GetElementSearcher();
  }
  theElementSearcher->FindElementsByPoint( gp_Pnt( x,y,z ),
                                           SMDSAbs_ElementType( type ),
                                           foundElems);
  res->length( foundElems.size() );
  for ( int i = 0; i < foundElems.size(); ++i )
    res[i] = foundElems[i]->GetID();

  if ( !myPreviewMode ) // call from tui
    TPythonDump() << res << " = " << this << ".FindElementsByPoint( "
                  << x << ", "
                  << y << ", "
                  << z << ", "
                  << type << " )";

  return res._retn();
}

void SMESH_MeshEditor_i::FindEqualElements	(	SMESH::SMESH_IDSource_ptr	Object,
		SMESH::array_of_long_array_out	GroupsOfElementsID
	)

Definition at line 4013 of file SMESH_MeshEditor_i.cxx.

References SMESH_controls.aGroup, SMDS_Mesh.FindElement(), ex21_lamp.group, and SMESH.NODE.

{
  initData();

  SMESH::SMESH_GroupBase_var group = SMESH::SMESH_GroupBase::_narrow(theObject);
  if ( !(!group->_is_nil() && group->GetType() == SMESH::NODE) )
  {
    typedef list<int> TListOfIDs;
    set<const SMDS_MeshElement*> elems;
    SMESH::long_array_var aElementsId = theObject->GetIDs();
    SMESHDS_Mesh* aMesh = GetMeshDS();

    for(int i = 0; i < aElementsId->length(); i++) {
      CORBA::Long anID = aElementsId[i];
      const SMDS_MeshElement * elem = aMesh->FindElement(anID);
      if (elem) {
        elems.insert(elem);
      }
    }

    ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
    ::SMESH_MeshEditor anEditor( myMesh );
    anEditor.FindEqualElements( elems, aListOfListOfElementsID );

    GroupsOfElementsID = new SMESH::array_of_long_array;
    GroupsOfElementsID->length( aListOfListOfElementsID.size() );

    ::SMESH_MeshEditor::TListOfListOfElementsID::iterator arraysIt = aListOfListOfElementsID.begin();
    for (CORBA::Long j = 0; arraysIt != aListOfListOfElementsID.end(); ++arraysIt, ++j) {
      SMESH::long_array& aGroup = (*GroupsOfElementsID)[ j ];
      TListOfIDs& listOfIDs = *arraysIt;
      aGroup.length( listOfIDs.size() );
      TListOfIDs::iterator idIt = listOfIDs.begin();
      for (int k = 0; idIt != listOfIDs.end(); ++idIt, ++k ) {
        aGroup[ k ] = *idIt;
      }
    }

    TPythonDump() << "equal_elements = " << this << ".FindEqualElements( "
                  <<theObject<<" )";
  }
}

CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo	(	CORBA::Double	x,
		CORBA::Double	y,
		CORBA::Double	z
	)

Return ID of node closest to a given point.

Definition at line 4171 of file SMESH_MeshEditor_i.cxx.

References ex29_refine.node().

{
  theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other

  if ( !theNodeSearcher ) {
    ::SMESH_MeshEditor anEditor( myMesh );
    theNodeSearcher = anEditor.GetNodeSearcher();
  }
  gp_Pnt p( x,y,z );
  if ( const SMDS_MeshNode* node = theNodeSearcher->FindClosestTo( p ))
    return node->GetID();

  return 0;
}

string SMESH_MeshEditor_i::generateGroupName

(

const string &

thePrefix

)

[private]

Generates the unique group name.

Parameters:

thePrefix

name prefix

Returns:

unique name

Definition at line 4903 of file SMESH_MeshEditor_i.cxx.

References SMESH_controls.aGroup, and ex21_lamp.name.

{
  SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
  set<string> groupNames;

  // Get existing group names
  for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {
    SMESH::SMESH_GroupBase_var aGroup = groups[i];
    if (CORBA::is_nil(aGroup))
      continue;

    groupNames.insert(aGroup->GetName());
  }

  // Find new name
  string name = thePrefix;
  int index = 0;

  while (!groupNames.insert(name).second) {
    if (index == 0) {
      name += "_1";
    }
    else {
      TCollection_AsciiString nbStr(index+1);
      name.resize( name.rfind('_')+1 );
      name += nbStr.ToCString();
    }
    ++index;
  }

  return name;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::getGroups

(

const std::list< int > *

groupIDs

)

[private]

Return groups by their IDs.

Definition at line 1540 of file SMESH_MeshEditor_i.cxx.

{
  if ( !groupIDs )
    return 0;
  myMesh_i->CreateGroupServants();
  return myMesh_i->GetGroups( *groupIDs );
}

SMESH::long_array * SMESH_MeshEditor_i::GetLastCreatedElems

(

)

If during last operation of MeshEditor some elements were created this method returns list of it's IDs, if new elements not creared - returns empty list.

Returns list of it's IDs of created elements.

Return values:

SMESH.long_array*

- list of elements' ID

Definition at line 4763 of file SMESH_MeshEditor_i.cxx.

{
  return myLastCreatedElems._retn();
}

SMESH::long_array * SMESH_MeshEditor_i::GetLastCreatedNodes

(

)

If during last operation of MeshEditor some nodes were created this method returns list of it's IDs, if new nodes not creared - returns empty list.

Returns list of it's IDs of created nodes.

Return values:

SMESH.long_array*

- list of node ID

Definition at line 4751 of file SMESH_MeshEditor_i.cxx.

{
  return myLastCreatedNodes._retn();
}

SMESHDS_Mesh* SMESH_MeshEditor_i.GetMeshDS

(

)

[private]

< private methods

Definition at line 744 of file SMESH_MeshEditor_i.hxx.

References SMESH_Mesh.GetMeshDS(), and myMesh.

{ return myMesh->GetMeshDS(); }

int SMESH_MeshEditor_i.GetMeshId

(

)

const

Return edited mesh ID.

Return values:

int

- mesh ID

Definition at line 554 of file SMESH_MeshEditor_i.hxx.

References SMESH_Mesh.GetId(), and myMesh.

Referenced by SMESH.TPythonDump.operator<<().

{ return myMesh->GetId(); }

CORBA::Short SMESH_MeshEditor_i::GetPointState	(	CORBA::Double	x,
		CORBA::Double	y,
		CORBA::Double	z
	)

Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.

TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.

Definition at line 4308 of file SMESH_MeshEditor_i.cxx.

{
  theSearchersDeleter.Set( myMesh );
  if ( !theElementSearcher ) {
    ::SMESH_MeshEditor anEditor( myMesh );
    theElementSearcher = anEditor.GetElementSearcher();
  }
  return CORBA::Short( theElementSearcher->GetPointState( gp_Pnt( x,y,z )));
}

SMESH::MeshPreviewStruct * SMESH_MeshEditor_i::GetPreviewData

(

)

Return data of mesh edition preview.

Definition at line 4739 of file SMESH_MeshEditor_i.cxx.

{
  return myPreviewData._retn();
}

void SMESH_MeshEditor_i::initData

(

bool

deleteSearchers = true

)

[private]

Clear myLastCreated* or myPreviewData.

Clear members.

Definition at line 402 of file SMESH_MeshEditor_i.cxx.

{
  if ( myPreviewMode ) {
    myPreviewData = new SMESH::MeshPreviewStruct();
  }
  else {
    myLastCreatedElems = new SMESH::long_array();
    myLastCreatedNodes = new SMESH::long_array();
    if ( deleteSearchers )
      TSearchersDeleter::Delete();
  }
}

CORBA::Boolean SMESH_MeshEditor_i::InverseDiag	(	CORBA::Long	NodeID1,
		CORBA::Long	NodeID2
	)

Definition at line 1002 of file SMESH_MeshEditor_i.cxx.

References SMESH_AdvancedEditor.n1, SMESH_AdvancedEditor.n2, and PAL_MESH_041_mesh.ret.

{
  initData();

  const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
  const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
  if ( !n1 || !n2 )
    return false;

  // Update Python script
  TPythonDump() << "isDone = " << this << ".InverseDiag( "
                << NodeID1 << ", " << NodeID2 << " )";


  ::SMESH_MeshEditor aMeshEditor( myMesh );
  int ret =  aMeshEditor.InverseDiag ( n1, n2 );
  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true );
  return ret;
}

SMESH::double_array * SMESH_MeshEditor_i::LinearAnglesVariation	(	SMESH::SMESH_Mesh_ptr	thePathMesh,
		GEOM::GEOM_Object_ptr	thePathShape,
		const SMESH::double_array &	theAngles
	)

Compute rotation angles for ExtrusionAlongPath as linear variation of given angles along path steps.

Parameters:

PathMesh	mesh containing a 1D sub-mesh on the edge, along which proceeds the extrusion
PathShape	is shape(edge); as the mesh can be complex, the edge is used to define the sub-mesh for the path

Definition at line 2870 of file SMESH_MeshEditor_i.cxx.

References SMESH_demo_hexa2_upd.angle, SMESH_fixation.aShape, SMESH_Gen_i.GeomObjectToShape(), SMESH_Mesh_i.GetImpl(), and SMESH_Gen_i.GetSMESHGen().

{
  SMESH::double_array_var aResult = new SMESH::double_array();
  int nbAngles = theAngles.length();
  if ( nbAngles > 0 && !thePathMesh->_is_nil() && !thePathShape->_is_nil() )
  {
    SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
    TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
    SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
    if ( !aSubMesh || !aSubMesh->GetSubMeshDS())
      return aResult._retn();
    int nbSteps = aSubMesh->GetSubMeshDS()->NbElements();
    if ( nbSteps == nbAngles )
    {
      aResult.inout() = theAngles;
    }
    else
    {
      aResult->length( nbSteps );
      double rAn2St = double( nbAngles ) / double( nbSteps );
      double angPrev = 0, angle;
      for ( int iSt = 0; iSt < nbSteps; ++iSt )
      {
        double angCur = rAn2St * ( iSt+1 );
        double angCurFloor  = floor( angCur );
        double angPrevFloor = floor( angPrev );
        if ( angPrevFloor == angCurFloor )
          angle = rAn2St * theAngles[ int( angCurFloor ) ];
        else
        {
          int iP = int( angPrevFloor );
          double angPrevCeil = ceil(angPrev);
          angle = ( angPrevCeil - angPrev ) * theAngles[ iP ];

          int iC = int( angCurFloor );
          if ( iC < nbAngles )
            angle += ( angCur - angCurFloor ) * theAngles[ iC ];

          iP = int( angPrevCeil );
          while ( iC-- > iP )
            angle += theAngles[ iC ];
        }
        aResult[ iSt ] = angle;
        angPrev = angCur;
      }
    }
  }
  // Update Python script
  TPythonDump() << "rotAngles = " << theAngles;
  TPythonDump() << "rotAngles = " << this << ".LinearAnglesVariation( "
                << thePathMesh  << ", "
                << thePathShape << ", "
                << "rotAngles )";

  return aResult._retn();
}

CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D

(

)

Generated skin mesh (containing 2D cells) from 3D mesh The created 2D mesh elements based on nodes of free faces of boundary volumes.

Returns:

TRUE if operation has been completed successfully, FALSE otherwise

Definition at line 5573 of file SMESH_MeshEditor_i.cxx.

{
  initData();

  ::SMESH_MeshEditor aMeshEditor( myMesh );
  bool aResult = aMeshEditor.Make2DMeshFrom3D();
  storeResult( aMeshEditor) ;
  myMesh->GetMeshDS()->Modified();
  TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()";
  return aResult;
}

CORBA::Long SMESH_MeshEditor_i::MakeBoundaryElements	(	SMESH::Bnd_Dimension	dim,
		const char *	groupName,
		const char *	meshName,
		CORBA::Boolean	toCopyAll,
		const SMESH::ListOfIDSources &	groups,
		SMESH::SMESH_Mesh_out	mesh,
		SMESH::SMESH_Group_out	group
	)		throw (SALOME::SALOME_Exception)

Creates missing boundary elements.

Parameters:

dimension	- defines type of boundary elements to create
groupName	- a name of group to store all boundary elements in, "" means not to create the group
meshName	- a name of a new mesh, which is a copy of the initial mesh + created boundary elements; "" means not to create the new mesh
toCopyAll	- if true, the whole initial mesh will be copied into the new mesh else only boundary elements will be copied into the new mesh
groups	- optional groups of elements to make boundary around
mesh	- returns the mesh where elements were added to
group	- returns the created group, if any

Return values:

long	- number of added boundary elements

Definition at line 5795 of file SMESH_MeshEditor_i.cxx.

References SMESH.BND_1DFROM2D, SMESH.BND_2DFROM3D, SMESH_Gen_i.CopyMesh(), SMESH_Mesh_i.CreateGroup(), SMESH_Mesh_i.GetImpl(), SMESH_Gen_i.GetSMESHGen(), ex21_lamp.group, ex30_tepal.m, PAL_MESH_041_mesh.mesh, SMDSAbs_Face, and SMDSAbs_Volume.

{
  Unexpect aCatch(SALOME_SalomeException);

  initData();

  if ( dim > SMESH::BND_1DFROM2D )
    THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);

  // separate groups belonging to this and other mesh
  SMESH::ListOfIDSources_var groupsOfThisMesh = new SMESH::ListOfIDSources;
  SMESH::ListOfIDSources_var groupsOfOtherMesh = new SMESH::ListOfIDSources;
  groupsOfThisMesh->length( groups.length() );
  groupsOfOtherMesh->length( groups.length() );
  int nbGroups = 0, nbGroupsOfOtherMesh = 0;
  for ( int i = 0; i < groups.length(); ++i )
  {
    SMESH::SMESH_Mesh_var m = groups[i]->GetMesh();
    if ( myMesh_i != SMESH::DownCast<SMESH_Mesh_i*>( m ))
      groupsOfOtherMesh[ nbGroupsOfOtherMesh++ ] = groups[i];
    else
      groupsOfThisMesh[ nbGroups++ ] = groups[i];
    if ( SMESH::DownCast<SMESH_Mesh_i*>( groups[i] ))
      THROW_SALOME_CORBA_EXCEPTION("expect a group but recieve a mesh", SALOME::BAD_PARAM);
  }
  groupsOfThisMesh->length( nbGroups );
  groupsOfOtherMesh->length( nbGroupsOfOtherMesh );

  int nbAdded = 0;
  TPythonDump pyDump;

  if ( nbGroupsOfOtherMesh > 0 )
  {
    // process groups belonging to another mesh
    SMESH::SMESH_Mesh_var    otherMesh = groupsOfOtherMesh[0]->GetMesh();
    SMESH::SMESH_MeshEditor_var editor = otherMesh->GetMeshEditor();
    nbAdded += editor->MakeBoundaryElements( dim, groupName, meshName, toCopyAll,
                                             groupsOfOtherMesh, mesh, group );
  }

  SMESH::SMESH_Mesh_var mesh_var;
  SMESH::SMESH_Group_var group_var;

  // get mesh to fill
  mesh_var = SMESH::SMESH_Mesh::_duplicate( myMesh_i->_this() );
  const bool toCopyMesh = ( strlen( meshName ) > 0 );
  if ( toCopyMesh )
  {
    if ( toCopyAll )
      mesh_var = SMESH_Gen_i::GetSMESHGen()->CopyMesh(mesh_var,
                                                      meshName,
                                                      /*toCopyGroups=*/false,
                                                      /*toKeepIDs=*/true);
    else
      mesh_var = makeMesh(meshName);
  }
  SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh_var );
  SMESH_Mesh*  tgtMesh = &mesh_i->GetImpl();

  // source mesh
  SMESH_Mesh*     srcMesh = ( toCopyMesh && !toCopyAll ) ? myMesh : tgtMesh;
  SMESHDS_Mesh* srcMeshDS = srcMesh->GetMeshDS();

  // group of boundary elements
  SMESH_Group* smesh_group = 0;
  SMDSAbs_ElementType elemType = (dim == SMESH::BND_2DFROM3D) ? SMDSAbs_Volume : SMDSAbs_Face;
  if ( strlen(groupName) )
  {
    SMESH::ElementType groupType = SMESH::ElementType( int(elemType)-1 );
    group_var = mesh_i->CreateGroup( groupType, groupName );
    if ( SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>( group_var ))
      smesh_group = group_i->GetSmeshGroup();
  }

  TIDSortedElemSet elements;

  if ( groups.length() > 0 )
  {
    for ( int i = 0; i < nbGroups; ++i )
    {
      elements.clear();
      if ( idSourceToSet( groupsOfThisMesh[i], srcMeshDS, elements, elemType,/*emptyIfIsMesh=*/0 ))
      {
        SMESH::Bnd_Dimension bdim = 
          ( elemType == SMDSAbs_Volume ) ? SMESH::BND_2DFROM3D : SMESH::BND_1DFROM2D;
        ::SMESH_MeshEditor aMeshEditor( srcMesh );
        nbAdded += aMeshEditor.MakeBoundaryMesh( elements,
                                                 ::SMESH_MeshEditor::Bnd_Dimension(bdim),
                                                 smesh_group,
                                                 tgtMesh,
                                                 /*toCopyElements=*/false,
                                                 /*toCopyExistingBondary=*/srcMesh != tgtMesh,
                                                 /*toAddExistingBondary=*/true,
                                                 /*aroundElements=*/true);
        storeResult( aMeshEditor );
      }
    }
  }
  else
  {
    ::SMESH_MeshEditor aMeshEditor( srcMesh );
    nbAdded += aMeshEditor.MakeBoundaryMesh( elements,
                                             ::SMESH_MeshEditor::Bnd_Dimension(dim),
                                             smesh_group,
                                             tgtMesh,
                                             /*toCopyElements=*/false,
                                             /*toCopyExistingBondary=*/srcMesh != tgtMesh,
                                             /*toAddExistingBondary=*/true);
    storeResult( aMeshEditor );
  }
  tgtMesh->GetMeshDS()->Modified();

  const char* dimName[] = { "BND_2DFROM3D", "BND_1DFROM3D", "BND_1DFROM2D" };

  // result of MakeBoundaryElements() is a tuple (nb, mesh, group)
  pyDump << "nbAdded, ";
  if ( mesh_var->_is_nil() )
    pyDump << myMesh_i->_this() << ", ";
  else
    pyDump << mesh_var << ", ";
  if ( group_var->_is_nil() )
    pyDump << "_NoneGroup = "; // assignment to None is forbiden
  else
    pyDump << group_var << " = ";
  pyDump << this << ".MakeBoundaryElements( "
         << "SMESH." << dimName[int(dim)] << ", "
         << "'" << groupName << "', "
         << "'" << meshName<< "', "
         << toCopyAll << ", "
         << groups << ")";

  mesh  = mesh_var._retn();
  group = group_var._retn();
  return nbAdded;
}

SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::MakeBoundaryMesh	(	SMESH::SMESH_IDSource_ptr	idSource,
		SMESH::Bnd_Dimension	dim,
		const char *	groupName,
		const char *	meshName,
		CORBA::Boolean	toCopyElements,
		CORBA::Boolean	toCopyExistingBondary,
		SMESH::SMESH_Group_out	group
	)

Creates missing boundary elements.

Parameters:

elements	- elements whose boundary is to be checked
dimension	- defines type of boundary elements to create
groupName	- a name of group to store created boundary elements in, "" means not to create the group
meshName	- a name of new mesh to store created boundary elements in, "" means not to create the new mesh
toCopyElements	- if true, the checked elements will be copied into the new mesh
toCopyExistingBondary	- if true, not only new but also pre-existing boundary elements will be copied into the new mesh
group	- returns the create group, if any

Return values:

SMESH.SMESH_Mesh

- the mesh where elements were added to

Definition at line 5701 of file SMESH_MeshEditor_i.cxx.

References SMESH.BND_1DFROM2D, SMDSAbs_Face, and SMDSAbs_Volume.

{
  initData();

  if ( dim > SMESH::BND_1DFROM2D )
    THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);

  SMESHDS_Mesh* aMeshDS = GetMeshDS();

  SMESH::SMESH_Mesh_var mesh_var;
  SMESH::SMESH_Group_var group_var;

  TPythonDump pyDump;

  TIDSortedElemSet elements;
  SMDSAbs_ElementType elemType = (dim == SMESH::BND_1DFROM2D) ? SMDSAbs_Face : SMDSAbs_Volume;
  if ( idSourceToSet( idSource, aMeshDS, elements, elemType,/*emptyIfIsMesh=*/true ))
  {
    // mesh to fill in
    mesh_var =
      strlen(meshName) ? makeMesh(meshName) : SMESH::SMESH_Mesh::_duplicate(myMesh_i->_this());
    SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh_var );
    // other mesh
    SMESH_Mesh* smesh_mesh = (mesh_i==myMesh_i) ? (SMESH_Mesh*)0 : &mesh_i->GetImpl();

    // group of new boundary elements
    SMESH_Group* smesh_group = 0;
    if ( strlen(groupName) )
    {
      group_var = mesh_i->CreateGroup( SMESH::ElementType(int(elemType)-1),groupName);
      if ( SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>( group_var ))
        smesh_group = group_i->GetSmeshGroup();
    }

    // do it
    ::SMESH_MeshEditor aMeshEditor( myMesh );
    aMeshEditor.MakeBoundaryMesh( elements,
                                  ::SMESH_MeshEditor::Bnd_Dimension(dim),
                                  smesh_group,
                                  smesh_mesh,
                                  toCopyElements,
                                  toCopyExistingBondary);
    storeResult( aMeshEditor );

    if ( smesh_mesh )
      smesh_mesh->GetMeshDS()->Modified();
  }

  const char* dimName[] = { "BND_2DFROM3D", "BND_1DFROM3D", "BND_1DFROM2D" };

  // result of MakeBoundaryMesh() is a tuple (mesh, group)
  if ( mesh_var->_is_nil() )
    pyDump << myMesh_i->_this() << ", ";
  else
    pyDump << mesh_var << ", ";
  if ( group_var->_is_nil() )
    pyDump << "_NoneGroup = "; // assignment to None is forbiden
  else
    pyDump << group_var << " = ";
  pyDump << this << ".MakeBoundaryMesh( "
         << idSource << ", "
         << "SMESH." << dimName[int(dim)] << ", "
         << "'" << groupName << "', "
         << "'" << meshName<< "', "
         << toCopyElements << ", "
         << toCopyExistingBondary << ")";

  group = group_var._retn();
  return mesh_var._retn();
}

SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource	(	const SMESH::long_array &	IDsOfElements,
		SMESH::ElementType	type
	)

Wrap a sequence of ids in a SMESH_IDSource.

Definition at line 439 of file SMESH_MeshEditor_i.cxx.

References _IDSource._ids, _IDSource._mesh, _IDSource._type, and SMESH_test.ids.

{
  _IDSource* anIDSource = new _IDSource;
  anIDSource->_ids = ids;
  anIDSource->_type = type;
  anIDSource->_mesh = myMesh_i->_this();
  SMESH::SMESH_IDSource_var anIDSourceVar = anIDSource->_this();

  return anIDSourceVar._retn();
}

SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::makeMesh

(

const char *

theMeshName

)

[private]

Definition at line 4871 of file SMESH_MeshEditor_i.cxx.

References SMESH_Gen_i.CreateEmptyMesh(), SMESH_Gen_i.GetCurrentStudy(), SMESH_Gen_i.GetSMESHGen(), PAL_MESH_041_mesh.mesh, SMESH_Gen_i.ObjectToSObject(), SMESH_Gen_i.SetName(), and SMESH_Gen_i.SetPixMap().

{
  SMESH_Gen_i* gen = SMESH_Gen_i::GetSMESHGen();
  SMESH::SMESH_Mesh_var mesh = gen->CreateEmptyMesh();
  SALOMEDS::Study_var study = gen->GetCurrentStudy();
  SALOMEDS::SObject_var meshSO = gen->ObjectToSObject( study, mesh );
  gen->SetName( meshSO, theMeshName, "Mesh" );
  gen->SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");

  return mesh._retn();
}

void SMESH_MeshEditor_i::MergeElements

(

const SMESH::array_of_long_array &

GroupsOfElementsID

)

Definition at line 4062 of file SMESH_MeshEditor_i.cxx.

{
  initData();

  TPythonDump aTPythonDump;
  aTPythonDump << this << ".MergeElements( [";

  ::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;

  for (int i = 0; i < GroupsOfElementsID.length(); i++) {
    const SMESH::long_array& anElemsIDGroup = GroupsOfElementsID[ i ];
    aListOfListOfElementsID.push_back( list< int >() );
    list< int >& aListOfElemsID = aListOfListOfElementsID.back();
    for ( int j = 0; j < anElemsIDGroup.length(); j++ ) {
      CORBA::Long id = anElemsIDGroup[ j ];
      aListOfElemsID.push_back( id );
    }
    if ( aListOfElemsID.size() < 2 )
      aListOfListOfElementsID.pop_back();
    if ( i > 0 ) aTPythonDump << ", ";
    aTPythonDump << anElemsIDGroup;
  }

  ::SMESH_MeshEditor anEditor( myMesh );
  anEditor.MergeElements(aListOfListOfElementsID);
  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true );

  aTPythonDump << "] )";
}

void SMESH_MeshEditor_i::MergeEqualElements

(

)

Definition at line 4098 of file SMESH_MeshEditor_i.cxx.

{
  initData();

  ::SMESH_MeshEditor anEditor( myMesh );
  anEditor.MergeEqualElements();

  TPythonDump() << this << ".MergeEqualElements()";
}

void SMESH_MeshEditor_i::MergeNodes

(

const SMESH::array_of_long_array &

GroupsOfNodes

)

Definition at line 3974 of file SMESH_MeshEditor_i.cxx.

References SMDS_Mesh.FindNode(), and ex29_refine.node().

{
  initData();

  SMESHDS_Mesh* aMesh = GetMeshDS();

  TPythonDump aTPythonDump;
  aTPythonDump << this << ".MergeNodes([";
  ::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
  for (int i = 0; i < GroupsOfNodes.length(); i++)
  {
    const SMESH::long_array& aNodeGroup = GroupsOfNodes[ i ];
    aListOfListOfNodes.push_back( list< const SMDS_MeshNode* >() );
    list< const SMDS_MeshNode* >& aListOfNodes = aListOfListOfNodes.back();
    for ( int j = 0; j < aNodeGroup.length(); j++ )
    {
      CORBA::Long index = aNodeGroup[ j ];
      const SMDS_MeshNode * node = aMesh->FindNode(index);
      if ( node )
        aListOfNodes.push_back( node );
    }
    if ( aListOfNodes.size() < 2 )
      aListOfListOfNodes.pop_back();

    if ( i > 0 ) aTPythonDump << ", ";
    aTPythonDump << aNodeGroup;
  }
  ::SMESH_MeshEditor anEditor( myMesh );
  anEditor.MergeNodes( aListOfListOfNodes );

  aTPythonDump <<  "])";
  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true );
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::mirror	(	TIDSortedElemSet &	IDsOfElements,
		const SMESH::AxisStruct &	Axis,
		SMESH::SMESH_MeshEditor::MirrorType	MirrorType,
		CORBA::Boolean	Copy,
		bool	MakeGroups,
		::SMESH_Mesh *	TargetMesh = 0
	)		[private]

Definition at line 2936 of file SMESH_MeshEditor_i.cxx.

References SMESH.SMESH_MeshEditor.AXIS, PAL_MESH_041_mesh.mesh, SMESH.SMESH_MeshEditor.POINT, SMESH.AxisStruct.vx, SMESH.AxisStruct.vy, SMESH.AxisStruct.vz, SMESH.AxisStruct.x, SMESH.AxisStruct.y, and SMESH.AxisStruct.z.

{
  initData();

  gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
  gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );

  if ( theTargetMesh )
    theCopy = false;

  gp_Trsf aTrsf;
  switch ( theMirrorType ) {
  case  SMESH::SMESH_MeshEditor::POINT:
    aTrsf.SetMirror( P );
    break;
  case  SMESH::SMESH_MeshEditor::AXIS:
    aTrsf.SetMirror( gp_Ax1( P, V ));
    break;
  default:
    aTrsf.SetMirror( gp_Ax2( P, V ));
  }

  TIDSortedElemSet  copyElements;
  TPreviewMesh      tmpMesh;
  TIDSortedElemSet* workElements = & theElements;
  SMESH_Mesh*       mesh = myMesh;

  if ( myPreviewMode )
  {
    tmpMesh.Copy( theElements, copyElements);
    if ( !theCopy && !theTargetMesh )
    {
      TIDSortedElemSet elemsAround, elemsAroundCopy;
      getElementsAround( theElements, GetMeshDS(), elemsAround );
      tmpMesh.Copy( elemsAround, elemsAroundCopy);
    }
    mesh = &tmpMesh;
    workElements = & copyElements;
    theMakeGroups = false;
  }

  ::SMESH_MeshEditor anEditor( mesh );
  ::SMESH_MeshEditor::PGroupIDs groupIds =
      anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);

  if(theCopy || myPreviewMode)
    storeResult(anEditor);
  else
  {
    myMesh->SetIsModified( true );
    myMesh->GetMeshDS()->Modified();
  }
  return theMakeGroups ? getGroups(groupIds.get()) : 0;
}

void SMESH_MeshEditor_i::Mirror	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::AxisStruct &	Axis,
		SMESH::SMESH_MeshEditor::MirrorType	MirrorType,
		CORBA::Boolean	Copy
	)

Definition at line 3001 of file SMESH_MeshEditor_i.cxx.

{
  if ( !myPreviewMode ) {
    TPythonDump() << this << ".Mirror( "
                  << theIDsOfElements << ", "
                  << theAxis          << ", "
                  << mirrorTypeName(theMirrorType) << ", "
                  << theCopy          << " )";
  }
  if ( theIDsOfElements.length() > 0 )
  {
    TIDSortedElemSet elements;
    arrayToSet(theIDsOfElements, GetMeshDS(), elements);
    mirror(elements, theAxis, theMirrorType, theCopy, false);
  }
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::MirrorMakeGroups	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::AxisStruct &	Mirror,
		SMESH::SMESH_MeshEditor::MirrorType	MirrorType
	)

Definition at line 3053 of file SMESH_MeshEditor_i.cxx.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups * aGroups = 0;
  if ( theIDsOfElements.length() > 0 )
  {
    TIDSortedElemSet elements;
    arrayToSet(theIDsOfElements, GetMeshDS(), elements);
    aGroups = mirror(elements, theMirror, theMirrorType, true, true);
  }
  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".MirrorMakeGroups( "
                << theIDsOfElements << ", "
                << theMirror << ", "
                << mirrorTypeName(theMirrorType) << " )";
  }
  return aGroups;
}

SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::MirrorMakeMesh	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::AxisStruct &	Mirror,
		SMESH::SMESH_MeshEditor::MirrorType	MirrorType,
		CORBA::Boolean	CopyGroups,
		const char *	MeshName
	)

Definition at line 3110 of file SMESH_MeshEditor_i.cxx.

References SMESH_Mesh_i.CreateGroupServants(), SMESH_Mesh_i.GetGroups(), SMESH_Mesh_i.GetImpl(), and PAL_MESH_041_mesh.mesh.

{
  SMESH_Mesh_i* mesh_i;
  SMESH::SMESH_Mesh_var mesh;
  { // open new scope to dump "MakeMesh" command
    // and then "GetGroups" using SMESH_Mesh::GetGroups()

    TPythonDump pydump; // to prevent dump at mesh creation

    mesh = makeMesh( theMeshName );
    mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
    if (mesh_i && theIDsOfElements.length() > 0 )
    {
      TIDSortedElemSet elements;
      arrayToSet(theIDsOfElements, GetMeshDS(), elements);
      mirror(elements, theMirror, theMirrorType,
             false, theCopyGroups, & mesh_i->GetImpl());
      mesh_i->CreateGroupServants();
    }

    if (!myPreviewMode) {
      pydump << mesh << " = " << this << ".MirrorMakeMesh( "
             << theIDsOfElements << ", "
             << theMirror   << ", "
             << mirrorTypeName(theMirrorType) << ", "
             << theCopyGroups << ", '"
             << theMeshName << "' )";
    }
  }

  //dump "GetGroups"
  if (!myPreviewMode && mesh_i)
    mesh_i->GetGroups();

  return mesh._retn();
}

void SMESH_MeshEditor_i::MirrorObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::AxisStruct &	Axis,
		SMESH::SMESH_MeshEditor::MirrorType	MirrorType,
		CORBA::Boolean	Copy
	)

Definition at line 3027 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_All.

{
  if ( !myPreviewMode ) {
    TPythonDump() << this << ".MirrorObject( "
                  << theObject << ", "
                  << theAxis   << ", "
                  << mirrorTypeName(theMirrorType) << ", "
                  << theCopy   << " )";
  }
  TIDSortedElemSet elements;

  bool emptyIfIsMesh = myPreviewMode ? false : true;

  if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
    mirror(elements, theAxis, theMirrorType, theCopy, false);
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::MirrorObjectMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::AxisStruct &	Mirror,
		SMESH::SMESH_MeshEditor::MirrorType	MirrorType
	)

Definition at line 3082 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_All.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups * aGroups = 0;
  TIDSortedElemSet elements;
  if ( idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
    aGroups = mirror(elements, theMirror, theMirrorType, true, true);

  if (!myPreviewMode)
  {
    DumpGroupsList(aPythonDump,aGroups);
    aPythonDump << this << ".MirrorObjectMakeGroups( "
                << theObject << ", "
                << theMirror << ", "
                << mirrorTypeName(theMirrorType) << " )";
  }
  return aGroups;
}

SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::MirrorObjectMakeMesh	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::AxisStruct &	Mirror,
		SMESH::SMESH_MeshEditor::MirrorType	MirrorType,
		CORBA::Boolean	CopyGroups,
		const char *	MeshName
	)

Definition at line 3157 of file SMESH_MeshEditor_i.cxx.

References SMESH_Mesh_i.CreateGroupServants(), SMESH_Mesh_i.GetGroups(), SMESH_Mesh_i.GetImpl(), PAL_MESH_041_mesh.mesh, and SMDSAbs_All.

{
  SMESH_Mesh_i* mesh_i;
  SMESH::SMESH_Mesh_var mesh;
  { // open new scope to dump "MakeMesh" command
    // and then "GetGroups" using SMESH_Mesh::GetGroups()

    TPythonDump pydump; // to prevent dump at mesh creation

    mesh = makeMesh( theMeshName );
    mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
    TIDSortedElemSet elements;
    if ( mesh_i &&
         idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
    {
      mirror(elements, theMirror, theMirrorType,
             false, theCopyGroups, & mesh_i->GetImpl());
      mesh_i->CreateGroupServants();
    }
    if (!myPreviewMode) {
      pydump << mesh << " = " << this << ".MirrorObjectMakeMesh( "
             << theObject << ", "
             << theMirror   << ", "
             << mirrorTypeName(theMirrorType) << ", "
             << theCopyGroups << ", '"
             << theMeshName << "' )";
    }
  }

  //dump "GetGroups"
  if (!myPreviewMode && mesh_i)
    mesh_i->GetGroups();

  return mesh._retn();
}

CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint	(	CORBA::Double	x,
		CORBA::Double	y,
		CORBA::Double	z,
		CORBA::Long	nodeID
	)

If the given ID is a valid node ID (nodeID > 0), just move this node, else move the node closest to the point to point's location and return ID of the node.

Definition at line 4195 of file SMESH_MeshEditor_i.cxx.

References cast2Node, SMESH_test.edge, SMDS_MeshElement.GetID(), SMESH_MeshEditor.GetLinkedNodes(), and ex29_refine.node().

{
  // We keep theNodeSearcher until any mesh modification:
  // 1) initData() deletes theNodeSearcher at any edition,
  // 2) TSearchersDeleter - at any mesh compute event and mesh change

  initData(/*deleteSearchers=*/false);

  theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other

  int nodeID = theNodeID;
  const SMDS_MeshNode* node = GetMeshDS()->FindNode( nodeID );
  if ( !node ) // preview moving node
  {
    if ( !theNodeSearcher ) {
      ::SMESH_MeshEditor anEditor( myMesh );
      theNodeSearcher = anEditor.GetNodeSearcher();
    }
    gp_Pnt p( x,y,z );
    node = theNodeSearcher->FindClosestTo( p );
  }
  if ( node ) {
    nodeID = node->GetID();
    if ( myPreviewMode ) // make preview data
    {
      // in a preview mesh, make edges linked to a node
      TPreviewMesh tmpMesh;
      TIDSortedElemSet linkedNodes;
      ::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
      TIDSortedElemSet::iterator nIt = linkedNodes.begin();
      for ( ; nIt != linkedNodes.end(); ++nIt )
      {
        SMDS_LinearEdge edge( node, cast2Node( *nIt ));
        tmpMesh.Copy( &edge );
      }
      // move copied node
      node = tmpMesh.GetMeshDS()->FindNode( nodeID );
      if ( node )
        tmpMesh.GetMeshDS()->MoveNode(node, x, y, z);
      // fill preview data
      ::SMESH_MeshEditor anEditor( & tmpMesh );
      storeResult( anEditor );
    }
    else if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly
    {
      theNodeSearcher->MoveNode(node, gp_Pnt( x,y,z ));
    }
    else
    {
      GetMeshDS()->MoveNode(node, x, y, z);
    }
  }

  if ( !myPreviewMode )
  {
    TPythonDump() << "nodeID = " << this
                  << ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z
                  << ", " << nodeID << " )";

    myMesh->GetMeshDS()->Modified();
    myMesh->SetIsModified( true );
  }

  return nodeID;
}

CORBA::Boolean SMESH_MeshEditor_i::MoveNode	(	CORBA::Long	NodeID,
		CORBA::Double	x,
		CORBA::Double	y,
		CORBA::Double	z
	)

Move the node to a given point.

Definition at line 4114 of file SMESH_MeshEditor_i.cxx.

References cast2Node, SMESH_MeshEditor.GetLinkedNodes(), and ex29_refine.node().

{
  initData(/*deleteSearchers=*/false);

  const SMDS_MeshNode * node = GetMeshDS()->FindNode( NodeID );
  if ( !node )
    return false;

  if ( theNodeSearcher )
    theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other

  if ( myPreviewMode ) // make preview data
  {
    // in a preview mesh, make edges linked to a node
    TPreviewMesh tmpMesh;
    TIDSortedElemSet linkedNodes;
    ::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
    TIDSortedElemSet::iterator nIt = linkedNodes.begin();
    SMDS_MeshNode *nodeCpy1 = tmpMesh.Copy(node);
    for ( ; nIt != linkedNodes.end(); ++nIt )
    {
      SMDS_MeshNode *nodeCpy2 = tmpMesh.Copy ( cast2Node( *nIt ));
      tmpMesh.GetMeshDS()->AddEdge(nodeCpy1, nodeCpy2);
    }
    // move copied node
    if ( nodeCpy1 )
      tmpMesh.GetMeshDS()->MoveNode(nodeCpy1, x, y, z);
    // fill preview data
    ::SMESH_MeshEditor anEditor( & tmpMesh );
    storeResult( anEditor );
  }
  else if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly
    theNodeSearcher->MoveNode(node, gp_Pnt( x,y,z ));
  else
    GetMeshDS()->MoveNode(node, x, y, z);

  if ( !myPreviewMode )
  {
    // Update Python script
    TPythonDump() << "isDone = " << this << ".MoveNode( "
                  << NodeID << ", " << x << ", " << y << ", " << z << " )";
    myMesh->GetMeshDS()->Modified();
    myMesh->SetIsModified( true );
  }

  return true;
}

CORBA::Boolean SMESH_MeshEditor_i::QuadToTri	(	const SMESH::long_array &	IDsOfElements,
		SMESH::NumericalFunctor_ptr	Criterion
	)

Definition at line 1178 of file SMESH_MeshEditor_i.cxx.

References ex21_lamp.faces, SMESH.NumericalFunctor_i.GetNumericalFunctor(), SMESH_Gen_i.GetServant(), and SMDSAbs_Face.

{
  initData();

  SMESHDS_Mesh* aMesh = GetMeshDS();
  TIDSortedElemSet faces;
  arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);

  SMESH::NumericalFunctor_i* aNumericalFunctor =
    dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
  SMESH::Controls::NumericalFunctorPtr aCrit;
  if ( !aNumericalFunctor )
    aCrit.reset( new SMESH::Controls::AspectRatio() );
  else
    aCrit = aNumericalFunctor->GetNumericalFunctor();


  // Update Python script
  TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";

  ::SMESH_MeshEditor anEditor( myMesh );
  CORBA::Boolean stat = anEditor.QuadToTri( faces, aCrit );
  myMesh->GetMeshDS()->Modified();
  if ( stat )
    myMesh->SetIsModified( true ); // issue 0020693

  storeResult(anEditor);

  return stat;
}

CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		SMESH::NumericalFunctor_ptr	Criterion
	)

Definition at line 1216 of file SMESH_MeshEditor_i.cxx.

References ex30_groupsOp.isDone.

{
  initData();

  TPythonDump aTPythonDump;  // suppress dump in QuadToTri()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  CORBA::Boolean isDone = QuadToTri(anElementsId, Criterion);

  SMESH::NumericalFunctor_i* aNumericalFunctor =
    SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );

  // Update Python script
  aTPythonDump << "isDone = " << this << ".QuadToTriObject( " << theObject << ", " << aNumericalFunctor << " )";

  return isDone;
}

CORBA::Boolean SMESH_MeshEditor_i::RemoveElements

(

const SMESH::long_array &

IDsOfElements

)

Definition at line 458 of file SMESH_MeshEditor_i.cxx.

References PAL_MESH_041_mesh.ret.

{
  initData();

  ::SMESH_MeshEditor anEditor( myMesh );
  list< int > IdList;

  for (int i = 0; i < IDsOfElements.length(); i++)
    IdList.push_back( IDsOfElements[i] );

  // Update Python script
  TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";

  // Remove Elements
  bool ret = anEditor.Remove( IdList, false );
  myMesh->GetMeshDS()->Modified();
  if ( IDsOfElements.length() )
    myMesh->SetIsModified( true ); // issue 0020693
  return ret;
}

CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes

(

const SMESH::long_array &

IDsOfNodes

)

Definition at line 485 of file SMESH_MeshEditor_i.cxx.

References PAL_MESH_041_mesh.ret.

{
  initData();

  ::SMESH_MeshEditor anEditor( myMesh );
  list< int > IdList;
  for (int i = 0; i < IDsOfNodes.length(); i++)
    IdList.push_back( IDsOfNodes[i] );

  // Update Python script
  TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";

  bool ret = anEditor.Remove( IdList, true );
  myMesh->GetMeshDS()->Modified();
  if ( IDsOfNodes.length() )
    myMesh->SetIsModified( true ); // issue 0020693
  return ret;
}

CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes

(

)

Definition at line 510 of file SMESH_MeshEditor_i.cxx.

References SMESH.Controls.Filter.GetElementsId(), and PAL_MESH_041_mesh.ret.

{
  initData();

  ::SMESH_MeshEditor anEditor( myMesh );

  // Update Python script
  TPythonDump() << "nbRemoved = " << this << ".RemoveOrphanNodes()";

  // Create filter to find all orphan nodes
  SMESH::Controls::Filter::TIdSequence seq;
  SMESH::Controls::PredicatePtr predicate( new SMESH::Controls::FreeNodes() );
  SMESH::Controls::Filter::GetElementsId( GetMeshDS(), predicate, seq );

  // remove orphan nodes (if there are any)
  list< int > IdList;
  for ( int i = 0; i < seq.size(); i++ )
    IdList.push_back( seq[i] );

  bool ret = anEditor.Remove( IdList, true );
  myMesh->GetMeshDS()->Modified();
  if ( IdList.size() )
    myMesh->SetIsModified( true );

  return ret;
}

void SMESH_MeshEditor_i::RenumberElements

(

)

Definition at line 1526 of file SMESH_MeshEditor_i.cxx.

{
  // Update Python script
  TPythonDump() << this << ".RenumberElements()";

  GetMeshDS()->Renumber( false );
}

void SMESH_MeshEditor_i::RenumberNodes

(

)

Definition at line 1511 of file SMESH_MeshEditor_i.cxx.

{
  // Update Python script
  TPythonDump() << this << ".RenumberNodes()";

  GetMeshDS()->Renumber( true );
}

CORBA::Boolean SMESH_MeshEditor_i::Reorient

(

const SMESH::long_array &

IDsOfElements

)

Definition at line 1063 of file SMESH_MeshEditor_i.cxx.

{
  initData();

  ::SMESH_MeshEditor anEditor( myMesh );
  for (int i = 0; i < IDsOfElements.length(); i++)
  {
    CORBA::Long index = IDsOfElements[i];
    const SMDS_MeshElement * elem = GetMeshDS()->FindElement(index);
    if ( elem )
      anEditor.Reorient( elem );
  }
  // Update Python script
  TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";

  myMesh->GetMeshDS()->Modified();
  if ( IDsOfElements.length() )
    myMesh->SetIsModified( true ); // issue 0020693

  return true;
}

CORBA::Boolean SMESH_MeshEditor_i::ReorientObject

(

SMESH::SMESH_IDSource_ptr

theObject

)

Definition at line 1092 of file SMESH_MeshEditor_i.cxx.

References ex30_groupsOp.isDone.

{
  initData();

  TPythonDump aTPythonDump; // suppress dump in Reorient()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  CORBA::Boolean isDone = Reorient(anElementsId);

  // Update Python script
  aTPythonDump << "isDone = " << this << ".ReorientObject( " << theObject << " )";

  return isDone;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::rotate	(	TIDSortedElemSet &	IDsOfElements,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	Angle,
		CORBA::Boolean	Copy,
		bool	MakeGroups,
		::SMESH_Mesh *	TargetMesh = 0
	)		[private]

Definition at line 3443 of file SMESH_MeshEditor_i.cxx.

References PAL_MESH_041_mesh.mesh, SMESH.AxisStruct.vx, SMESH.AxisStruct.vy, SMESH.AxisStruct.vz, SMESH.AxisStruct.x, SMESH.AxisStruct.y, and SMESH.AxisStruct.z.

{
  initData();

  if ( theTargetMesh )
    theCopy = false;

  gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
  gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );

  gp_Trsf aTrsf;
  aTrsf.SetRotation( gp_Ax1( P, V ), theAngle);

  TIDSortedElemSet  copyElements;
  TIDSortedElemSet* workElements = &theElements;
  TPreviewMesh      tmpMesh;
  SMESH_Mesh*       mesh = myMesh;

  if ( myPreviewMode ) {
    tmpMesh.Copy( theElements, copyElements );
    if ( !theCopy && !theTargetMesh )
    {
      TIDSortedElemSet elemsAround, elemsAroundCopy;
      getElementsAround( theElements, GetMeshDS(), elemsAround );
      tmpMesh.Copy( elemsAround, elemsAroundCopy);
    }
    mesh = &tmpMesh;
    workElements = &copyElements;
    theMakeGroups = false;
  }

  ::SMESH_MeshEditor anEditor( mesh );
  ::SMESH_MeshEditor::PGroupIDs groupIds =
      anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);

  if(theCopy || myPreviewMode)
    storeResult(anEditor);
  else
  {
    myMesh->GetMeshDS()->Modified();
    myMesh->SetIsModified( true );
  }

  return theMakeGroups ? getGroups(groupIds.get()) : 0;
}

void SMESH_MeshEditor_i::Rotate	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	Angle,
		CORBA::Boolean	Copy
	)

Definition at line 3499 of file SMESH_MeshEditor_i.cxx.

{
  if (!myPreviewMode) {
    TPythonDump() << this << ".Rotate( "
                  << theIDsOfElements << ", "
                  << theAxis << ", "
                  << theAngle << ", "
                  << theCopy << " )";
  }
  if (theIDsOfElements.length() > 0)
  {
    TIDSortedElemSet elements;
    arrayToSet(theIDsOfElements, GetMeshDS(), elements);
    rotate(elements,theAxis,theAngle,theCopy,false);
  }
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::RotateMakeGroups	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	AngleInRadians
	)

Definition at line 3548 of file SMESH_MeshEditor_i.cxx.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups * aGroups = 0;
  if (theIDsOfElements.length() > 0)
  {
    TIDSortedElemSet elements;
    arrayToSet(theIDsOfElements, GetMeshDS(), elements);
    aGroups = rotate(elements,theAxis,theAngle,true,true);
  }
  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".RotateMakeGroups( "
                << theIDsOfElements << ", "
                << theAxis << ", "
                << theAngle << " )";
  }
  return aGroups;
}

SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::RotateMakeMesh	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	AngleInRadians,
		CORBA::Boolean	CopyGroups,
		const char *	MeshName
	)

Definition at line 3604 of file SMESH_MeshEditor_i.cxx.

References SMESH_Mesh_i.CreateGroupServants(), SMESH_Mesh_i.GetGroups(), SMESH_Mesh_i.GetImpl(), and PAL_MESH_041_mesh.mesh.

{
  SMESH::SMESH_Mesh_var mesh;
  SMESH_Mesh_i* mesh_i;

  { // open new scope to dump "MakeMesh" command
    // and then "GetGroups" using SMESH_Mesh::GetGroups()

    TPythonDump pydump; // to prevent dump at mesh creation

    mesh = makeMesh( theMeshName );
    mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );

    if ( mesh_i && theIDsOfElements.length() > 0 )
    {
      TIDSortedElemSet elements;
      arrayToSet(theIDsOfElements, GetMeshDS(), elements);
      rotate(elements, theAxis, theAngleInRadians,
             false, theCopyGroups, & mesh_i->GetImpl());
      mesh_i->CreateGroupServants();
    }
    if ( !myPreviewMode ) {
      pydump << mesh << " = " << this << ".RotateMakeMesh( "
             << theIDsOfElements << ", "
             << theAxis << ", "
             << theAngleInRadians   << ", "
             << theCopyGroups << ", '"
             << theMeshName << "' )";
    }
  }

  // dump "GetGroups"
  if (!myPreviewMode && mesh_i && theIDsOfElements.length() > 0 )
    mesh_i->GetGroups();

  return mesh._retn();
}

void SMESH_MeshEditor_i::RotateObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	Angle,
		CORBA::Boolean	Copy
	)

Definition at line 3524 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_All.

{
  if ( !myPreviewMode ) {
    TPythonDump() << this << ".RotateObject( "
                  << theObject << ", "
                  << theAxis << ", "
                  << theAngle << ", "
                  << theCopy << " )";
  }
  TIDSortedElemSet elements;
  bool emptyIfIsMesh = myPreviewMode ? false : true;
  if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
    rotate(elements,theAxis,theAngle,theCopy,false);
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::RotateObjectMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	AngleInRadians
	)

Definition at line 3577 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_All.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups * aGroups = 0;
  TIDSortedElemSet elements;
  if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
    aGroups = rotate(elements, theAxis, theAngle, true, true);

  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".RotateObjectMakeGroups( "
                << theObject << ", "
                << theAxis << ", "
                << theAngle << " )";
  }
  return aGroups;
}

SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::RotateObjectMakeMesh	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	AngleInRadians,
		CORBA::Boolean	CopyGroups,
		const char *	MeshName
	)

Definition at line 3652 of file SMESH_MeshEditor_i.cxx.

References SMESH_Mesh_i.CreateGroupServants(), SMESH_Mesh_i.GetGroups(), SMESH_Mesh_i.GetImpl(), PAL_MESH_041_mesh.mesh, and SMDSAbs_All.

{
  SMESH::SMESH_Mesh_var mesh;
  SMESH_Mesh_i* mesh_i;

  {// open new scope to dump "MakeMesh" command
   // and then "GetGroups" using SMESH_Mesh::GetGroups()

    TPythonDump pydump; // to prevent dump at mesh creation
    mesh = makeMesh( theMeshName );
    mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );

    TIDSortedElemSet elements;
    if (mesh_i &&
        idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
    {
      rotate(elements, theAxis, theAngleInRadians,
             false, theCopyGroups, & mesh_i->GetImpl());
      mesh_i->CreateGroupServants();
    }
    if ( !myPreviewMode ) {
      pydump << mesh << " = " << this << ".RotateObjectMakeMesh( "
             << theObject << ", "
             << theAxis << ", "
             << theAngleInRadians   << ", "
             << theCopyGroups << ", '"
             << theMeshName << "' )";
    }
  }

  // dump "GetGroups"
  if (!myPreviewMode && mesh_i)
    mesh_i->GetGroups();

  return mesh._retn();
}

void SMESH_MeshEditor_i::RotationSweep	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	AngleInRadians,
		CORBA::Long	NbOfSteps,
		CORBA::Double	Tolerance
	)

Definition at line 1604 of file SMESH_MeshEditor_i.cxx.

{
  if ( !myPreviewMode ) {
    TPythonDump() << this << ".RotationSweep( "
                  << theIDsOfElements << ", "
                  << theAxis << ", "
                  << theAngleInRadians << ", "
                  << theNbOfSteps << ", "
                  << theTolerance << " )";
  }
  rotationSweep(theIDsOfElements,
                theAxis,
                theAngleInRadians,
                theNbOfSteps,
                theTolerance,
                false);
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::rotationSweep	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	AngleInRadians,
		CORBA::Long	NbOfSteps,
		CORBA::Double	Tolerance,
		const bool	MakeGroups,
		const SMDSAbs_ElementType	ElementType = SMDSAbs_All
	)		[private]

Definition at line 1554 of file SMESH_MeshEditor_i.cxx.

References PAL_MESH_041_mesh.mesh, SMDSAbs_All, SMDSAbs_Face, SMDSAbs_Volume, SMESH.AxisStruct.vx, SMESH.AxisStruct.vy, SMESH.AxisStruct.vz, SMESH.AxisStruct.x, SMESH.AxisStruct.y, and SMESH.AxisStruct.z.

{
  initData();

  TIDSortedElemSet inElements, copyElements;
  arrayToSet(theIDsOfElements, GetMeshDS(), inElements, theElementType);

  TIDSortedElemSet* workElements = & inElements;
  TPreviewMesh      tmpMesh( SMDSAbs_Face );
  SMESH_Mesh*       mesh = 0;
  bool              makeWalls=true;
  if ( myPreviewMode )
  {
    SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
    tmpMesh.Copy( inElements, copyElements, select, avoid );
    mesh = &tmpMesh;
    workElements = & copyElements;
    //makeWalls = false;
  }
  else
  {
    mesh = myMesh;
  }

  gp_Ax1 Ax1 (gp_Pnt( theAxis.x,  theAxis.y,  theAxis.z ),
              gp_Vec( theAxis.vx, theAxis.vy, theAxis.vz ));

  ::SMESH_MeshEditor anEditor( mesh );
  ::SMESH_MeshEditor::PGroupIDs groupIds =
      anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians,
                              theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
  storeResult(anEditor);
  myMesh->GetMeshDS()->Modified();

  //  myMesh->SetIsModified( true ); -- it does not influence Compute()

  return theMakeGroups ? getGroups(groupIds.get()) : 0;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::RotationSweepMakeGroups	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::AxisStruct &	Axix,
		CORBA::Double	AngleInRadians,
		CORBA::Long	NbOfSteps,
		CORBA::Double	Tolerance
	)

Definition at line 1632 of file SMESH_MeshEditor_i.cxx.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups *aGroups = rotationSweep(theIDsOfElements,
                                               theAxis,
                                               theAngleInRadians,
                                               theNbOfSteps,
                                               theTolerance,
                                               true);
  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".RotationSweepMakeGroups( "
                << theIDsOfElements << ", "
                << theAxis << ", "
                << theAngleInRadians << ", "
                << theNbOfSteps << ", "
                << theTolerance << " )";
  }
  return aGroups;
}

void SMESH_MeshEditor_i::RotationSweepObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	AngleInRadians,
		CORBA::Long	NbOfSteps,
		CORBA::Double	Tolerance
	)

Definition at line 1663 of file SMESH_MeshEditor_i.cxx.

{
  if ( !myPreviewMode ) {
    TPythonDump() << this << ".RotationSweepObject( "
                  << theObject << ", "
                  << theAxis << ", "
                  << theAngleInRadians << ", "
                  << theNbOfSteps << ", "
                  << theTolerance << " )";
  }
  SMESH::long_array_var anElementsId = theObject->GetIDs();
  rotationSweep(anElementsId,
                theAxis,
                theAngleInRadians,
                theNbOfSteps,
                theTolerance,
                false);
}

void SMESH_MeshEditor_i::RotationSweepObject1D	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	AngleInRadians,
		CORBA::Long	NbOfSteps,
		CORBA::Double	Tolerance
	)

Definition at line 1691 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Edge.

{
  if ( !myPreviewMode ) {
    TPythonDump() << this << ".RotationSweepObject1D( "
                  << theObject << ", "
                  << theAxis << ", "
                  << theAngleInRadians << ", "
                  << theNbOfSteps << ", "
                  << theTolerance << " )";
  }
  SMESH::long_array_var anElementsId = theObject->GetIDs();
  rotationSweep(anElementsId,
                theAxis,
                theAngleInRadians,
                theNbOfSteps,
                theTolerance,
                false,
                SMDSAbs_Edge);
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::RotationSweepObject1DMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::AxisStruct &	Axix,
		CORBA::Double	AngleInRadians,
		CORBA::Long	NbOfSteps,
		CORBA::Double	Tolerance
	)

Definition at line 1783 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Edge.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
                                               theAxis,
                                               theAngleInRadians,
                                               theNbOfSteps,
                                               theTolerance,
                                               true,
                                               SMDSAbs_Edge);
  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".RotationSweepObject1DMakeGroups( "
                << theObject << ", "
                << theAxis << ", "
                << theAngleInRadians << ", "
                << theNbOfSteps << ", "
                << theTolerance << " )";
  }
  return aGroups;
}

void SMESH_MeshEditor_i::RotationSweepObject2D	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::AxisStruct &	Axis,
		CORBA::Double	AngleInRadians,
		CORBA::Long	NbOfSteps,
		CORBA::Double	Tolerance
	)

Definition at line 1720 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Face.

{
  if ( !myPreviewMode ) {
    TPythonDump() << this << ".RotationSweepObject2D( "
                  << theObject << ", "
                  << theAxis << ", "
                  << theAngleInRadians << ", "
                  << theNbOfSteps << ", "
                  << theTolerance << " )";
  }
  SMESH::long_array_var anElementsId = theObject->GetIDs();
  rotationSweep(anElementsId,
                theAxis,
                theAngleInRadians,
                theNbOfSteps,
                theTolerance,
                false,
                SMDSAbs_Face);
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::RotationSweepObject2DMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::AxisStruct &	Axix,
		CORBA::Double	AngleInRadians,
		CORBA::Long	NbOfSteps,
		CORBA::Double	Tolerance
	)

Definition at line 1817 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Face.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
                                               theAxis,
                                               theAngleInRadians,
                                               theNbOfSteps,
                                               theTolerance,
                                               true,
                                               SMDSAbs_Face);
  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".RotationSweepObject2DMakeGroups( "
                << theObject << ", "
                << theAxis << ", "
                << theAngleInRadians << ", "
                << theNbOfSteps << ", "
                << theTolerance << " )";
  }
  return aGroups;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::RotationSweepObjectMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::AxisStruct &	Axix,
		CORBA::Double	AngleInRadians,
		CORBA::Long	NbOfSteps,
		CORBA::Double	Tolerance
	)

Definition at line 1750 of file SMESH_MeshEditor_i.cxx.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
                                               theAxis,
                                               theAngleInRadians,
                                               theNbOfSteps,
                                               theTolerance,
                                               true);
  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".RotationSweepObjectMakeGroups( "
                << theObject << ", "
                << theAxis << ", "
                << theAngleInRadians << ", "
                << theNbOfSteps << ", "
                << theTolerance << " )";
  }
  return aGroups;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::scale	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::PointStruct &	thePoint,
		const SMESH::double_array &	theScaleFact,
		CORBA::Boolean	theCopy,
		bool	theMakeGroups,
		::SMESH_Mesh *	theTargetMesh = 0
	)		[private]

Definition at line 3699 of file SMESH_MeshEditor_i.cxx.

References PAL_MESH_041_mesh.mesh, SMDSAbs_All, SMESH_AdvancedEditor.tol, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  initData();
  if ( theScaleFact.length() < 1 )
    THROW_SALOME_CORBA_EXCEPTION("Scale factor not given", SALOME::BAD_PARAM);
  if ( theScaleFact.length() == 2 )
    THROW_SALOME_CORBA_EXCEPTION("Invalid nb of scale factors : 2", SALOME::BAD_PARAM);

  if ( theTargetMesh )
    theCopy = false;

  TIDSortedElemSet elements;
  bool emptyIfIsMesh = myPreviewMode ? false : true;
  if ( !idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
    return 0;

  double S[3] = {
    theScaleFact[0],
    (theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[1],
    (theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[2],
  };
  double tol = std::numeric_limits<double>::max();
  gp_Trsf aTrsf;
  aTrsf.SetValues( S[0], 0,    0,    thePoint.x * (1-S[0]),
                   0,    S[1], 0,    thePoint.y * (1-S[1]),
                   0,    0,    S[2], thePoint.z * (1-S[2]),   tol, tol);

  TIDSortedElemSet  copyElements;
  TPreviewMesh      tmpMesh;
  TIDSortedElemSet* workElements = &elements;
  SMESH_Mesh*       mesh = myMesh;
  
  if ( myPreviewMode )
  {
    tmpMesh.Copy( elements, copyElements);
    if ( !theCopy && !theTargetMesh )
    {
      TIDSortedElemSet elemsAround, elemsAroundCopy;
      getElementsAround( elements, GetMeshDS(), elemsAround );
      tmpMesh.Copy( elemsAround, elemsAroundCopy);
    }
    mesh = &tmpMesh;
    workElements = & copyElements;
    theMakeGroups = false;
  }

  ::SMESH_MeshEditor anEditor( mesh );
  ::SMESH_MeshEditor::PGroupIDs groupIds =
      anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);

  if(theCopy || myPreviewMode )
    storeResult(anEditor);
  else
  {
    myMesh->GetMeshDS()->Modified();
    myMesh->SetIsModified( true );
  }
  return theMakeGroups ? getGroups(groupIds.get()) : 0;
}

void SMESH_MeshEditor_i::Scale	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::PointStruct &	thePoint,
		const SMESH::double_array &	theScaleFact,
		CORBA::Boolean	theCopy
	)

Definition at line 3769 of file SMESH_MeshEditor_i.cxx.

References SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  if ( !myPreviewMode ) {
    TPythonDump() << this << ".Scale( "
                  << theObject << ", "
                  << "SMESH.PointStruct( "  << thePoint.x << ", "
                  << thePoint.y << ", " << thePoint.z << " ) ,"
                  << theScaleFact << ", "
                  << theCopy << " )";
  }
  scale(theObject, thePoint, theScaleFact, theCopy, false);
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::ScaleMakeGroups	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::PointStruct &	thePoint,
		const SMESH::double_array &	theScaleFact
	)

Definition at line 3792 of file SMESH_MeshEditor_i.cxx.

References SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups * aGroups = scale(theObject, thePoint, theScaleFact, true, true);
  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".Scale("
                << theObject << ","
                << "SMESH.PointStruct(" <<thePoint.x << ","
                << thePoint.y << "," << thePoint.z << "),"
                << theScaleFact << ",True,True)";
  }
  return aGroups;
}

SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::ScaleMakeMesh	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::PointStruct &	Point,
		const SMESH::double_array &	theScaleFact,
		CORBA::Boolean	CopyGroups,
		const char *	MeshName
	)

Definition at line 3817 of file SMESH_MeshEditor_i.cxx.

References SMESH_Mesh_i.CreateGroupServants(), SMESH_Mesh_i.GetGroups(), SMESH_Mesh_i.GetImpl(), PAL_MESH_041_mesh.mesh, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  SMESH_Mesh_i* mesh_i;
  SMESH::SMESH_Mesh_var mesh;
  { // open new scope to dump "MakeMesh" command
    // and then "GetGroups" using SMESH_Mesh::GetGroups()

    TPythonDump pydump; // to prevent dump at mesh creation
    mesh = makeMesh( theMeshName );
    mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );

    if ( mesh_i )
    {
      scale(theObject, thePoint, theScaleFact,false, theCopyGroups, & mesh_i->GetImpl());
      mesh_i->CreateGroupServants();
    }
    if ( !myPreviewMode )
      pydump << mesh << " = " << this << ".ScaleMakeMesh( "
             << theObject << ", "
             << "SMESH.PointStruct( "  << thePoint.x << ", "
             << thePoint.y << ", " << thePoint.z << " ) ,"
             << theScaleFact << ", "
             << theCopyGroups << ", '"
             << theMeshName << "' )";
  }

  // dump "GetGroups"
  if (!myPreviewMode && mesh_i)
    mesh_i->GetGroups();

  return mesh._retn();
}

void SMESH_MeshEditor_i::SetMeshElementOnShape	(	CORBA::Long	ElementID,
		CORBA::Long	ShapeID
	)		throw (SALOME::SALOME_Exception)

Bind an element to a shape.

Parameters:

ElementID	- element ID
ShapeID	- shape ID available through GEOM_Object.GetSubShapeIndices()[0]
ElementID	- element ID
ShapeID	- shape ID available through GEOM_Object.GetSubShapeIndices()[0]

Return values:

boolean

- false if ElementID or ShapeID is invalid

Definition at line 970 of file SMESH_MeshEditor_i.cxx.

References SMDS_Mesh.FindElement(), SMESHDS_Mesh.IndexToShape(), SMESHDS_Mesh.MaxShapeIndex(), PAL_MESH_041_mesh.mesh, SMESHDS_Mesh.SetMeshElementOnShape(), and SMESH_fixation.shape.

{
  Unexpect aCatch(SALOME_SalomeException);

  SMESHDS_Mesh * mesh = GetMeshDS();
  SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(mesh->FindElement(ElementID));
  if ( !elem )
    THROW_SALOME_CORBA_EXCEPTION("Invalid ElementID", SALOME::BAD_PARAM);

  if ( mesh->MaxShapeIndex() < ShapeID )
    THROW_SALOME_CORBA_EXCEPTION("Invalid ShapeID", SALOME::BAD_PARAM);

  TopoDS_Shape shape = mesh->IndexToShape( ShapeID );
  if ( shape.ShapeType() != TopAbs_EDGE &&
       shape.ShapeType() != TopAbs_FACE &&
       shape.ShapeType() != TopAbs_SOLID &&
       shape.ShapeType() != TopAbs_SHELL )
    THROW_SALOME_CORBA_EXCEPTION("Invalid shape type", SALOME::BAD_PARAM);

  mesh->SetMeshElementOnShape( elem, ShapeID );

  myMesh->SetIsModified( true );
}

void SMESH_MeshEditor_i::SetNodeInVolume	(	CORBA::Long	NodeID,
		CORBA::Long	SolidID
	)		throw (SALOME::SALOME_Exception)

Bind a node to a solid.

Parameters:

NodeID	- node ID
SolidID	- vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
NodeID	- node ID
SolidID	- vertex ID available through GEOM_Object.GetSubShapeIndices()[0]

Return values:

boolean

- false if NodeID or SolidID is invalid

Definition at line 938 of file SMESH_MeshEditor_i.cxx.

References SMDS_Mesh.FindNode(), SMESHDS_Mesh.IndexToShape(), SMESHDS_Mesh.MaxShapeIndex(), PAL_MESH_041_mesh.mesh, ex29_refine.node(), SMESHDS_Mesh.SetNodeInVolume(), and SMESH_fixation.shape.

{
  Unexpect aCatch(SALOME_SalomeException);

  SMESHDS_Mesh * mesh = GetMeshDS();
  SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
  if ( !node )
    THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);

  if ( mesh->MaxShapeIndex() < SolidID )
    THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);

  TopoDS_Shape shape = mesh->IndexToShape( SolidID );
  if ( shape.ShapeType() != TopAbs_SOLID &&
       shape.ShapeType() != TopAbs_SHELL)
    THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);

  mesh->SetNodeInVolume( node, SolidID );

  // myMesh->SetIsModified( true ); - SetNodeInVolume() can't prevent re-compute, I believe
}

void SMESH_MeshEditor_i::SetNodeOnEdge	(	CORBA::Long	NodeID,
		CORBA::Long	EdgeID,
		CORBA::Double	paramOnEdge
	)		throw (SALOME::SALOME_Exception)

Store node position on an edge.

Parameters:

NodeID	- node ID
EdgeID	- edge ID available through GEOM_Object.GetSubShapeIndices()[0]
paramOnEdge	- parameter on edge where the node is located
NodeID	- node ID
EdgeID	- edge ID available through GEOM_Object.GetSubShapeIndices()[0]
paramOnEdge	- parameter on edge where the node is located

Return values:

boolean

- false if any parameter is invalid

Definition at line 851 of file SMESH_MeshEditor_i.cxx.

References SMDS_Mesh.FindNode(), SMESHDS_Mesh.IndexToShape(), SMESHDS_Mesh.MaxShapeIndex(), PAL_MESH_041_mesh.mesh, ex29_refine.node(), SMESHDS_Mesh.SetNodeOnEdge(), and SMESH_fixation.shape.

{
  Unexpect aCatch(SALOME_SalomeException);

  SMESHDS_Mesh * mesh = GetMeshDS();
  SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
  if ( !node )
    THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);

  if ( mesh->MaxShapeIndex() < EdgeID )
    THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);

  TopoDS_Shape shape = mesh->IndexToShape( EdgeID );
  if ( shape.ShapeType() != TopAbs_EDGE )
    THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);

  Standard_Real f,l;
  BRep_Tool::Range( TopoDS::Edge( shape ), f,l);
  if ( paramOnEdge < f || paramOnEdge > l )
    THROW_SALOME_CORBA_EXCEPTION("Invalid paramOnEdge", SALOME::BAD_PARAM);

  mesh->SetNodeOnEdge( node, EdgeID, paramOnEdge );

  myMesh->SetIsModified( true );
}

void SMESH_MeshEditor_i::SetNodeOnFace	(	CORBA::Long	NodeID,
		CORBA::Long	FaceID,
		CORBA::Double	u,
		CORBA::Double	v
	)		throw (SALOME::SALOME_Exception)

Store node position on a face.

Parameters:

NodeID	- node ID
FaceID	- face ID available through GEOM_Object.GetSubShapeIndices()[0]
u	- U parameter on face where the node is located
v	- V parameter on face where the node is located
NodeID	- node ID
FaceID	- face ID available through GEOM_Object.GetSubShapeIndices()[0]
u	- U parameter on face where the node is located
v	- V parameter on face where the node is located

Return values:

boolean

- false if any parameter is invalid

Definition at line 890 of file SMESH_MeshEditor_i.cxx.

References SMDS_Mesh.FindNode(), SMESHDS_Mesh.IndexToShape(), SMESHDS_Mesh.MaxShapeIndex(), PAL_MESH_041_mesh.mesh, MESSAGE, ex29_refine.node(), SMESHDS_Mesh.SetNodeOnFace(), and SMESH_fixation.shape.

{
  Unexpect aCatch(SALOME_SalomeException);

  SMESHDS_Mesh * mesh = GetMeshDS();
  SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
  if ( !node )
    THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);

  if ( mesh->MaxShapeIndex() < FaceID )
    THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);

  TopoDS_Shape shape = mesh->IndexToShape( FaceID );
  if ( shape.ShapeType() != TopAbs_FACE )
    THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);

  BRepAdaptor_Surface surf( TopoDS::Face( shape ));
  bool isOut = ( u < surf.FirstUParameter() ||
                 u > surf.LastUParameter()  ||
                 v < surf.FirstVParameter() ||
                 v > surf.LastVParameter() );

  if ( isOut ) {
#ifdef _DEBUG_
    MESSAGE ( "FACE " << FaceID << " (" << u << "," << v << ") out of "
              << " u( " <<  surf.FirstUParameter()
              << "," <<  surf.LastUParameter()
              << ") v( " <<  surf.FirstVParameter()
              << "," <<  surf.LastVParameter() << ")" );
#endif
    THROW_SALOME_CORBA_EXCEPTION("Invalid UV", SALOME::BAD_PARAM);
  }

  mesh->SetNodeOnFace( node, FaceID, u, v );
  myMesh->SetIsModified( true );
}

void SMESH_MeshEditor_i::SetNodeOnVertex	(	CORBA::Long	NodeID,
		CORBA::Long	VertexID
	)		throw (SALOME::SALOME_Exception)

Bind a node to a vertex.

Parameters:

NodeID	- node ID
VertexID	- vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
NodeID	- node ID
VertexID	- vertex ID available through GEOM_Object.GetSubShapeIndices()[0]

Return values:

boolean

- false if NodeID or VertexID is invalid

Definition at line 819 of file SMESH_MeshEditor_i.cxx.

References SMDS_Mesh.FindNode(), SMESHDS_Mesh.IndexToShape(), SMESHDS_Mesh.MaxShapeIndex(), PAL_MESH_041_mesh.mesh, ex29_refine.node(), SMESHDS_Mesh.SetNodeOnVertex(), and SMESH_fixation.shape.

{
  Unexpect aCatch(SALOME_SalomeException);

  SMESHDS_Mesh * mesh = GetMeshDS();
  SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
  if ( !node )
    THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);

  if ( mesh->MaxShapeIndex() < VertexID )
    THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);

  TopoDS_Shape shape = mesh->IndexToShape( VertexID );
  if ( shape.ShapeType() != TopAbs_VERTEX )
    THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);

  mesh->SetNodeOnVertex( node, VertexID );

  myMesh->SetIsModified( true );
}

SMESH::SMESH_MeshEditor::Sew_Error SMESH_MeshEditor_i::SewBorderToSide	(	CORBA::Long	FirstNodeIDOnFreeBorder,
		CORBA::Long	SecondNodeIDOnFreeBorder,
		CORBA::Long	LastNodeIDOnFreeBorder,
		CORBA::Long	FirstNodeIDOnSide,
		CORBA::Long	LastNodeIDOnSide,
		CORBA::Boolean	CreatePolygons,
		CORBA::Boolean	CreatePolyedrs
	)

Definition at line 4474 of file SMESH_MeshEditor_i.cxx.

References convError(), SMDS_Mesh.FindNode(), SMESH.SMESH_MeshEditor.SEW_BAD_SIDE_NODES, and SMESH.SMESH_MeshEditor.SEW_BORDER1_NOT_FOUND.

{
  initData();

  SMESHDS_Mesh* aMesh = GetMeshDS();

  const SMDS_MeshNode* aBorderFirstNode  = aMesh->FindNode( FirstNodeIDOnFreeBorder  );
  const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeIDOnFreeBorder );
  const SMDS_MeshNode* aBorderLastNode   = aMesh->FindNode( LastNodeIDOnFreeBorder   );
  const SMDS_MeshNode* aSide2FirstNode   = aMesh->FindNode( FirstNodeIDOnSide  );
  const SMDS_MeshNode* aSide2SecondNode  = aMesh->FindNode( LastNodeIDOnSide );
  const SMDS_MeshNode* aSide2ThirdNode   = 0;

  if (!aBorderFirstNode ||
      !aBorderSecondNode||
      !aBorderLastNode  )
    return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
  if (!aSide2FirstNode  ||
      !aSide2SecondNode)
    return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE_NODES;

  TPythonDump() << "error = " << this << ".SewBorderToSide( "
                << FirstNodeIDOnFreeBorder  << ", "
                << SecondNodeIDOnFreeBorder << ", "
                << LastNodeIDOnFreeBorder   << ", "
                << FirstNodeIDOnSide        << ", "
                << LastNodeIDOnSide         << ", "
                << CreatePolygons           << ", "
                << CreatePolyedrs           << ") ";

  ::SMESH_MeshEditor anEditor( myMesh );
  SMESH::SMESH_MeshEditor::Sew_Error error =
    convError( anEditor.SewFreeBorder (aBorderFirstNode,
                                       aBorderSecondNode,
                                       aBorderLastNode,
                                       aSide2FirstNode,
                                       aSide2SecondNode,
                                       aSide2ThirdNode,
                                       false,
                                       CreatePolygons,
                                       CreatePolyedrs) );

  storeResult(anEditor);

  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true );

  return error;
}

SMESH::SMESH_MeshEditor::Sew_Error SMESH_MeshEditor_i::SewConformFreeBorders	(	CORBA::Long	FirstNodeID1,
		CORBA::Long	SecondNodeID1,
		CORBA::Long	LastNodeID1,
		CORBA::Long	FirstNodeID2,
		CORBA::Long	SecondNodeID2
	)

Definition at line 4416 of file SMESH_MeshEditor_i.cxx.

References convError(), SMDS_Mesh.FindNode(), SMESH.SMESH_MeshEditor.SEW_BORDER1_NOT_FOUND, and SMESH.SMESH_MeshEditor.SEW_BORDER2_NOT_FOUND.

{
  initData();

  SMESHDS_Mesh* aMesh = GetMeshDS();

  const SMDS_MeshNode* aBorderFirstNode  = aMesh->FindNode( FirstNodeID1  );
  const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
  const SMDS_MeshNode* aBorderLastNode   = aMesh->FindNode( LastNodeID1   );
  const SMDS_MeshNode* aSide2FirstNode   = aMesh->FindNode( FirstNodeID2  );
  const SMDS_MeshNode* aSide2SecondNode  = aMesh->FindNode( SecondNodeID2 );
  const SMDS_MeshNode* aSide2ThirdNode   = 0;

  if (!aBorderFirstNode ||
      !aBorderSecondNode||
      !aBorderLastNode )
    return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
  if (!aSide2FirstNode  ||
      !aSide2SecondNode)
    return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;

  TPythonDump() << "error = " << this << ".SewConformFreeBorders( "
                << FirstNodeID1  << ", "
                << SecondNodeID1 << ", "
                << LastNodeID1   << ", "
                << FirstNodeID2  << ", "
                << SecondNodeID2 << " )";

  ::SMESH_MeshEditor anEditor( myMesh );
  SMESH::SMESH_MeshEditor::Sew_Error error =
    convError( anEditor.SewFreeBorder (aBorderFirstNode,
                                       aBorderSecondNode,
                                       aBorderLastNode,
                                       aSide2FirstNode,
                                       aSide2SecondNode,
                                       aSide2ThirdNode,
                                       true,
                                       false, false) );

  storeResult(anEditor);

  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true );

  return error;
}

SMESH::SMESH_MeshEditor::Sew_Error SMESH_MeshEditor_i::SewFreeBorders	(	CORBA::Long	FirstNodeID1,
		CORBA::Long	SecondNodeID1,
		CORBA::Long	LastNodeID1,
		CORBA::Long	FirstNodeID2,
		CORBA::Long	SecondNodeID2,
		CORBA::Long	LastNodeID2,
		CORBA::Boolean	CreatePolygons,
		CORBA::Boolean	CreatePolyedrs
	)

Definition at line 4350 of file SMESH_MeshEditor_i.cxx.

References convError(), SMDS_Mesh.FindNode(), SMESH.SMESH_MeshEditor.SEW_BORDER1_NOT_FOUND, and SMESH.SMESH_MeshEditor.SEW_BORDER2_NOT_FOUND.

{
  initData();

  SMESHDS_Mesh* aMesh = GetMeshDS();

  const SMDS_MeshNode* aBorderFirstNode  = aMesh->FindNode( FirstNodeID1  );
  const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
  const SMDS_MeshNode* aBorderLastNode   = aMesh->FindNode( LastNodeID1   );
  const SMDS_MeshNode* aSide2FirstNode   = aMesh->FindNode( FirstNodeID2  );
  const SMDS_MeshNode* aSide2SecondNode  = aMesh->FindNode( SecondNodeID2 );
  const SMDS_MeshNode* aSide2ThirdNode   = aMesh->FindNode( LastNodeID2   );

  if (!aBorderFirstNode ||
      !aBorderSecondNode||
      !aBorderLastNode)
    return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
  if (!aSide2FirstNode  ||
      !aSide2SecondNode ||
      !aSide2ThirdNode)
    return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;

  TPythonDump() << "error = " << this << ".SewFreeBorders( "
                << FirstNodeID1  << ", "
                << SecondNodeID1 << ", "
                << LastNodeID1   << ", "
                << FirstNodeID2  << ", "
                << SecondNodeID2 << ", "
                << LastNodeID2   << ", "
                << CreatePolygons<< ", "
                << CreatePolyedrs<< " )";

  ::SMESH_MeshEditor anEditor( myMesh );
  SMESH::SMESH_MeshEditor::Sew_Error error =
    convError( anEditor.SewFreeBorder (aBorderFirstNode,
                                       aBorderSecondNode,
                                       aBorderLastNode,
                                       aSide2FirstNode,
                                       aSide2SecondNode,
                                       aSide2ThirdNode,
                                       true,
                                       CreatePolygons,
                                       CreatePolyedrs) );

  storeResult(anEditor);

  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true );

  return error;
}

SMESH::SMESH_MeshEditor::Sew_Error SMESH_MeshEditor_i::SewSideElements	(	const SMESH::long_array &	IDsOfSide1Elements,
		const SMESH::long_array &	IDsOfSide2Elements,
		CORBA::Long	NodeID1OfSide1ToMerge,
		CORBA::Long	NodeID1OfSide2ToMerge,
		CORBA::Long	NodeID2OfSide1ToMerge,
		CORBA::Long	NodeID2OfSide2ToMerge
	)

Definition at line 4537 of file SMESH_MeshEditor_i.cxx.

References convError(), SMDS_Mesh.FindNode(), SMESH.SMESH_MeshEditor.SEW_BAD_SIDE1_NODES, and SMESH.SMESH_MeshEditor.SEW_BAD_SIDE2_NODES.

{
  initData();

  SMESHDS_Mesh* aMesh = GetMeshDS();

  const SMDS_MeshNode* aFirstNode1ToMerge  = aMesh->FindNode( NodeID1OfSide1ToMerge );
  const SMDS_MeshNode* aFirstNode2ToMerge  = aMesh->FindNode( NodeID1OfSide2ToMerge );
  const SMDS_MeshNode* aSecondNode1ToMerge = aMesh->FindNode( NodeID2OfSide1ToMerge );
  const SMDS_MeshNode* aSecondNode2ToMerge = aMesh->FindNode( NodeID2OfSide2ToMerge );

  if (!aFirstNode1ToMerge ||
      !aFirstNode2ToMerge )
    return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE1_NODES;
  if (!aSecondNode1ToMerge||
      !aSecondNode2ToMerge)
    return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE2_NODES;

  TIDSortedElemSet aSide1Elems, aSide2Elems;
  arrayToSet(IDsOfSide1Elements, aMesh, aSide1Elems);
  arrayToSet(IDsOfSide2Elements, aMesh, aSide2Elems);

  TPythonDump() << "error = " << this << ".SewSideElements( "
                << IDsOfSide1Elements << ", "
                << IDsOfSide2Elements << ", "
                << NodeID1OfSide1ToMerge << ", "
                << NodeID1OfSide2ToMerge << ", "
                << NodeID2OfSide1ToMerge << ", "
                << NodeID2OfSide2ToMerge << ")";

  ::SMESH_MeshEditor anEditor( myMesh );
  SMESH::SMESH_MeshEditor::Sew_Error error =
    convError( anEditor.SewSideElements (aSide1Elems, aSide2Elems,
                                         aFirstNode1ToMerge,
                                         aFirstNode2ToMerge,
                                         aSecondNode1ToMerge,
                                         aSecondNode2ToMerge));

  storeResult(anEditor);

  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true );

  return error;
}

CORBA::Boolean SMESH_MeshEditor_i::Smooth	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::long_array &	IDsOfFixedNodes,
		CORBA::Long	MaxNbOfIterations,
		CORBA::Double	MaxAspectRatio,
		SMESH::SMESH_MeshEditor::Smooth_Method	Method
	)

Definition at line 1354 of file SMESH_MeshEditor_i.cxx.

{
  return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
                 MaxAspectRatio, Method, false );
}

CORBA::Boolean SMESH_MeshEditor_i::smooth	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::long_array &	IDsOfFixedNodes,
		CORBA::Long	MaxNbOfIterations,
		CORBA::Double	MaxAspectRatio,
		SMESH::SMESH_MeshEditor::Smooth_Method	Method,
		bool	IsParametric
	)

Definition at line 1423 of file SMESH_MeshEditor_i.cxx.

References SMESH_MeshEditor.CENTROIDAL, SMESH.SMESH_MeshEditor.CENTROIDAL_SMOOTH, SMDS_Mesh.FindNode(), SMESH_MeshEditor.LAPLACIAN, SMESH.SMESH_MeshEditor.LAPLACIAN_SMOOTH, ex29_refine.node(), and SMDSAbs_Face.

{
  initData();

  SMESHDS_Mesh* aMesh = GetMeshDS();

  TIDSortedElemSet elements;
  arrayToSet(IDsOfElements, aMesh, elements, SMDSAbs_Face);

  set<const SMDS_MeshNode*> fixedNodes;
  for (int i = 0; i < IDsOfFixedNodes.length(); i++) {
    CORBA::Long index = IDsOfFixedNodes[i];
    const SMDS_MeshNode * node = aMesh->FindNode(index);
    if ( node )
      fixedNodes.insert( node );
  }
  ::SMESH_MeshEditor::SmoothMethod method = ::SMESH_MeshEditor::LAPLACIAN;
  if ( Method != SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH )
    method = ::SMESH_MeshEditor::CENTROIDAL;

  ::SMESH_MeshEditor anEditor( myMesh );
  anEditor.Smooth(elements, fixedNodes, method,
                  MaxNbOfIterations, MaxAspectRatio, IsParametric );

  myMesh->GetMeshDS()->Modified();
  myMesh->SetIsModified( true ); // issue 0020693

  storeResult(anEditor);

  // Update Python script
  TPythonDump() << "isDone = " << this << "."
                << (IsParametric ? "SmoothParametric( " : "Smooth( ")
                << IDsOfElements << ", "     << IDsOfFixedNodes << ", "
                << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
                << "SMESH.SMESH_MeshEditor."
                << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
                     "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");

  return true;
}

CORBA::Boolean SMESH_MeshEditor_i::smoothObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::long_array &	IDsOfFixedNodes,
		CORBA::Long	MaxNbOfIterations,
		CORBA::Double	MaxAspectRatio,
		SMESH::SMESH_MeshEditor::Smooth_Method	Method,
		bool	IsParametric
	)

Definition at line 1477 of file SMESH_MeshEditor_i.cxx.

References SMESH.SMESH_MeshEditor.CENTROIDAL_SMOOTH, and ex30_groupsOp.isDone.

{
  initData();

  TPythonDump aTPythonDump;  // suppress dump in smooth()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  CORBA::Boolean isDone = smooth (anElementsId, IDsOfFixedNodes, MaxNbOfIterations,
                                  MaxAspectRatio, Method, IsParametric);

  // Update Python script
  aTPythonDump << "isDone = " << this << "."
               << (IsParametric ? "SmoothParametricObject( " : "SmoothObject( ")
               << theObject << ", " << IDsOfFixedNodes << ", "
               << MaxNbOfIterations << ", " << MaxAspectRatio << ", "
               << "SMESH.SMESH_MeshEditor."
               << ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
                    "CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");

  return isDone;
}

CORBA::Boolean SMESH_MeshEditor_i::SmoothObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::long_array &	IDsOfFixedNodes,
		CORBA::Long	MaxNbOfIterations,
		CORBA::Double	MaxAspectRatio,
		SMESH::SMESH_MeshEditor::Smooth_Method	Method
	)

Definition at line 1388 of file SMESH_MeshEditor_i.cxx.

{
  return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
                       MaxAspectRatio, Method, false);
}

CORBA::Boolean SMESH_MeshEditor_i::SmoothParametric	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::long_array &	IDsOfFixedNodes,
		CORBA::Long	MaxNbOfIterations,
		CORBA::Double	MaxAspectRatio,
		SMESH::SMESH_MeshEditor::Smooth_Method	Method
	)

Definition at line 1371 of file SMESH_MeshEditor_i.cxx.

{
  return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
                 MaxAspectRatio, Method, true );
}

CORBA::Boolean SMESH_MeshEditor_i::SmoothParametricObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::long_array &	IDsOfFixedNodes,
		CORBA::Long	MaxNbOfIterations,
		CORBA::Double	MaxAspectRatio,
		SMESH::SMESH_MeshEditor::Smooth_Method	Method
	)

Definition at line 1405 of file SMESH_MeshEditor_i.cxx.

{
  return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
                       MaxAspectRatio, Method, true);
}

CORBA::Boolean SMESH_MeshEditor_i::SplitQuad	(	const SMESH::long_array &	IDsOfElements,
		CORBA::Boolean	Diag13
	)

Definition at line 1241 of file SMESH_MeshEditor_i.cxx.

References ex21_lamp.faces, and SMDSAbs_Face.

{
  initData();

  SMESHDS_Mesh* aMesh = GetMeshDS();
  TIDSortedElemSet faces;
  arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);

  // Update Python script
  TPythonDump() << "isDone = " << this << ".SplitQuad( "
                << IDsOfElements << ", " << Diag13 << " )";

  ::SMESH_MeshEditor anEditor( myMesh );
  CORBA::Boolean stat = anEditor.QuadToTri( faces, Diag13 );
  myMesh->GetMeshDS()->Modified();
  if ( stat )
    myMesh->SetIsModified( true ); // issue 0020693


  storeResult(anEditor);

  return stat;
}

CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		CORBA::Boolean	Diag13
	)

Definition at line 1272 of file SMESH_MeshEditor_i.cxx.

References ex30_groupsOp.isDone.

{
  initData();

  TPythonDump aTPythonDump;  // suppress dump in SplitQuad()

  SMESH::long_array_var anElementsId = theObject->GetIDs();
  CORBA::Boolean isDone = SplitQuad(anElementsId, Diag13);

  // Update Python script
  aTPythonDump << "isDone = " << this << ".SplitQuadObject( "
               << theObject << ", " << Diag13 << " )";

  return isDone;
}

void SMESH_MeshEditor_i::SplitVolumesIntoTetra	(	SMESH::SMESH_IDSource_ptr	elems,
		CORBA::Short	methodFlags
	)		throw (SALOME::SALOME_Exception)

Split volumic elements into tetrahedrons.

Definition at line 1323 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_Volume.

{
  Unexpect aCatch(SALOME_SalomeException);

  initData();

  SMESH::long_array_var anElementsId = elems->GetIDs();
  TIDSortedElemSet elemSet;
  arrayToSet( anElementsId, GetMeshDS(), elemSet, SMDSAbs_Volume );

  ::SMESH_MeshEditor anEditor (myMesh);
  anEditor.SplitVolumesIntoTetra( elemSet, int( methodFlags ));
  myMesh->GetMeshDS()->Modified();

  storeResult(anEditor);

//   if ( myLastCreatedElems.length() ) - it does not influence Compute()
//     myMesh->SetIsModified( true ); // issue 0020693

  TPythonDump() << this << ".SplitVolumesIntoTetra( "
                << elems << ", " << methodFlags << " )";
}

void SMESH_MeshEditor_i::storeResult

(

::SMESH_MeshEditor &

anEditor

)

[private]

Update myLastCreated* or myPreviewData.

Parameters:

anEditor	- it contains edition results
anEditor	- it contains last modification results

Definition at line 4636 of file SMESH_MeshEditor_i.cxx.

References SMDS_Mesh.elementsIterator(), SMDS_MeshElement.GetID(), SMDS_MeshElement.GetType(), SMDS_MeshElement.IsPoly(), SMDS_Mesh.NbEdges(), SMDS_Mesh.NbFaces(), SMDS_MeshElement.NbNodes(), SMDS_Mesh.NbNodes(), SMDS_Mesh.NbVolumes(), SMDS_MeshElement.nodesIterator(), SMDSAbs_All, SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume, SMDS_MeshNode.X(), SMDS_MeshNode.Y(), and SMDS_MeshNode.Z().

{
  if ( myPreviewMode ) { // --- MeshPreviewStruct filling ---

    list<int> aNodesConnectivity;
    typedef map<int, int> TNodesMap;
    TNodesMap nodesMap;

    TPreviewMesh * aPreviewMesh = dynamic_cast< TPreviewMesh* >( anEditor.GetMesh() );
    SMDSAbs_ElementType previewType = aPreviewMesh->myPreviewType;

    SMESHDS_Mesh* aMeshDS = anEditor.GetMeshDS();
    int nbEdges = aMeshDS->NbEdges();
    int nbFaces = aMeshDS->NbFaces();
    int nbVolum = aMeshDS->NbVolumes();
    switch ( previewType ) {
    case SMDSAbs_Edge  : nbFaces = nbVolum = 0; break;
    case SMDSAbs_Face  : nbEdges = nbVolum = 0; break;
    case SMDSAbs_Volume: nbEdges = nbFaces = 0; break;
    default:;
    }
    myPreviewData->nodesXYZ.length(aMeshDS->NbNodes());
    myPreviewData->elementTypes.length(nbEdges + nbFaces + nbVolum);
    int i = 0, j = 0;
    SMDS_ElemIteratorPtr itMeshElems = aMeshDS->elementsIterator();

    while ( itMeshElems->more() ) {
      const SMDS_MeshElement* aMeshElem = itMeshElems->next();
      if ( previewType != SMDSAbs_All && aMeshElem->GetType() != previewType )
        continue;

      SMDS_ElemIteratorPtr itElemNodes = aMeshElem->nodesIterator();
      while ( itElemNodes->more() ) {
        const SMDS_MeshNode* aMeshNode =
          static_cast<const SMDS_MeshNode*>( itElemNodes->next() );
        int aNodeID = aMeshNode->GetID();
        TNodesMap::iterator anIter = nodesMap.find(aNodeID);
        if ( anIter == nodesMap.end() ) {
          // filling the nodes coordinates
          myPreviewData->nodesXYZ[j].x = aMeshNode->X();
          myPreviewData->nodesXYZ[j].y = aMeshNode->Y();
          myPreviewData->nodesXYZ[j].z = aMeshNode->Z();
          anIter = nodesMap.insert( make_pair(aNodeID, j) ).first;
          j++;
        }
        aNodesConnectivity.push_back(anIter->second);
      }

      // filling the elements types
      SMDSAbs_ElementType aType;
      bool isPoly;
      /*if (aMeshElem->GetType() == SMDSAbs_Volume) {
        aType = SMDSAbs_Node;
        isPoly = false;
        }
        else*/ {
        aType = aMeshElem->GetType();
        isPoly = aMeshElem->IsPoly();
      }

      myPreviewData->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) aType;
      myPreviewData->elementTypes[i].isPoly = isPoly;
      myPreviewData->elementTypes[i].nbNodesInElement = aMeshElem->NbNodes();
      i++;

    }
    myPreviewData->nodesXYZ.length( j );

    // filling the elements connectivities
    list<int>::iterator aConnIter = aNodesConnectivity.begin();
    myPreviewData->elementConnectivities.length(aNodesConnectivity.size());
    for( int i = 0; aConnIter != aNodesConnectivity.end(); aConnIter++, i++ )
      myPreviewData->elementConnectivities[i] = *aConnIter;

    return;
  }

  {
    // append new nodes into myLastCreatedNodes
    const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedNodes();
    int j = myLastCreatedNodes->length();
    int newLen = j + aSeq.Length();
    myLastCreatedNodes->length( newLen );
    for(int i=0; j<newLen; i++,j++)
      myLastCreatedNodes[j] = aSeq.Value(i+1)->GetID();
  }
  {
    // append new elements into myLastCreatedElems
    const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedElems();
    int j = myLastCreatedElems->length();
    int newLen = j + aSeq.Length();
    myLastCreatedElems->length( newLen );
    for(int i=0; j<newLen; i++,j++)
      myLastCreatedElems[j] = aSeq.Value(i+1)->GetID();
  }
}

void SMESH_MeshEditor_i::Translate	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::DirStruct &	Vector,
		CORBA::Boolean	Copy
	)

Definition at line 3257 of file SMESH_MeshEditor_i.cxx.

{
  if (!myPreviewMode) {
    TPythonDump() << this << ".Translate( "
                  << theIDsOfElements << ", "
                  << theVector << ", "
                  << theCopy << " )";
  }
  if (theIDsOfElements.length()) {
    TIDSortedElemSet elements;
    arrayToSet(theIDsOfElements, GetMeshDS(), elements);
    translate(elements, theVector, theCopy, false);
  }
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::translate	(	TIDSortedElemSet &	IDsOfElements,
		const SMESH::DirStruct &	Vector,
		CORBA::Boolean	Copy,
		bool	MakeGroups,
		::SMESH_Mesh *	TargetMesh = 0
	)		[private]

Definition at line 3203 of file SMESH_MeshEditor_i.cxx.

References PAL_MESH_041_mesh.mesh, SMESH.DirStruct.PS, SMESH.PointStruct.x, SMESH.PointStruct.y, and SMESH.PointStruct.z.

{
  initData();

  if ( theTargetMesh )
    theCopy = false;

  gp_Trsf aTrsf;
  const SMESH::PointStruct * P = &theVector.PS;
  aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z ));

  TIDSortedElemSet  copyElements;
  TIDSortedElemSet* workElements = &theElements;
  TPreviewMesh      tmpMesh;
  SMESH_Mesh*       mesh = myMesh;

  if ( myPreviewMode )
  {
    tmpMesh.Copy( theElements, copyElements);
    if ( !theCopy && !theTargetMesh )
    {
      TIDSortedElemSet elemsAround, elemsAroundCopy;
      getElementsAround( theElements, GetMeshDS(), elemsAround );
      tmpMesh.Copy( elemsAround, elemsAroundCopy);
    }
    mesh = &tmpMesh;
    workElements = & copyElements;
    theMakeGroups = false;
  }

  ::SMESH_MeshEditor anEditor( mesh );
  ::SMESH_MeshEditor::PGroupIDs groupIds =
      anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);

  if(theCopy || myPreviewMode)
    storeResult(anEditor);
  else
  {
    myMesh->GetMeshDS()->Modified();
    myMesh->SetIsModified( true );
  }

  return theMakeGroups ? getGroups(groupIds.get()) : 0;
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::TranslateMakeGroups	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::DirStruct &	Vector
	)

Definition at line 3303 of file SMESH_MeshEditor_i.cxx.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups * aGroups = 0;
  if (theIDsOfElements.length()) {
    TIDSortedElemSet elements;
    arrayToSet(theIDsOfElements, GetMeshDS(), elements);
    aGroups = translate(elements,theVector,true,true);
  }
  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".TranslateMakeGroups( "
                << theIDsOfElements << ", "
                << theVector << " )";
  }
  return aGroups;
}

SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::TranslateMakeMesh	(	const SMESH::long_array &	IDsOfElements,
		const SMESH::DirStruct &	Vector,
		CORBA::Boolean	CopyGroups,
		const char *	MeshName
	)

Definition at line 3354 of file SMESH_MeshEditor_i.cxx.

References SMESH_Mesh_i.CreateGroupServants(), SMESH_Mesh_i.GetGroups(), SMESH_Mesh_i.GetImpl(), and PAL_MESH_041_mesh.mesh.

{
  SMESH_Mesh_i* mesh_i;
  SMESH::SMESH_Mesh_var mesh;

  { // open new scope to dump "MakeMesh" command
    // and then "GetGroups" using SMESH_Mesh::GetGroups()

    TPythonDump pydump; // to prevent dump at mesh creation

    mesh = makeMesh( theMeshName );
    mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );

    if ( mesh_i && theIDsOfElements.length() )
    {
      TIDSortedElemSet elements;
      arrayToSet(theIDsOfElements, GetMeshDS(), elements);
      translate(elements, theVector, false, theCopyGroups, & mesh_i->GetImpl());
      mesh_i->CreateGroupServants();
    }

    if ( !myPreviewMode ) {
      pydump << mesh << " = " << this << ".TranslateMakeMesh( "
             << theIDsOfElements << ", "
             << theVector   << ", "
             << theCopyGroups << ", '"
             << theMeshName << "' )";
    }
  }

  //dump "GetGroups"
  if (!myPreviewMode && mesh_i)
    mesh_i->GetGroups();

  return mesh._retn();
}

void SMESH_MeshEditor_i::TranslateObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		const SMESH::DirStruct &	Vector,
		CORBA::Boolean	Copy
	)

Definition at line 3279 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_All.

{
  if (!myPreviewMode) {
    TPythonDump() << this << ".TranslateObject( "
                  << theObject << ", "
                  << theVector << ", "
                  << theCopy << " )";
  }
  TIDSortedElemSet elements;

  bool emptyIfIsMesh = myPreviewMode ? false : true;
  
  if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
    translate(elements, theVector, theCopy, false);
}

SMESH::ListOfGroups * SMESH_MeshEditor_i::TranslateObjectMakeGroups	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::DirStruct &	Vector
	)

Definition at line 3329 of file SMESH_MeshEditor_i.cxx.

References SMDSAbs_All.

{
  TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()

  SMESH::ListOfGroups * aGroups = 0;
  TIDSortedElemSet elements;
  if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
    aGroups = translate(elements, theVector, true, true);

  if (!myPreviewMode) {
    DumpGroupsList(aPythonDump, aGroups);
    aPythonDump << this << ".TranslateObjectMakeGroups( "
                << theObject << ", "
                << theVector << " )";
  }
  return aGroups;
}

SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::TranslateObjectMakeMesh	(	SMESH::SMESH_IDSource_ptr	Object,
		const SMESH::DirStruct &	Vector,
		CORBA::Boolean	CopyGroups,
		const char *	MeshName
	)

Definition at line 3400 of file SMESH_MeshEditor_i.cxx.

References SMESH_Mesh_i.CreateGroupServants(), SMESH_Mesh_i.GetGroups(), SMESH_Mesh_i.GetImpl(), PAL_MESH_041_mesh.mesh, and SMDSAbs_All.

{
  SMESH_Mesh_i* mesh_i;
  SMESH::SMESH_Mesh_var mesh;
  { // open new scope to dump "MakeMesh" command
    // and then "GetGroups" using SMESH_Mesh::GetGroups()

    TPythonDump pydump; // to prevent dump at mesh creation
    mesh = makeMesh( theMeshName );
    mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );

    TIDSortedElemSet elements;
    if ( mesh_i &&
      idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
    {
      translate(elements, theVector,false, theCopyGroups, & mesh_i->GetImpl());
      mesh_i->CreateGroupServants();
    }
    if ( !myPreviewMode ) {
      pydump << mesh << " = " << this << ".TranslateObjectMakeMesh( "
             << theObject << ", "
             << theVector   << ", "
             << theCopyGroups << ", '"
             << theMeshName << "' )";
    }
  }

  // dump "GetGroups"
  if (!myPreviewMode && mesh_i)
    mesh_i->GetGroups();

  return mesh._retn();
}

CORBA::Boolean SMESH_MeshEditor_i::TriToQuad	(	const SMESH::long_array &	IDsOfElements,
		SMESH::NumericalFunctor_ptr	Criterion,
		CORBA::Double	MaxAngle
	)

Definition at line 1112 of file SMESH_MeshEditor_i.cxx.

References ex21_lamp.faces, SMESH.NumericalFunctor_i.GetNumericalFunctor(), SMESH_Gen_i.GetServant(), and SMDSAbs_Face.

{
  initData();

  SMESHDS_Mesh* aMesh = GetMeshDS();
  TIDSortedElemSet faces;
  arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);

  SMESH::NumericalFunctor_i* aNumericalFunctor =
    dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
  SMESH::Controls::NumericalFunctorPtr aCrit;
  if ( !aNumericalFunctor )
    aCrit.reset( new SMESH::Controls::AspectRatio() );
  else
    aCrit = aNumericalFunctor->GetNumericalFunctor();

  // Update Python script
  TPythonDump() << "isDone = " << this << ".TriToQuad( "
                << IDsOfElements << ", " << aNumericalFunctor << ", " << MaxAngle << " )";

  ::SMESH_MeshEditor anEditor( myMesh );

  bool stat = anEditor.TriToQuad( faces, aCrit, MaxAngle );
  myMesh->GetMeshDS()->Modified();
  if ( stat )
    myMesh->SetIsModified( true ); // issue 0020693

  storeResult(anEditor);

  return stat;
}

CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject	(	SMESH::SMESH_IDSource_ptr	theObject,
		SMESH::NumericalFunctor_ptr	Criterion,
		CORBA::Double	MaxAngle
	)

Definition at line 1152 of file SMESH_MeshEditor_i.cxx.

References ex30_groupsOp.isDone.

{
  initData();

  TPythonDump aTPythonDump;  // suppress dump in TriToQuad()
  SMESH::long_array_var anElementsId = theObject->GetIDs();
  CORBA::Boolean isDone = TriToQuad(anElementsId, Criterion, MaxAngle);

  SMESH::NumericalFunctor_i* aNumericalFunctor =
    SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );

  // Update Python script
  aTPythonDump << "isDone = " << this << ".TriToQuadObject("
               << theObject << ", " << aNumericalFunctor << ", " << MaxAngle << " )";

  return isDone;
}

---

Field Documentation

SMESH::long_array_var SMESH_MeshEditor_i.myLastCreatedElems [private]

Definition at line 838 of file SMESH_MeshEditor_i.hxx.

SMESH::long_array_var SMESH_MeshEditor_i.myLastCreatedNodes [private]

Definition at line 839 of file SMESH_MeshEditor_i.hxx.

SMESH_Mesh* SMESH_MeshEditor_i.myMesh [private]

Definition at line 836 of file SMESH_MeshEditor_i.hxx.

Referenced by GetMeshDS(), and GetMeshId().

SMESH_Mesh_i* SMESH_MeshEditor_i.myMesh_i [private]

< fields

Definition at line 835 of file SMESH_MeshEditor_i.hxx.

SMESH::MeshPreviewStruct_var SMESH_MeshEditor_i.myPreviewData [private]

Definition at line 841 of file SMESH_MeshEditor_i.hxx.

bool SMESH_MeshEditor_i.myPreviewMode [private]

Definition at line 842 of file SMESH_MeshEditor_i.hxx.