SET(${PROJECT_NAME_UC}_PATCH_VERSION 0)
SET(${PROJECT_NAME_UC}_VERSION
${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION}.${${PROJECT_NAME_UC}_PATCH_VERSION})
-SET(${PROJECT_NAME_UC}_VERSION_DEV 0)
+SET(${PROJECT_NAME_UC}_VERSION_DEV 1)
# Common CMake macros
# ===================
# create mesh
from SMESH_mechanic import *
# get faces with warping angle = 2.0e-13 with tolerance 5.0e-14
-criterion = smesh.GetCriterion(SMESH.FACE, SMESH.FT_Warping, SMESH.FT_EqualTo, 2.0e-13)
-criterion.Tolerance = 5.0e-14
-filter = smesh.CreateFilterManager().CreateFilter()
-filter.SetCriteria([criterion])
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Warping, "=", 2.0e-13, Tolerance=5.0e-14)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with warping angle = 2.0e-13 (tolerance 5.0e-14):", len(ids)
# create mesh
from SMESH_mechanic import *
# get faces with area > 60 and < 90
-criterion1 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 60,\
- SMESH.FT_Undefined, SMESH.FT_LogicalAND)
+criterion1 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 60)
criterion2 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_Area, SMESH.FT_LessThan, 90)
-filter = smesh.CreateFilterManager().CreateFilter()
-filter.SetCriteria([criterion1,criterion2])
+filter = smesh.GetFilterFromCriteria([criterion1,criterion2], SMESH.FT_LogicalAND)
ids = mesh.GetIdsFromFilter(filter)
print "Number of faces with area in range (60,90):", len(ids)
smesh = smeshBuilder.New(salome.myStudy)
# create mesh
-face = geompy.MakeFaceHW(100, 100, 1)
-geompy.addToStudy( face, "quadrangle" )
+face = geompy.MakeFaceHW(100, 100, 1, theName="quadrangle")
mesh = smesh.Mesh(face)
mesh.Segment().NumberOfSegments(10)
mesh.Triangle().MaxElementArea(25)
return myInfo.NbNodes();
}
+///////////////////////////////////////////////////////////////////////////////
+/// Return the number of elements
+///////////////////////////////////////////////////////////////////////////////
+int SMDS_Mesh::NbElements() const
+{
+ return myInfo.NbElements();
+}
///////////////////////////////////////////////////////////////////////////////
/// Return the number of 0D elements
///////////////////////////////////////////////////////////////////////////////
void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
{
int elemId = elem->GetID();
- int vtkId = elem->getVtkId();
+ int vtkId = elem->getVtkId();
SMDSAbs_ElementType aType = elem->GetType();
- SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
- if (aType == SMDSAbs_Node) {
+ SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
+ if ( aType == SMDSAbs_Node )
+ {
// only free node can be removed by this method
const SMDS_MeshNode* n = static_cast<SMDS_MeshNode*>(todest);
- SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
- if (!itFe->more()) { // free node
+ if ( n->NbInverseElements() == 0 ) { // free node
myNodes[elemId] = 0;
myInfo.myNbNodes--;
((SMDS_MeshNode*) n)->SetPosition(SMDS_SpacePosition::originSpacePosition());
myNodePool->destroy(static_cast<SMDS_MeshNode*>(todest));
myNodeIDFactory->ReleaseID(elemId, vtkId);
}
- } else {
+ }
+ else
+ {
if (hasConstructionEdges() || hasConstructionFaces())
// this methods is only for meshes without descendants
return;
const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
virtual int NbNodes() const;
+ virtual int NbElements() const;
virtual int Nb0DElements() const;
virtual int NbBalls() const;
virtual int NbEdges() const;
SMDS_MeshNode_MyInvIterator(SMDS_Mesh *mesh, vtkIdType* cells, int ncells, SMDSAbs_ElementType type) :
myMesh(mesh), myCells(cells), myNcells(ncells), myType(type), iter(0)
{
- cellList.reserve( ncells );
- if (type == SMDSAbs_All)
- cellList.assign( cells, cells + ncells );
- else
- for (int i = 0; i < ncells; i++)
+ if ( ncells )
+ {
+ cellList.reserve( ncells );
+ if (type == SMDSAbs_All)
+ {
+ cellList.assign( cells, cells + ncells );
+ }
+ else
{
- int vtkId = cells[i];
- int smdsId = myMesh->fromVtkToSmds(vtkId);
- const SMDS_MeshElement* elem = myMesh->FindElement(smdsId);
- if (elem->GetType() == type)
+ for (int i = 0; i < ncells; i++)
{
- cellList.push_back(vtkId);
+ int vtkId = cells[i];
+ int smdsId = myMesh->fromVtkToSmds(vtkId);
+ const SMDS_MeshElement* elem = myMesh->FindElement(smdsId);
+ if (elem->GetType() == type)
+ {
+ cellList.push_back(vtkId);
+ }
}
+ myCells = cellList.empty() ? 0 : &cellList[0];
+ myNcells = cellList.size();
}
- myCells = cellList.empty() ? 0 : &cellList[0];
- myNcells = cellList.size();
+ }
}
bool more()
SMDS_ElemIteratorPtr SMDS_MeshNode::GetInverseElementIterator(SMDSAbs_ElementType type) const
{
- vtkCellLinks::Link l = SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetLinks()->GetLink(myVtkID);
- return SMDS_ElemIteratorPtr(new SMDS_MeshNode_MyInvIterator(SMDS_Mesh::_meshList[myMeshId], l.cells, l.ncells, type));
-}
-
-// Same as GetInverseElementIterator but the created iterator only returns
-// wanted type elements.
-class SMDS_MeshNode_MyIterator:public SMDS_ElemIterator
-{
-private:
- SMDS_Mesh* myMesh;
- vtkIdType* myCells;
- int myNcells;
- SMDSAbs_ElementType myType;
- int iter;
- vector<SMDS_MeshElement*> myFiltCells;
-
-public:
- SMDS_MeshNode_MyIterator(SMDS_Mesh *mesh,
- vtkIdType* cells,
- int ncells,
- SMDSAbs_ElementType type):
- myMesh(mesh), myCells(cells), myNcells(ncells), myType(type), iter(0)
+ if ( SMDS_Mesh::_meshList[myMeshId]->NbElements() > 0 ) // avoid building links
{
- for (; iter<ncells; iter++)
- {
- int vtkId = myCells[iter];
- int smdsId = myMesh->fromVtkToSmds(vtkId);
- const SMDS_MeshElement* elem = myMesh->FindElement(smdsId);
- if (elem->GetType() == type)
- myFiltCells.push_back((SMDS_MeshElement*)elem);
- }
- myNcells = myFiltCells.size();
- iter = 0;
- }
-
- bool more()
- {
- return (iter< myNcells);
+ vtkCellLinks::Link& l = SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetLinks()->GetLink(myVtkID);
+ return SMDS_ElemIteratorPtr(new SMDS_MeshNode_MyInvIterator(SMDS_Mesh::_meshList[myMeshId], l.cells, l.ncells, type));
}
-
- const SMDS_MeshElement* next()
+ else
{
- const SMDS_MeshElement* elem = myFiltCells[iter];
- iter++;
- return elem;
+ return SMDS_ElemIteratorPtr(new SMDS_MeshNode_MyInvIterator(SMDS_Mesh::_meshList[myMeshId], 0, 0, type));
}
-};
+}
-SMDS_ElemIteratorPtr SMDS_MeshNode::
-elementsIterator(SMDSAbs_ElementType type) const
+SMDS_ElemIteratorPtr SMDS_MeshNode::elementsIterator(SMDSAbs_ElementType type) const
{
- if(type==SMDSAbs_Node)
- return SMDS_MeshElement::elementsIterator(SMDSAbs_Node);
+ if ( type == SMDSAbs_Node )
+ return SMDS_MeshElement::elementsIterator( SMDSAbs_Node );
else
- {
- vtkCellLinks::Link l = SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetLinks()->GetLink(myVtkID);
- return SMDS_ElemIteratorPtr(new SMDS_MeshNode_MyIterator(SMDS_Mesh::_meshList[myMeshId], l.cells, l.ncells, type));
- }
+ return GetInverseElementIterator( type );
}
int SMDS_MeshNode::NbNodes() const
/*!
* \brief thread safe getting coords
*/
+//================================================================================
+
void SMDS_MeshNode::GetXYZ(double xyz[3]) const
{
return SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetPoint(myVtkID,xyz);
}
-//* resize the vtkPoints structure every SMDS_Mesh::chunkSize points
+//================================================================================
void SMDS_MeshNode::setXYZ(double x, double y, double z)
{
SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
SMDS_Mesh::_meshList[myMeshId]->getGrid()->ResizeCellList(myVtkID, 0);
}
-bool SMDS_MeshNode::emptyInverseElements()
-{
- vtkCellLinks::Link l = SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetLinks()->GetLink(myVtkID);
- return (l.ncells == 0);
-}
-
//================================================================================
/*!
* \brief Count inverse elements of given type
int SMDS_MeshNode::NbInverseElements(SMDSAbs_ElementType type) const
{
- vtkCellLinks::Link l = SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetLinks()->GetLink(myVtkID);
-
- if ( type == SMDSAbs_All )
- return l.ncells;
-
int nb = 0;
- SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
- for (int i=0; i<l.ncells; i++)
+ if ( SMDS_Mesh::_meshList[myMeshId]->NbElements() > 0 ) // avoid building links
{
- const SMDS_MeshElement* elem = mesh->FindElement(mesh->fromVtkToSmds(l.cells[i]));
- if (elem->GetType() == type)
- nb++;
- }
- return nb;
-}
+ vtkCellLinks::Link& l = SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetLinks()->GetLink(myVtkID);
-///////////////////////////////////////////////////////////////////////////////
-/// To be used with STL set
-///////////////////////////////////////////////////////////////////////////////
-bool operator<(const SMDS_MeshNode& e1, const SMDS_MeshNode& e2)
-{
- return e1.getVtkId()<e2.getVtkId();
- /*if(e1.myX<e2.myX) return true;
- else if(e1.myX==e2.myX)
+ if ( type == SMDSAbs_All )
+ return l.ncells;
+
+ SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
+ for ( int i = 0; i < l.ncells; i++ )
{
- if(e1.myY<e2.myY) return true;
- else if(e1.myY==e2.myY) return (e1.myZ<e2.myZ);
- else return false;
+ const SMDS_MeshElement* elem = mesh->FindElement( mesh->fromVtkToSmds( l.cells[i] ));
+ nb += ( elem->GetType() == type );
}
- else return false;*/
+ }
+ return nb;
}
-
void AddInverseElement(const SMDS_MeshElement * ME);
void RemoveInverseElement(const SMDS_MeshElement * parent);
void ClearInverseElements();
- bool emptyInverseElements();
SMDS_ElemIteratorPtr
elementsIterator(SMDSAbs_ElementType type) const;
SMDS_ElemIteratorPtr faceIter( new TIterOnIter( faceIterVec ));
// a seacher to check if a volume is close to a concave face
- std::auto_ptr< SMESH_ElementSearcher > faceSearcher
+ SMESHUtils::Deleter< SMESH_ElementSearcher > faceSearcher
( SMESH_MeshAlgos::GetElementSearcher( *theHelper.GetMeshDS(), faceIter ));
// classifier
gp_Pnt pMedium = SMESH_TNodeXYZ( linkIt->second );
double hMedium = faceNorm * gp_Vec( pOnFace0, pMedium ).XYZ();
double hVol = faceNorm * gp_Vec( pOnFace0, pInSolid ).XYZ();
- isDistorted = ( Abs( hMedium ) > Abs( hVol * 0.5 ));
+ isDistorted = ( Abs( hMedium ) > Abs( hVol * 0.75 ));
}
}
}
double u = epos->GetUParameter();
paramNodeMap.insert( make_pair( u, node ));
}
- if ((int) paramNodeMap.size() != eSubMesh->NbNodes() ) {
+ if ((int) paramNodeMap.size() != eSubMesh->NbNodes() - nbMeduimNodes ) {
// wrong U on edge, project
Extrema_ExtPC proj;
BRepAdaptor_Curve aCurve( edge );
std::for_each( myPlanes.begin(),myPlanes.end(), TSetVisibility( PreviewCheckBox->isChecked() ) );
aPlaneData.Plane.GetPointer()->myActor->SetVisibility( false );
+ std::map< std::string, QListWidgetItem* > itemMap; // used to sort items by entry
+
VTK::ActorCollectionCopy aCopy( myViewWindow->getRenderer()->GetActors() );
vtkActorCollection* anAllActors = aCopy.GetActors();
anAllActors->InitTraversal();
if ( !aFatherName.isEmpty() )
aName = aFatherName + " / " + aName;
aName += QString(" (%1)").arg( aSObj->GetID().c_str() );
- QListWidgetItem* anItem = new ActorItem( anActor, aName, ActorList );
+ QListWidgetItem* anItem = new ActorItem( anActor, aName, 0 );
anItem->setCheckState( anIsChecked ? Qt::Checked : Qt::Unchecked );
- updateActorItem( anItem, true, false );
+ itemMap.insert( std::make_pair( aSObj->GetID(), anItem ));
}
}
}
}
+ std::map< std::string, QListWidgetItem* >::iterator s2i = itemMap.begin();
+ for ( ; s2i != itemMap.end(); ++s2i )
+ {
+ QListWidgetItem* anItem = s2i->second;
+ ActorList->addItem( anItem );
+ }
+ updateActorItem( 0, true, false );
}
/*!
SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New(myViewWindow);
SMESH::TPlane aTPlane(aPlane);
aPlane->PlaneMode = CurrentMode;
- SMESH::TActorList anActorList;
+ SMESH::TActorList anActorList, aVisibleActorList;
VTK::ActorCollectionCopy aCopy( myViewWindow->getRenderer()->GetActors() );
vtkActorCollection* anAllActors = aCopy.GetActors();
anAllActors->InitTraversal();
while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
+ {
anActorList.push_back( anActor );
-
- SMESH::TPlaneData aPlaneData(aTPlane, anActorList);
-
+ if ( anActor->GetVisibility() )
+ aVisibleActorList.push_back( anActor );
+ }
+ SMESH::TPlaneData aPlaneData(aTPlane,
+ aVisibleActorList.empty() ? anActorList : aVisibleActorList);
myPlanes.push_back(aPlaneData);
myDY->SetValue(0);
myDZ->SetValue(0);
- myDX->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
- myDY->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
- myDZ->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
+ myDX->RangeStepAndValidator(COORD_MIN, COORD_MAX, 1.0, "length_precision");
+ myDY->RangeStepAndValidator(COORD_MIN, COORD_MAX, 1.0, "length_precision");
+ myDZ->RangeStepAndValidator(COORD_MIN, COORD_MAX, 1.0, "length_precision");
width = Max( aFaceBut->fontMetrics().width( tr("SMESH_X")),
aFaceBut->fontMetrics().width( tr("SMESH_DX")));
gp_Vec edge2( xyz[i+1], xyz[(i+2)%nbNodes] );
faceNorm += edge1 ^ edge2;
}
- double normSize = faceNorm.Magnitude();
- if ( normSize <= tol )
+ double fNormSize = faceNorm.Magnitude();
+ if ( fNormSize <= tol )
{
// degenerated face: point is out if it is out of all face edges
for ( i = 0; i < nbNodes; ++i )
}
return true;
}
- faceNorm /= normSize;
+ faceNorm /= fNormSize;
// check if the point lays on face plane
gp_Vec n2p( xyz[0], point );
// to find intersections of the ray with the boundary.
gp_Vec ray = n2p;
gp_Vec plnNorm = ray ^ faceNorm;
- normSize = plnNorm.Magnitude();
- if ( normSize <= tol ) return false; // point coincides with the first node
- plnNorm /= normSize;
+ double n2pSize = plnNorm.Magnitude();
+ if ( n2pSize <= tol ) return false; // point coincides with the first node
+ if ( n2pSize * n2pSize > fNormSize * 100 ) return true; // point is very far
+ plnNorm /= n2pSize;
// for each node of the face, compute its signed distance to the cutting plane
vector<double> dist( nbNodes + 1);
for ( i = 0; i < nbNodes; ++i )
if ( rClosest > 0. && rClosest < 1. ) // not node intersection
return out;
- // ray pass through a face node; analyze transition through an adjacent edge
+ // the ray passes through a face node; analyze transition through an adjacent edge
gp_Pnt p1 = xyz[ (rClosest == 0.) ? ((iClosest+nbNodes-1) % nbNodes) : (iClosest+1) ];
gp_Pnt p2 = xyz[ (rClosest == 0.) ? iClosest : ((iClosest+2) % nbNodes) ];
gp_Vec edgeAdjacent( p1, p2 );
# 1 - the medium node lies at the middle of the line segments connecting two nodes of a mesh element
# @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal
# @param theToBiQuad If True, converts the mesh to bi-quadratic
+ # @return SMESH.ComputeError which can hold a warning
# @ingroup l2_modif_tofromqu
def ConvertToQuadratic(self, theForce3d=False, theSubMesh=None, theToBiQuad=False):
if isinstance( theSubMesh, Mesh ):
error = self.editor.GetLastError()
if error and error.comment:
print error.comment
+ return error
## Converts the mesh from quadratic to ordinary,
# deletes old quadratic elements, \n replacing
## Private method.
def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
if geom is None and mesh.mesh.HasShapeToMesh():
- raise RuntimeError, "Attemp to create " + hypo + " algoritm on None shape"
+ raise RuntimeError, "Attemp to create " + hypo + " algorithm on None shape"
algo = self.FindAlgorithm(hypo, mesh.smeshpyD)
if algo is None:
algo = mesh.smeshpyD.CreateHypothesis(hypo, so)
def Assign(self, algo, mesh, geom):
from salome.smesh.smeshBuilder import AssureGeomPublished, TreatHypoStatus, GetName
if geom is None and mesh.mesh.HasShapeToMesh():
- raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape"
+ raise RuntimeError, "Attemp to create " + algo + " algorithm on None shape"
self.mesh = mesh
if not geom or geom.IsSame( mesh.geom ):
self.geom = mesh.geom
using namespace std;
#define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; }
+#ifdef _DEBUG_
+// enable printing algo + projection shapes while meshing
+//#define PRINT_WHO_COMPUTE_WHAT
+#endif
namespace TAssocTool = StdMeshers_ProjectionUtils;
//typedef StdMeshers_ProjectionUtils TAssocTool;
if (( err && !err->IsOK() ) ||
( srcWires.empty() ))
return err;
-
+#ifdef PRINT_WHO_COMPUTE_WHAT
+ cout << "Projection_2D" << " F "
+ << tgtMesh->GetMeshDS()->ShapeToIndex( tgtFace ) << " <- "
+ << srcMesh->GetMeshDS()->ShapeToIndex( srcFace ) << endl;
+#endif
SMESH_MesherHelper srcHelper( *srcMesh );
srcHelper.SetSubShape( srcFace );
for ( int iE = 0; iE < srcWire->NbEdges(); ++iE )
{
+#ifdef PRINT_WHO_COMPUTE_WHAT
+ if ( tgtMesh->GetSubMesh( tgtWire->Edge(iE) )->IsEmpty() )
+ cout << "Projection_2D" << " E "
+ << tgtWire->EdgeID(iE) << " <- " << srcWire->EdgeID(iE) << endl;
+#endif
if ( srcMesh->GetSubMesh( srcWire->Edge(iE) )->IsEmpty() ||
tgtMesh->GetSubMesh( tgtWire->Edge(iE) )->IsEmpty() )
{
gp_XYZ vert1 = P2.XYZ();
gp_XYZ vert2 = P3.XYZ();
- /* calculate distance from vert0 to ray origin */
- gp_XYZ tvec = orig - vert0;
-
gp_XYZ edge1 = vert1 - vert0;
gp_XYZ edge2 = vert2 - vert0;
/* if determinant is near zero, ray lies in plane of triangle */
double det = edge1 * pvec;
- if (det > -EPSILON && det < EPSILON)
+ const double ANGL_EPSILON = 1e-12;
+ if ( det > -ANGL_EPSILON && det < ANGL_EPSILON )
return false;
+ /* calculate distance from vert0 to ray origin */
+ gp_XYZ tvec = orig - vert0;
+
/* calculate U parameter and test bounds */
double u = ( tvec * pvec ) / det;
//if (u < 0.0 || u > 1.0)
<source>ICON_SMESH_TREE_ALGO_Projection_2D</source>
<translation>mesh_tree_algo_projection_2d.png</translation>
</message>
+ <message>
+ <source>ICON_SMESH_TREE_ALGO_Projection_1D2D</source>
+ <translation>mesh_tree_algo_projection_2d.png</translation>
+ </message>
<message>
<source>ICON_SMESH_TREE_ALGO_Projection_3D</source>
<translation>mesh_tree_hypo_projection_3d.png</translation>
<source>ICON_SMESH_TREE_HYPO_QuadranglePreference</source>
<translation>mesh_tree_algo_quad.png</translation>
</message>
+ <message>
+ <source>ICON_SMESH_TREE_HYPO_QuadrangleParams</source>
+ <translation>mesh_tree_algo_quad.png</translation>
+ </message>
<message>
<source>ICON_SMESH_TREE_HYPO_TrianglePreference</source>
<translation>mesh_tree_algo_mefisto.png</translation>
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA )
{
- MESSAGE( "StdMeshers_AutomaticLength_i::StdMeshers_AutomaticLength_i" );
myBaseImpl = new ::StdMeshers_AutomaticLength( theGenImpl->GetANewId(),
theStudyId,
theGenImpl );
StdMeshers_AutomaticLength_i::~StdMeshers_AutomaticLength_i()
{
- MESSAGE( "StdMeshers_AutomaticLength_i::~StdMeshers_AutomaticLength_i" );
}
//=============================================================================
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA )
{
- MESSAGE( "StdMeshers_SegmentLengthAroundVertex_i::StdMeshers_SegmentLengthAroundVertex_i" );
myBaseImpl = new ::StdMeshers_SegmentLengthAroundVertex( theGenImpl->GetANewId(),
theStudyId,
theGenImpl );
StdMeshers_SegmentLengthAroundVertex_i::~StdMeshers_SegmentLengthAroundVertex_i()
{
- MESSAGE( "StdMeshers_SegmentLengthAroundVertex_i::~StdMeshers_SegmentLengthAroundVertex_i" );
}
//=============================================================================
void StdMeshers_SegmentLengthAroundVertex_i::SetLength( CORBA::Double theLength )
throw ( SALOME::SALOME_Exception )
{
- MESSAGE( "StdMeshers_SegmentLengthAroundVertex_i::SetLength" );
ASSERT( myBaseImpl );
try {
this->GetImpl()->SetLength( theLength );
CORBA::Double StdMeshers_SegmentLengthAroundVertex_i::GetLength()
{
- MESSAGE( "StdMeshers_SegmentLengthAroundVertex_i::GetLength" );
ASSERT( myBaseImpl );
return this->GetImpl()->GetLength();
}
::StdMeshers_SegmentLengthAroundVertex* StdMeshers_SegmentLengthAroundVertex_i::GetImpl()
{
- MESSAGE( "StdMeshers_SegmentLengthAroundVertex_i::GetImpl" );
return ( ::StdMeshers_SegmentLengthAroundVertex* )myBaseImpl;
}
