std::map< int, BLSURFPlugin_Hypothesis::TEnfVertexCoordsList > FaceId2EnforcedVertexCoords;
std::map< BLSURFPlugin_Hypothesis::TEnfVertexCoords, BLSURFPlugin_Hypothesis::TEnfVertexCoords > EnfVertexCoords2ProjVertex;
std::map< BLSURFPlugin_Hypothesis::TEnfVertexCoords, BLSURFPlugin_Hypothesis::TEnfVertexList > EnfVertexCoords2EnfVertexList;
+SMESH_MesherHelper* theHelper;
bool HasSizeMapOnFace=false;
bool HasSizeMapOnEdge=false;
*/
//=============================================================================
-BLSURFPlugin_BLSURF::BLSURFPlugin_BLSURF(int hypId, int studyId,
- SMESH_Gen* gen)
+BLSURFPlugin_BLSURF::BLSURFPlugin_BLSURF(int hypId,
+ int studyId,
+ SMESH_Gen* gen,
+ bool theHasGEOM)
: SMESH_2D_Algo(hypId, studyId, gen)
{
- _name = "MG-CADSurf";//"BLSURF";
+ _name = theHasGEOM ? "MG-CADSurf" : "MG-CADSurf_NOGEOM";//"BLSURF";
_shapeType = (1 << TopAbs_FACE); // 1 bit /shape type
- _compatibleHypothesis.push_back(BLSURFPlugin_Hypothesis::GetHypType());
- _compatibleHypothesis.push_back(StdMeshers_ViscousLayers2D::GetHypType());
+ _compatibleHypothesis.push_back(BLSURFPlugin_Hypothesis::GetHypType(theHasGEOM));
+ if ( theHasGEOM )
+ _compatibleHypothesis.push_back(StdMeshers_ViscousLayers2D::GetHypType());
_requireDiscreteBoundary = false;
_onlyUnaryInput = false;
_hypothesis = NULL;
_supportSubmeshes = true;
+ _requireShape = theHasGEOM;
smeshGen_i = SMESH_Gen_i::GetSMESHGen();
CORBA::Object_var anObject = smeshGen_i->GetNS()->Resolve("/myStudyManager");
{
theHyp = *itl;
string hypName = theHyp->GetName();
- if ( hypName == BLSURFPlugin_Hypothesis::GetHypType() )
+ if ( hypName == BLSURFPlugin_Hypothesis::GetHypType(true) ||
+ hypName == BLSURFPlugin_Hypothesis::GetHypType(false) )
{
_hypothesis = static_cast<const BLSURFPlugin_Hypothesis*> (theHyp);
ASSERT(_hypothesis);
gp_XY uv;
gp_XYZ xyz;
} projectionPoint;
+
/////////////////////////////////////////////////////////
-projectionPoint getProjectionPoint(const TopoDS_Face& face, const gp_Pnt& point)
+
+projectionPoint getProjectionPoint(const TopoDS_Face& theFace, const gp_Pnt& thePoint)
{
projectionPoint myPoint;
- Handle(Geom_Surface) surface = BRep_Tool::Surface(face);
- GeomAPI_ProjectPointOnSurf projector( point, surface );
- if ( !projector.IsDone() || projector.NbPoints()==0 )
- throw "getProjectionPoint: Can't project";
-
- Quantity_Parameter u,v;
- projector.LowerDistanceParameters(u,v);
- myPoint.uv = gp_XY(u,v);
- gp_Pnt aPnt = projector.NearestPoint();
- myPoint.xyz = gp_XYZ(aPnt.X(),aPnt.Y(),aPnt.Z());
- //return gp_XY(u,v);
- return myPoint;
-}
-/////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////
-double getT(const TopoDS_Edge& edge, const gp_Pnt& point)
-{
- Standard_Real f,l;
- Handle(Geom_Curve) curve = BRep_Tool::Curve(edge, f,l);
- GeomAPI_ProjectPointOnCurve projector( point, curve);
- if ( projector.NbPoints() == 0 )
- throw;
- return projector.LowerDistanceParameter();
+ if ( theFace.IsNull() )
+ {
+ TopoDS_Shape foundFace, myShape = theHelper->GetSubShape();
+ TopTools_MapOfShape checkedFaces;
+ std::map< double, std::pair< TopoDS_Face, gp_Pnt2d > > dist2face;
+
+ for ( TopExp_Explorer exp ( myShape, TopAbs_FACE ); exp.More(); exp.Next())
+ {
+ const TopoDS_Face& face = TopoDS::Face( exp.Current() );
+ if ( !checkedFaces.Add( face )) continue;
+
+ // check distance to face
+ Handle(ShapeAnalysis_Surface) surface = theHelper->GetSurface( face );
+ gp_Pnt2d uv = surface->ValueOfUV( thePoint, Precision::Confusion());
+ double distance = surface->Gap();
+ if ( distance > Precision::Confusion() )
+ {
+ // the face is far, store for future analysis
+ dist2face.insert( std::make_pair( distance, std::make_pair( face, uv )));
+ }
+ else
+ {
+ // check location on the face
+ BRepClass_FaceClassifier FC( face, uv, Precision::Confusion());
+ if ( FC.State() == TopAbs_IN )
+ {
+ foundFace = face;
+ myPoint.uv = uv.XY();
+ myPoint.xyz = surface->Value( uv ).XYZ();
+ break;
+ }
+ }
+ }
+ if ( foundFace.IsNull() )
+ {
+ // find the closest face
+ std::map< double, std::pair< TopoDS_Face, gp_Pnt2d > >::iterator d2f = dist2face.begin();
+ for ( ; d2f != dist2face.end(); ++d2f )
+ {
+ const TopoDS_Face& face = d2f->second.first;
+ const gp_Pnt2d & uv = d2f->second.second;
+ BRepClass_FaceClassifier FC( face, uv, Precision::Confusion());
+ if ( FC.State() == TopAbs_IN )
+ {
+ foundFace = face;
+ myPoint.uv = uv.XY();
+ myPoint.xyz = theHelper->GetSurface( face )->Value( uv ).XYZ();
+ break;
+ }
+ }
+ }
+ // set the resultShape
+ if ( foundFace.IsNull() )
+ throw SMESH_ComputeError(COMPERR_BAD_PARMETERS,
+ "getProjectionPoint: can't find a face by a vertex");
+ }
+ else
+ {
+ Handle(Geom_Surface) surface = BRep_Tool::Surface( theFace );
+ GeomAPI_ProjectPointOnSurf projector( thePoint, surface );
+ if ( !projector.IsDone() || projector.NbPoints()==0 )
+ throw SMESH_ComputeError(COMPERR_BAD_PARMETERS,
+ "getProjectionPoint: can't project a vertex to a face");
+
+ Quantity_Parameter u,v;
+ projector.LowerDistanceParameters(u,v);
+ myPoint.uv = gp_XY(u,v);
+ gp_Pnt aPnt = projector.NearestPoint();
+ myPoint.xyz = gp_XYZ(aPnt.X(),aPnt.Y(),aPnt.Z());
+ }
+
+ return myPoint;
}
/////////////////////////////////////////////////////////
}
}
}
-
-/*!
- * \brief Find geom faces supporting given points
- */
-TopoDS_Shape BLSURFPlugin_BLSURF::
-findFaces( const BLSURFPlugin_Hypothesis::TEnfVertexList& enfVertexList )
-{
- // get points from enfVertexList
- vector< gp_Pnt > points;
- BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator enfVertexListIt = enfVertexList.begin();
- for( ; enfVertexListIt != enfVertexList.end() ; ++enfVertexListIt )
- {
- BLSURFPlugin_Hypothesis::TEnfVertex * enfVertex = *enfVertexListIt;
- if ( enfVertex->coords.size() >= 3 )
- {
- points.push_back( gp_Pnt( enfVertex->coords[0], enfVertex->coords[1], enfVertex->coords[2]));
- }
- else
- {
- TopoDS_Shape GeomShape = entryToShape( enfVertex->geomEntry );
- if ( !GeomShape.IsNull() )
- {
- if ( GeomShape.ShapeType() == TopAbs_VERTEX )
- points.push_back( BRep_Tool::Pnt( TopoDS::Vertex( GeomShape )));
-
- else if ( GeomShape.ShapeType() == TopAbs_COMPOUND)
- for (TopoDS_Iterator it (GeomShape); it.More(); it.Next())
- if ( it.Value().ShapeType() == TopAbs_VERTEX )
- points.push_back( BRep_Tool::Pnt( TopoDS::Vertex( it.Value() )));
- }
- }
- }
-
- TopoDS_Shape resultShape, myShape = myHelper->GetSubShape();
- TopoDS_Compound compound;
-
- for ( size_t i = 0; i <= points.size(); ++i )
- {
- TopoDS_Face foundFace;
- TopTools_MapOfShape checkedFaces;
- std::map< double, std::pair< TopoDS_Face, gp_Pnt2d > > dist2face;
-
- for ( TopExp_Explorer exp ( myShape, TopAbs_FACE ); exp.More(); exp.Next())
- {
- const TopoDS_Face& face = TopoDS::Face( exp.Current() );
- if ( !checkedFaces.Add( face )) continue;
-
- // check distance to face
- Handle(ShapeAnalysis_Surface) surface = myHelper->GetSurface( face );
- gp_Pnt2d uv = surface->ValueOfUV( points[i], Precision::Confusion());
- double distance = surface->Gap();
- if ( distance > Precision::Confusion() )
- {
- // the face is far, store for future analysis
- dist2face.insert( std::make_pair( distance, std::make_pair( face, uv )));
- }
- else
- {
- // check location on the face
- BRepClass_FaceClassifier FC( face, uv, Precision::Confusion());
- if ( FC.State() == TopAbs_IN )
- {
- foundFace = face;
- break;
- }
- }
- }
- if ( foundFace.IsNull() )
- {
- // find the closest face
- std::map< double, std::pair< TopoDS_Face, gp_Pnt2d > >::iterator d2f = dist2face.begin();
- for ( ; d2f != dist2face.end(); ++d2f )
- {
- const TopoDS_Face& face = d2f->second.first;
- const gp_Pnt2d & uv = d2f->second.second;
- BRepClass_FaceClassifier FC( face, uv, Precision::Confusion());
- if ( FC.State() == TopAbs_IN )
- {
- foundFace = face;
- break;
- }
- }
- }
- // set the resultShape
- if ( !foundFace.IsNull() )
- {
- if ( resultShape.IsNull() )
- {
- resultShape = foundFace;
- }
- else
- {
- BRep_Builder builder;
- if ( compound.IsNull() )
- {
- builder.MakeCompound( compound );
- resultShape = compound;
- }
- builder.Add( compound, foundFace );
- }
- }
- } // loop on points
-
- return resultShape;
-}
-
+
/////////////////////////////////////////////////////////
void BLSURFPlugin_BLSURF::createEnforcedVertexOnFace(TopoDS_Shape faceShape, BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList)
{
void BLSURFPlugin_BLSURF::SetParameters(const BLSURFPlugin_Hypothesis* hyp,
cadsurf_session_t * css,
- const TopoDS_Shape& theGeomShape
- )
+ const TopoDS_Shape& theGeomShape)
{
// rnc : Bug 1457
// Clear map so that it is not stored in the algorithm with old enforced vertices in it
+ FacesWithSizeMap.Clear();
+ FaceId2SizeMap.clear();
+ EdgesWithSizeMap.Clear();
+ EdgeId2SizeMap.clear();
+ VerticesWithSizeMap.Clear();
+ VertexId2SizeMap.clear();
+ FaceId2PythonSmp.clear();
+ EdgeId2PythonSmp.clear();
+ VertexId2PythonSmp.clear();
+ FaceId2AttractorCoords.clear();
+ FaceId2ClassAttractor.clear();
+ FaceIndex2ClassAttractor.clear();
+ FacesWithEnforcedVertices.Clear();
+ FaceId2EnforcedVertexCoords.clear();
+ EnfVertexCoords2ProjVertex.clear();
EnfVertexCoords2EnfVertexList.clear();
double diagonal = SMESH_Mesh::GetShapeDiagonalSize( theGeomShape );
GeomShape = entryToShape(enfIt->first);
if ( GeomShape.IsNull() )
{
- GeomShape = findFaces( enfIt->second );
- if ( GeomShape.IsNull() )
- continue;
+ createEnforcedVertexOnFace( GeomShape, enfIt->second );
}
// Group Management
- if ( GeomShape.ShapeType() == TopAbs_COMPOUND){
+ else if ( GeomShape.ShapeType() == TopAbs_COMPOUND)
+ {
for (TopoDS_Iterator it (GeomShape); it.More(); it.Next()){
if (it.Value().ShapeType() == TopAbs_FACE){
HasSizeMapOnFace = true;
}
}
}
- if ( GeomShape.ShapeType() == TopAbs_FACE){
+ else if ( GeomShape.ShapeType() == TopAbs_FACE)
+ {
HasSizeMapOnFace = true;
createEnforcedVertexOnFace(GeomShape, enfIt->second);
}
/*!
* \brief Class correctly terminating usage of MG-CADSurf library at destruction
*/
- class BLSURF_Cleaner
+ struct BLSURF_Cleaner
{
- context_t * _ctx;
+ context_t * _ctx;
cadsurf_session_t* _css;
- cad_t * _cad;
- dcad_t * _dcad;
- public:
- BLSURF_Cleaner(context_t * ctx,
- cadsurf_session_t* css,
- cad_t * cad,
- dcad_t * dcad)
+ cad_t * _cad;
+ dcad_t * _dcad;
+
+ BLSURF_Cleaner(context_t * ctx,
+ cadsurf_session_t* css=0,
+ cad_t * cad=0,
+ dcad_t * dcad=0)
: _ctx ( ctx ),
_css ( css ),
_cad ( cad ),
*/
//=============================================================================
-bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape) {
-
+bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
+{
// Fix problem with locales
Kernel_Utils::Localizer aLocalizer;
SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
SMESH_MesherHelper helper( aMesh ), helperWithShape( aMesh );
- myHelper = & helperWithShape;
+ myHelper = theHelper = & helperWithShape;
// do not call helper.IsQuadraticSubMesh() because sub-meshes
// may be cleaned and helper.myTLinkNodeMap gets invalid in such a case
bool haveQuadraticSubMesh = helperWithShape.IsQuadraticSubMesh( aShape );
cad_t *c = cad_new(ctx);
dcad_t *dcad = dcad_new(c);
- FacesWithSizeMap.Clear();
- FaceId2SizeMap.clear();
- FaceId2ClassAttractor.clear();
- FaceIndex2ClassAttractor.clear();
- EdgesWithSizeMap.Clear();
- EdgeId2SizeMap.clear();
- VerticesWithSizeMap.Clear();
- VertexId2SizeMap.clear();
-
/* Now fill the CAD object with data from your CAD
* environement. This is the most complex part of a successfull
* integration.
return ( status == STATUS_OK && !quadraticSubMeshAndViscousLayer );
}
+//================================================================================
+/*!
+ * \brief Compute a mesh basing on discrete CAD description
+ */
+//================================================================================
+
+bool BLSURFPlugin_BLSURF::Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper)
+{
+ if ( aMesh.NbFaces() == 0 )
+ return error( COMPERR_BAD_INPUT_MESH, "2D elements are missing" );
+
+ context_t *ctx = context_new();
+ if (!ctx) return error("Pb in context_new()");
+
+ BLSURF_Cleaner cleaner( ctx );
+
+ message_cb_user_data mcud;
+ mcud._error = & this->SMESH_Algo::_comment;
+ mcud._progress = & this->SMESH_Algo::_progress;
+ mcud._verbosity =
+ _hypothesis ? _hypothesis->GetVerbosity() : BLSURFPlugin_Hypothesis::GetDefaultVerbosity();
+ meshgems_status_t ret = context_set_message_callback(ctx, message_cb, &mcud);
+ if (ret != STATUS_OK) return error("Pb. in context_set_message_callback() ");
+
+ cadsurf_session_t * css = cadsurf_session_new(ctx);
+ if(!css) return error( "Pb. in cadsurf_session_new() " );
+ cleaner._css = css;
+
+
+ // Fill an input mesh
+
+ mesh_t * msh = meshgems_mesh_new_in_memory( ctx );
+ if ( !msh ) return error("Pb. in meshgems_mesh_new_in_memory()");
+
+ // mark nodes used by 2D elements
+ SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+ SMDS_NodeIteratorPtr nodeIt = meshDS->nodesIterator();
+ while ( nodeIt->more() )
+ {
+ const SMDS_MeshNode* n = nodeIt->next();
+ n->setIsMarked( n->NbInverseElements( SMDSAbs_Face ));
+ }
+ meshgems_mesh_set_vertex_count( msh, meshDS->NbNodes() );
+
+ // set node coordinates
+ if ( meshDS->NbNodes() != meshDS->MaxNodeID() )
+ {
+ meshDS->compactMesh();
+ }
+ SMESH_TNodeXYZ nXYZ;
+ nodeIt = meshDS->nodesIterator();
+ meshgems_integer i;
+ for ( i = 1; nodeIt->more(); ++i )
+ {
+ nXYZ.Set( nodeIt->next() );
+ meshgems_mesh_set_vertex_coordinates( msh, i, nXYZ._xyz );
+ }
+
+ // set nodes of faces
+ meshgems_mesh_set_triangle_count ( msh, meshDS->GetMeshInfo().NbTriangles() );
+ meshgems_mesh_set_quadrangle_count( msh, meshDS->GetMeshInfo().NbQuadrangles() );
+ meshgems_integer nodeIDs[4];
+ meshgems_integer iT = 1, iQ = 1;
+ SMDS_FaceIteratorPtr faceIt = meshDS->facesIterator();
+ while ( faceIt->more() )
+ {
+ const SMDS_MeshElement* face = faceIt->next();
+ meshgems_integer nbNodes = face->NbCornerNodes();
+ if ( nbNodes > 4 || face->IsPoly() ) continue;
+
+ for ( i = 0; i < nbNodes; ++i )
+ nodeIDs[i] = face->GetNode( i )->GetID();
+ if ( nbNodes == 3 )
+ meshgems_mesh_set_triangle_vertices ( msh, iT++, nodeIDs );
+ else
+ meshgems_mesh_set_quadrangle_vertices( msh, iQ++, nodeIDs );
+ }
+
+ ret = cadsurf_set_mesh(css, msh);
+ if ( ret != STATUS_OK ) return error("Pb in cadsurf_set_mesh()");
+
+
+ // Compute the mesh
+
+ SetParameters(_hypothesis, css, aMesh.GetShapeToMesh() );
+
+ ret = cadsurf_compute_mesh(css);
+ if ( ret != STATUS_OK ) return false;
+
+ mesh_t *omsh = 0;
+ cadsurf_get_mesh(css, &omsh);
+ if ( !omsh ) return error( "Pb. in cadsurf_get_mesh()" );
+
+
+ // Update SALOME mesh
+
+ // remove quadrangles and triangles
+ for ( faceIt = meshDS->facesIterator(); faceIt->more(); )
+ {
+ const SMDS_MeshElement* face = faceIt->next();
+ if ( !face->IsPoly() )
+ meshDS->RemoveFreeElement( face, /*sm=*/0, /*fromGroups=*/true );
+ }
+ // remove edges that bound the just removed faces
+ for ( SMDS_EdgeIteratorPtr edgeIt = meshDS->edgesIterator(); edgeIt->more(); )
+ {
+ const SMDS_MeshElement* edge = edgeIt->next();
+ const SMDS_MeshNode* n0 = edge->GetNode(0);
+ const SMDS_MeshNode* n1 = edge->GetNode(1);
+ if ( n0->isMarked() &&
+ n1->isMarked() &&
+ n0->NbInverseElements( SMDSAbs_Volume ) == 0 &&
+ n1->NbInverseElements( SMDSAbs_Volume ) == 0 )
+ meshDS->RemoveFreeElement( edge, /*sm=*/0, /*fromGroups=*/true );
+ }
+ // remove nodes that just became free
+ for ( nodeIt = meshDS->nodesIterator(); nodeIt->more(); )
+ {
+ const SMDS_MeshNode* n = nodeIt->next();
+ if ( n->isMarked() && n->NbInverseElements() == 0 )
+ meshDS->RemoveFreeNode( n, /*sm=*/0, /*fromGroups=*/true );
+ }
+
+ // add nodes
+ meshgems_integer nbvtx = 0, nodeID;
+ meshgems_mesh_get_vertex_count( omsh, &nbvtx );
+ meshgems_real xyz[3];
+ for ( i = 1; i <= nbvtx; ++i )
+ {
+ meshgems_mesh_get_vertex_coordinates( omsh, i, xyz );
+ SMDS_MeshNode* n = meshDS->AddNode( xyz[0], xyz[1], xyz[2] );
+ nodeID = n->GetID();
+ meshgems_mesh_set_vertex_tag( omsh, i, &nodeID ); // save mapping of IDs in MG and SALOME meshes
+ }
+
+ // add triangles
+ meshgems_integer nbtri = 0;
+ meshgems_mesh_get_triangle_count( omsh, &nbtri );
+ const SMDS_MeshNode* nodes[3];
+ for ( i = 1; i <= nbtri; ++i )
+ {
+ meshgems_mesh_get_triangle_vertices( omsh, i, nodeIDs );
+ for ( int j = 0; j < 3; ++j )
+ {
+ meshgems_mesh_get_vertex_tag( omsh, nodeIDs[j], &nodeID );
+ nodes[j] = meshDS->FindNode( nodeID );
+ }
+ meshDS->AddFace( nodes[0], nodes[1], nodes[2] );
+ }
+
+ cadsurf_regain_mesh(css, omsh);
+
+ // as we don't assign the new triangles to a shape (the pseudo-shape),
+ // we mark the shape as always computed to avoid the error messages
+ // that no elements assigned to the shape
+ aMesh.GetSubMesh( aHelper->GetSubShape() )->SetIsAlwaysComputed( true );
+
+ return true;
+}
+
//================================================================================
/*!
* \brief Terminates computation
*/
//=============================================================================
-void BLSURFPlugin_BLSURF::Set_NodeOnEdge(SMESHDS_Mesh* meshDS, const SMDS_MeshNode* node, const TopoDS_Shape& ed) {
+void BLSURFPlugin_BLSURF::Set_NodeOnEdge(SMESHDS_Mesh* meshDS,
+ const SMDS_MeshNode* node,
+ const TopoDS_Shape& ed)
+{
const TopoDS_Edge edge = TopoDS::Edge(ed);
gp_Pnt pnt(node->X(), node->Y(), node->Z());
* Constructor
*/
//=============================================================================
-BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr thePOA, int theStudyId,
- ::SMESH_Gen* theGenImpl) :
- SALOME::GenericObj_i(thePOA), SMESH_Hypothesis_i(thePOA) {
- MESSAGE( "BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i" );
- myBaseImpl = new ::BLSURFPlugin_Hypothesis(theGenImpl->GetANewId(), theStudyId, theGenImpl);
+BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl,
+ bool theHasGEOM) :
+ SALOME::GenericObj_i(thePOA), SMESH_Hypothesis_i(thePOA)
+{
+ myBaseImpl = new ::BLSURFPlugin_Hypothesis(theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl,
+ theHasGEOM);
}
//=============================================================================
* Destructor
*/
//=============================================================================
-BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i() {
- MESSAGE( "BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i" );
+BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i()
+{
}
//=============================================================================
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh(CORBA::Long theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhysicalMesh");
+void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh(CORBA::Long theValue)
+{
ASSERT(myBaseImpl);
this->GetImpl()->SetPhysicalMesh((::BLSURFPlugin_Hypothesis::PhysicalMesh) theValue);
SMESH::TPythonDump() << _this() << ".SetPhysicalMesh( " << theValue << " )";
* Get PhysicalMesh
*/
//=============================================================================
-CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPhysicalMesh");
+CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh()
+{
ASSERT(myBaseImpl);
return this->GetImpl()->GetPhysicalMesh();
}
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetGeometricMesh(CORBA::Long theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetGeometricMesh");
+void BLSURFPlugin_Hypothesis_i::SetGeometricMesh(CORBA::Long theValue)
+{
ASSERT(myBaseImpl);
this->GetImpl()->SetGeometricMesh((::BLSURFPlugin_Hypothesis::GeometricMesh) theValue);
SMESH::TPythonDump() << _this() << ".SetGeometricMesh( " << theValue << " )";
* Get GeometricMesh
*/
//=============================================================================
-CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetGeometricMesh");
+CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh()
+{
ASSERT(myBaseImpl);
return this->GetImpl()->GetGeometricMesh();
}
* Set PhySize
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetPhySize(CORBA::Double theValue) {
-// MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhySize");
+void BLSURFPlugin_Hypothesis_i::SetPhySize(CORBA::Double theValue)
+{
ASSERT(myBaseImpl);
this->GetImpl()->SetPhySize(theValue, false);
SMESH::TPythonDump() << _this() << ".SetPhySize( " << theValue << " )";
* Set Relative PhySize
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetPhySizeRel(CORBA::Double theValue) {
-// MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhySizeRel");
+void BLSURFPlugin_Hypothesis_i::SetPhySizeRel(CORBA::Double theValue)
+{
ASSERT(myBaseImpl);
this->GetImpl()->SetPhySize(theValue, true);
SMESH::TPythonDump() << _this() << ".SetPhySizeRel( " << theValue << " )";
* Get PhySize
*/
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize() {
-// MESSAGE("BLSURFPlugin_Hypothesis_i::GetPhySize");
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize()
+{
ASSERT(myBaseImpl);
return this->GetImpl()->GetPhySize();
}
* Returns True if PhySize is relative
*/
//=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsPhySizeRel() {
-// MESSAGE("BLSURFPlugin_Hypothesis_i::IsPhySizeRel");
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsPhySizeRel()
+{
ASSERT(myBaseImpl);
return this->GetImpl()->IsPhySizeRel();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetMinSize(CORBA::Double theMinSize) {
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetMinSize(CORBA::Double theMinSize)
+{
if (IsMinSizeRel() || GetMinSize() != theMinSize ) {
this->GetImpl()->SetMinSize(theMinSize, false);
SMESH::TPythonDump() << _this() << ".SetMinSize( " << theMinSize << " )";
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetMinSizeRel(CORBA::Double theMinSize) {
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetMinSizeRel(CORBA::Double theMinSize)
+{
if ( !IsMinSizeRel() || (GetMinSize() != theMinSize) ) {
this->GetImpl()->SetMinSize(theMinSize, true);
SMESH::TPythonDump() << _this() << ".SetMinSizeRel( " << theMinSize << " )";
}
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetMinSize() {
- ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetMinSize()
+{
return this->GetImpl()->GetMinSize();
}
//=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMinSizeRel() {
-// MESSAGE("BLSURFPlugin_Hypothesis_i::IsMinSizeRel");
- ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMinSizeRel()
+{
return this->GetImpl()->IsMinSizeRel();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetMaxSize(CORBA::Double theMaxSize) {
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetMaxSize(CORBA::Double theMaxSize)
+{
if (IsMaxSizeRel() || GetMaxSize() != theMaxSize) {
this->GetImpl()->SetMaxSize(theMaxSize, false);
SMESH::TPythonDump() << _this() << ".SetMaxSize( " << theMaxSize << " )";
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetMaxSizeRel(CORBA::Double theMaxSize) {
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetMaxSizeRel(CORBA::Double theMaxSize)
+{
if ( !IsMaxSizeRel() || (GetMaxSize() != theMaxSize) ) {
this->GetImpl()->SetMaxSize(theMaxSize, true);
SMESH::TPythonDump() << _this() << ".SetMaxSizeRel( " << theMaxSize << " )";
}
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetMaxSize() {
- ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetMaxSize()
+{
return this->GetImpl()->GetMaxSize();
}
//=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMaxSizeRel() {
-// MESSAGE("BLSURFPlugin_Hypothesis_i::IsMaxSizeRel");
- ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMaxSizeRel()
+{
return this->GetImpl()->IsMaxSizeRel();
}
* Set true or false
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetUseGradation(CORBA::Boolean theValue) {
- MESSAGE("BLSURFPlugin_Hypothesis_i::SetUseGradation");
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetUseGradation(CORBA::Boolean theValue)
+{
if ( GetImpl()->GetUseGradation() != bool( theValue ))
{
this->GetImpl()->SetUseGradation(theValue);
* Get true or false
*/
//=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseGradation() {
- MESSAGE("BLSURFPlugin_Hypothesis_i::GetUseGradation");
- ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseGradation()
+{
return this->GetImpl()->GetUseGradation();
}
* Set Gradation
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetGradation(CORBA::Double theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetGradation");
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetGradation(CORBA::Double theValue)
+{
this->GetImpl()->SetGradation(theValue);
if ( theValue < 0 )
* Get Gradation
*/
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetGradation() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetGradation");
- ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetGradation()
+{
return this->GetImpl()->GetGradation();
}
* Set true or false
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation(CORBA::Boolean theValue) {
- MESSAGE("BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation");
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation(CORBA::Boolean theValue)
+{
if ( GetImpl()->GetUseVolumeGradation() != bool( theValue ))
{
this->GetImpl()->SetUseVolumeGradation(theValue);
* Get true or false
*/
//=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation() {
- MESSAGE("BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation");
- ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation()
+{
return this->GetImpl()->GetUseVolumeGradation();
}
* Set VolumeGradation
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetVolumeGradation(CORBA::Double theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetVolumeGradation");
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetVolumeGradation(CORBA::Double theValue)
+{
this->GetImpl()->SetVolumeGradation(theValue);
if ( theValue < 0 )
SetUseVolumeGradation( false );
* Get VolumeGradation
*/
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetVolumeGradation() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetVolumeGradation");
- ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetVolumeGradation()
+{
return this->GetImpl()->GetVolumeGradation();
}
* Set true or false
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetQuadAllowed(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetQuadAllowed");
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetQuadAllowed(CORBA::Boolean theValue)
+{
this->GetImpl()->SetQuadAllowed(theValue);
std::string theValueStr = theValue ? "True" : "False";
SMESH::TPythonDump() << _this() << ".SetQuadAllowed( " << theValueStr.c_str() << " )";
* Get true or false
*/
//=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadAllowed() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetQuadAllowed");
- ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadAllowed()
+{
return this->GetImpl()->GetQuadAllowed();
}
* Set AngleMesh
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetAngleMesh(CORBA::Double theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetAngleMesh");
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetAngleMesh(CORBA::Double theValue)
+{
this->GetImpl()->SetAngleMesh(theValue);
SMESH::TPythonDump() << _this() << ".SetAngleMesh( " << theValue << " )";
}
* Get AngleMesh
*/
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMesh() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetAngleMesh");
- ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMesh()
+{
return this->GetImpl()->GetAngleMesh();
}
* Set Chordal Error
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetChordalError(CORBA::Double theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetChordalError");
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetChordalError(CORBA::Double theValue)
+{
this->GetImpl()->SetChordalError(theValue);
SMESH::TPythonDump() << _this() << ".SetChordalError( " << theValue << " )";
}
* Get Chordal Error
*/
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetChordalError() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetChordalError");
- ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetChordalError()
+{
return this->GetImpl()->GetChordalError();
}
* Set true or false
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetAnisotropic(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetAnisotropic");
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetAnisotropic(CORBA::Boolean theValue)
+{
this->GetImpl()->SetAnisotropic(theValue);
std::string theValueStr = theValue ? "True" : "False";
SMESH::TPythonDump() << _this() << ".SetAnisotropic( " << theValueStr.c_str() << " )";
* Get true or false
*/
//=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetAnisotropic() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetAnisotropic");
- ASSERT(myBaseImpl);
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetAnisotropic()
+{
return this->GetImpl()->GetAnisotropic();
}
* Set Anisotropic Ratio
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio(CORBA::Double theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio");
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio(CORBA::Double theValue)
+{
this->GetImpl()->SetAnisotropicRatio(theValue);
SMESH::TPythonDump() << _this() << ".SetAnisotropicRatio( " << theValue << " )";
}
* Get Anisotropic Ratio
*/
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio");
- ASSERT(myBaseImpl);
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio()
+{
return this->GetImpl()->GetAnisotropicRatio();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetRemoveTinyEdges(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetRemoveTinyEdges");
ASSERT(myBaseImpl);
this->GetImpl()->SetRemoveTinyEdges(theValue);
std::string theValueStr = theValue ? "True" : "False";
*/
//=============================================================================
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetRemoveTinyEdges() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetRemoveTinyEdges");
ASSERT(myBaseImpl);
return this->GetImpl()->GetRemoveTinyEdges();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetTinyEdgeLength(CORBA::Double theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetTinyEdgeLength");
ASSERT(myBaseImpl);
this->GetImpl()->SetTinyEdgeLength(theValue);
SMESH::TPythonDump() << _this() << ".SetTinyEdgeLength( " << theValue << " )";
*/
//=============================================================================
CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeLength() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetTinyEdgeLength");
ASSERT(myBaseImpl);
return this->GetImpl()->GetTinyEdgeLength();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetOptimiseTinyEdges(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetOptimiseTinyEdges");
ASSERT(myBaseImpl);
this->GetImpl()->SetOptimiseTinyEdges(theValue);
std::string theValueStr = theValue ? "True" : "False";
*/
//=============================================================================
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimiseTinyEdges() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetOptimiseTinyEdges");
ASSERT(myBaseImpl);
return this->GetImpl()->GetOptimiseTinyEdges();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetTinyEdgeOptimisationLength(CORBA::Double theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetTinyEdgeOptimisationLength");
ASSERT(myBaseImpl);
this->GetImpl()->SetTinyEdgeOptimisationLength(theValue);
SMESH::TPythonDump() << _this() << ".SetTinyEdgeOptimisationLength( " << theValue << " )";
*/
//=============================================================================
CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeOptimisationLength() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetTinyEdgeOptimisationLength");
ASSERT(myBaseImpl);
return this->GetImpl()->GetTinyEdgeOptimisationLength();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersection(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersection");
ASSERT(myBaseImpl);
this->GetImpl()->SetCorrectSurfaceIntersection(theValue);
std::string theValueStr = theValue ? "True" : "False";
*/
//=============================================================================
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersection() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersection");
ASSERT(myBaseImpl);
return this->GetImpl()->GetCorrectSurfaceIntersection();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersectionMaxCost(CORBA::Double theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersectionMaxCost");
ASSERT(myBaseImpl);
this->GetImpl()->SetCorrectSurfaceIntersectionMaxCost(theValue);
SMESH::TPythonDump() << _this() << ".SetCorrectSurfaceIntersectionMaxCost( " << theValue << " )";
*/
//=============================================================================
CORBA::Double BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersectionMaxCost() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersectionMaxCost");
ASSERT(myBaseImpl);
return this->GetImpl()->GetCorrectSurfaceIntersectionMaxCost();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetBadElementRemoval(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetBadElementRemoval");
ASSERT(myBaseImpl);
this->GetImpl()->SetBadElementRemoval(theValue);
std::string theValueStr = theValue ? "True" : "False";
*/
//=============================================================================
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetBadElementRemoval() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetBadElementRemoval");
ASSERT(myBaseImpl);
return this->GetImpl()->GetBadElementRemoval();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetBadElementAspectRatio(CORBA::Double theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetBadElementAspectRatio");
ASSERT(myBaseImpl);
this->GetImpl()->SetBadElementAspectRatio(theValue);
SMESH::TPythonDump() << _this() << ".SetBadElementAspectRatio( " << theValue << " )";
*/
//=============================================================================
CORBA::Double BLSURFPlugin_Hypothesis_i::GetBadElementAspectRatio() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetBadElementAspectRatio");
ASSERT(myBaseImpl);
return this->GetImpl()->GetBadElementAspectRatio();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetOptimizeMesh(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetOptimizeMesh");
ASSERT(myBaseImpl);
this->GetImpl()->SetOptimizeMesh(theValue);
std::string theValueStr = theValue ? "True" : "False";
*/
//=============================================================================
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimizeMesh() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetOptimizeMesh");
ASSERT(myBaseImpl);
return this->GetImpl()->GetOptimizeMesh();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetQuadraticMesh(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetQuadraticMesh");
ASSERT(myBaseImpl);
this->GetImpl()->SetQuadraticMesh(theValue);
std::string theValueStr = theValue ? "True" : "False";
*/
//=============================================================================
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadraticMesh() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetQuadraticMesh");
ASSERT(myBaseImpl);
return this->GetImpl()->GetQuadraticMesh();
}
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetTopology(CORBA::Long theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetTopology");
ASSERT(myBaseImpl);
this->GetImpl()->SetTopology((::BLSURFPlugin_Hypothesis::Topology) theValue);
SMESH::TPythonDump() << _this() << ".SetTopology( " << theValue << " )";
*/
//=============================================================================
CORBA::Long BLSURFPlugin_Hypothesis_i::GetTopology() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetTopology");
ASSERT(myBaseImpl);
return this->GetImpl()->GetTopology();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges");
ASSERT(myBaseImpl);
this->GetImpl()->SetPreCADMergeEdges(theValue);
std::string theValueStr = theValue ? "True" : "False";
*/
//=============================================================================
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges");
ASSERT(myBaseImpl);
return this->GetImpl()->GetPreCADMergeEdges();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetPreCADRemoveDuplicateCADFaces(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADRemoveDuplicateCADFaces");
ASSERT(myBaseImpl);
this->GetImpl()->SetPreCADRemoveDuplicateCADFaces(theValue);
std::string theValueStr = theValue ? "True" : "False";
*/
//=============================================================================
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADRemoveDuplicateCADFaces() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADRemoveDuplicateCADFaces");
ASSERT(myBaseImpl);
return this->GetImpl()->GetPreCADRemoveDuplicateCADFaces();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology");
ASSERT(myBaseImpl);
this->GetImpl()->SetPreCADProcess3DTopology(theValue);
std::string theValueStr = theValue ? "True" : "False";
*/
//=============================================================================
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology");
ASSERT(myBaseImpl);
return this->GetImpl()->GetPreCADProcess3DTopology();
}
*/
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetPreCADDiscardInput(CORBA::Boolean theValue) {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADDiscardInput");
ASSERT(myBaseImpl);
this->GetImpl()->SetPreCADDiscardInput(theValue);
std::string theValueStr = theValue ? "True" : "False";
*/
//=============================================================================
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADDiscardInput() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADDiscardInput");
ASSERT(myBaseImpl);
return this->GetImpl()->GetPreCADDiscardInput();
}
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetOptionValues(const BLSURFPlugin::string_array& options)
- throw (SALOME::SALOME_Exception) {
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
for (CORBA::ULong i = 0; i < options.length(); ++i) {
string name_value_type = options[i].in();
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValues(const BLSURFPlugin::string_array& options)
- throw (SALOME::SALOME_Exception) {
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
for ( CORBA::ULong i = 0; i < options.length(); ++i) {
string name_value_type = options[i].in();
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* sizeMap)
- throw (SALOME::SALOME_Exception) {
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : SETSIZEMAP START ENTRY : " << entry);
if ( !entry || !entry[0] )
THROW_SALOME_CORBA_EXCEPTION( "SetSizeMapEntry(): empty geom entry", SALOME::BAD_PARAM );
bool valueChanged = false;
} catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- MESSAGE("ENGINE : SETSIZEMAP END ENTRY : " << entry);
if (valueChanged)
SMESH::TPythonDump() << _this() << ".SetSizeMap(" << entry << ", '" << sizeMap << "' )";
}
void BLSURFPlugin_Hypothesis_i::SetConstantSizeMapEntry(const char* entry, GEOM::shape_type shapeType, CORBA::Double sizeMap)
throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : SETSIZEMAP START ENTRY : " << entry);
bool valueChanged = false;
std::ostringstream sizeMapFunction;
switch (shapeType) {
} catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- MESSAGE("ENGINE : SETSIZEMAP END ENTRY : " << entry);
if (valueChanged)
SMESH::TPythonDump() << _this() << ".SetConstantSizeMap(" << entry << ", '" << sizeMap << "' )";
}
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry, const char* attractor)
- throw (SALOME::SALOME_Exception) {
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : SETATTRACTOR START ENTRY : " << entry);
bool valueChanged = false;
try {
valueChanged = ( this->GetImpl()->GetAttractorEntry(entry) != attractor );
} catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- MESSAGE("ENGINE : SETATTRACTOR END ENTRY : " << entry);
if (valueChanged)
SMESH::TPythonDump() << _this() << ".SetAttractor(" << entry << ", '" << attractor << "' )";
}
throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : SETATTRACTOR START ENTRY : " << entry);
//bool valueChanged = false;
try {
this->GetImpl()->SetClassAttractorEntry(entry, att_entry, StartSize, EndSize, ActionRadius, ConstantRadius);
} catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- MESSAGE("ENGINE : SETATTRACTOR END ENTRY : " << entry);
//if ( valueChanged )
SMESH::TPythonDump() << _this() << ".SetAttractorGeom( "
<< entry << ", " << att_entry << ", "<<StartSize<<", "<<EndSize<<", "<<ActionRadius<<", "<<ConstantRadius<<" )";
double startSize, endSize, infDist, constDist;
if ( !atIt->second->Empty() ) {
attEntry = atIt->second->GetAttractorEntry();
- MESSAGE("GetAttractorParams : attEntry ="<<attEntry)
std::vector<double> params = atIt->second->GetParameters();
startSize = params[0];
endSize = params[1];
result[i].endSize = endSize;
result[i].infDist = infDist;
result[i].constDist = constDist;
- MESSAGE("GetAttractorParams : result[i].attEntry ="<<result[i].attEntry)
- MESSAGE("GetAttractorParams : result[i].faceEntry ="<<result[i].faceEntry)
}
return result._retn();
}
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetSizeMapEntries(const BLSURFPlugin::string_array& sizeMaps)
- throw (SALOME::SALOME_Exception) {
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
for ( CORBA::ULong i = 0; i < sizeMaps.length(); ++i) {
string entry_sizemap = sizeMaps[i].in();
ASSERT(myBaseImpl);
string entry;
entry = GeomObj->GetStudyEntry();
- MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : SETSIZEMAP ( "<< entry << " , " << sizeMap << ")");
SetSizeMapEntry(entry.c_str(), sizeMap);
}
GEOM::shape_type shapeType = GeomObj->GetShapeType();
if (shapeType == GEOM::COMPOUND)
shapeType = GeomObj->GetMaxShapeType();
- MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : SETSIZEMAP ( "<< entry << " , " << sizeMap << ")");
SetConstantSizeMapEntry(entry.c_str(), shapeType, sizeMap);
}
ASSERT(myBaseImpl);
string entry;
entry = GeomObj->GetStudyEntry();
- MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : UNSETSIZEMAP ( "<< entry << ")");
UnsetEntry(entry.c_str());
SMESH::TPythonDump() << _this() << ".UnsetSizeMap( " << entry.c_str() << " )";
}
ASSERT(myBaseImpl);
string entry;
entry = GeomObj->GetStudyEntry();
- MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : SETATTRACTOR ( "<< entry << " , " << attractor << ")");
SetAttractorEntry(entry.c_str(), attractor);
}
ASSERT(myBaseImpl);
string entry;
entry = GeomObj->GetStudyEntry();
- MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : UNSETATTRACTOR ( "<< entry << ")");
UnsetEntry(entry.c_str());
SMESH::TPythonDump() << _this() << ".UnsetAttractor( " << entry.c_str() << " )";
}
TopoDS_Face FaceShape = TopoDS::Face(SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theFace ));
TopoDS_Shape AttractorShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theAttractor );
- MESSAGE("IDL : GetName : " << theFace->GetName());
- MESSAGE("IDL : SETATTRACTOR () ");//<< entry << " , " << att_entry << ")");
SetClassAttractorEntry( theFaceEntry.c_str(), theAttEntry.c_str(), StartSize, EndSize, ActionRadius, ConstantRadius);
}
!theAttrEntry.in() || !theAttrEntry.in()[0] )
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
- MESSAGE("IDL : GetName : " << theFace->GetName());
- MESSAGE("IDL : UNSETATTRACTOR ( "<< theFaceEntry << ")");
GetImpl()->ClearEntry( theFaceEntry.in(), theAttrEntry.in() );
SMESH::TPythonDump() << _this() << ".UnsetAttractorGeom( "
<< theFace << ", " << theAttractor << " )";
/*
- void BLSURFPlugin_Hypothesis_i::SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap)
- {}
+ void BLSURFPlugin_Hypothesis_i::SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap)
+ {}
- void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj)
- {}
+ void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj)
+ {}
- void BLSURFPlugin_Hypothesis_i::SetCustomSizeMapEntry(const char* entry,const char* sizeMap ) throw (SALOME::SALOME_Exception)
- {}
+ void BLSURFPlugin_Hypothesis_i::SetCustomSizeMapEntry(const char* entry,const char* sizeMap ) throw (SALOME::SALOME_Exception)
+ {}
- char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception)
- {}
+ char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception)
+ {}
- void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry)
- {
- ASSERT(myBaseImpl);
- this->GetImpl()->UnsetCustomSizeMap(entry);
- SMESH::TPythonDump() << _this() << ".UnsetCustomSizeMap( " << entry << " )";
- }
+ void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry)
+ {
+ ASSERT(myBaseImpl);
+ this->GetImpl()->UnsetCustomSizeMap(entry);
+ SMESH::TPythonDump() << _this() << ".UnsetCustomSizeMap( " << entry << " )";
+ }
- BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntries()
- {}
+ BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntries()
+ {}
- */
+*/
// ///////////////////////
// // ENFORCED VERTICES //
*
*/
BLSURFPlugin::TFaceEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByFace() {
- MESSAGE("IDL: GetAllEnforcedVerticesByFace()");
ASSERT(myBaseImpl);
BLSURFPlugin::TFaceEntryEnfVertexListMap_var resultMap = new BLSURFPlugin::TFaceEntryEnfVertexListMap();
const ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap faceEntryEnfVertexListMap =
- this->GetImpl()->_GetAllEnforcedVerticesByFace();
+ this->GetImpl()->_GetAllEnforcedVerticesByFace();
resultMap->length(faceEntryEnfVertexListMap.size());
- MESSAGE("Face entry to Enforced Vertex map size is " << resultMap->length());
::BLSURFPlugin_Hypothesis::TEnfVertexList _enfVertexList;
::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap::const_iterator it_entry = faceEntryEnfVertexListMap.begin();
for (int i = 0; it_entry != faceEntryEnfVertexListMap.end(); ++it_entry, ++i) {
BLSURFPlugin::TFaceEntryEnfVertexListMapElement_var mapElement =
- new BLSURFPlugin::TFaceEntryEnfVertexListMapElement();
+ new BLSURFPlugin::TFaceEntryEnfVertexListMapElement();
mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str());
- MESSAGE("Face Entry: " << mapElement->faceEntry);
_enfVertexList = it_entry->second;
BLSURFPlugin::TEnfVertexList_var enfVertexList = new BLSURFPlugin::TEnfVertexList();
enfVertexList->length(_enfVertexList.size());
- MESSAGE("Number of enf vertex: " << enfVertexList->length());
::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator it_enfVertex = _enfVertexList.begin();
::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
msg << "Enforced vertex: \n"
<< "Name: " << enfVertex->name << "\n";
if (coords->length())
- msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
+ msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
msg << "Geom entry: " << enfVertex->geomEntry << "\n"
<< "Group Name: " << enfVertex->grpName;
- MESSAGE(msg.str());
enfVertexList[j] = enfVertex;
}
*
*/
BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices() {
- MESSAGE("IDL: GetAllEnforcedVertices()");
ASSERT(myBaseImpl);
BLSURFPlugin::TEnfVertexList_var resultMap = new BLSURFPlugin::TEnfVertexList();
const ::BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList = this->GetImpl()->_GetAllEnforcedVertices();
resultMap->length(enfVertexList.size());
- MESSAGE("Enforced Vertex map size is " << resultMap->length());
::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = enfVertexList.begin();
::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
for (int i = 0; evlIt != enfVertexList.end(); ++evlIt, ++i) {
- MESSAGE("Enforced Vertex #" << i);
currentEnfVertex = (*evlIt);
BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
// Name
msg << "Enforced vertex: \n"
<< "Name: " << enfVertex->name << "\n";
if (coords->length())
- msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
+ msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
msg << "Geom entry: " << enfVertex->geomEntry << "\n"
<< "Group Name: " << enfVertex->grpName;
- MESSAGE(msg.str());
resultMap[i] = enfVertex;
}
*
*/
BLSURFPlugin::TFaceEntryCoordsListMap* BLSURFPlugin_Hypothesis_i::GetAllCoordsByFace() {
- MESSAGE("IDL: GetAllCoordsByFace()");
ASSERT(myBaseImpl);
BLSURFPlugin::TFaceEntryCoordsListMap_var resultMap = new BLSURFPlugin::TFaceEntryCoordsListMap();
const ::BLSURFPlugin_Hypothesis::TFaceEntryCoordsListMap entryCoordsListMap = this->GetImpl()->_GetAllCoordsByFace();
resultMap->length(entryCoordsListMap.size());
- MESSAGE("Enforced Vertex map size is " << resultMap->length());
::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList _coordsList;
::BLSURFPlugin_Hypothesis::TFaceEntryCoordsListMap::const_iterator it_entry = entryCoordsListMap.begin();
for (int i = 0; it_entry != entryCoordsListMap.end(); ++it_entry, ++i) {
BLSURFPlugin::TFaceEntryCoordsListMapElement_var mapElement = new BLSURFPlugin::TFaceEntryCoordsListMapElement();
mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str());
- MESSAGE("Face Entry: " << mapElement->faceEntry);
_coordsList = it_entry->second;
BLSURFPlugin::TEnfVertexCoordsList_var coordsList = new BLSURFPlugin::TEnfVertexCoordsList();
coordsList->length(_coordsList.size());
- MESSAGE("Number of coords: " << coordsList->length());
::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList::const_iterator it_coords = _coordsList.begin();
for (int j = 0; it_coords != _coordsList.end(); ++it_coords, ++j) {
for (CORBA::ULong i=0;i<coords->length();i++)
coords[i] = (*it_coords)[i];
coordsList[j] = coords;
- MESSAGE("Coords #" << j << ": " << coords[0] << ", " << coords[1] << ", " << coords[2]);
}
mapElement->coordsList = coordsList;
* They are the coords of the "manual" enforced vertices.
*/
BLSURFPlugin::TCoordsEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByCoords() {
- MESSAGE("IDL: GetAllEnforcedVerticesByCoords()");
ASSERT(myBaseImpl);
BLSURFPlugin::TCoordsEnfVertexMap_var resultMap = new BLSURFPlugin::TCoordsEnfVertexMap();
const ::BLSURFPlugin_Hypothesis::TCoordsEnfVertexMap coordsEnfVertexMap =
- this->GetImpl()->_GetAllEnforcedVerticesByCoords();
+ this->GetImpl()->_GetAllEnforcedVerticesByCoords();
resultMap->length(coordsEnfVertexMap.size());
- MESSAGE("Enforced Vertex map size is " << resultMap->length());
::BLSURFPlugin_Hypothesis::TCoordsEnfVertexMap::const_iterator it_coords = coordsEnfVertexMap.begin();
::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
for (int i = 0; it_coords != coordsEnfVertexMap.end(); ++it_coords, ++i) {
- MESSAGE("Enforced Vertex #" << i);
currentEnfVertex = (it_coords->second);
BLSURFPlugin::TCoordsEnfVertexElement_var mapElement = new BLSURFPlugin::TCoordsEnfVertexElement();
BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
for (CORBA::ULong ind=0;ind<coords->length();ind++)
coords[ind] = it_coords->first[ind];
mapElement->coords = coords;
- MESSAGE("Coords: " << mapElement->coords[0] << ", " << mapElement->coords[1] << ", " << mapElement->coords[2]);
BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
// Name
msg << "Enforced vertex: \n"
<< "Name: " << enfVertex->name << "\n";
if (coords->length())
- msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
+ msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
msg << "Geom entry: " << enfVertex->geomEntry << "\n"
<< "Group Name: " << enfVertex->grpName;
- MESSAGE(msg.str());
resultMap[i] = mapElement;
}
*
*/
BLSURFPlugin::TFaceEntryEnfVertexEntryListMap* BLSURFPlugin_Hypothesis_i::GetAllEnfVertexEntriesByFace() {
- MESSAGE("IDL: GetAllEnfVertexEntriesByFace()");
ASSERT(myBaseImpl);
BLSURFPlugin::TFaceEntryEnfVertexEntryListMap_var resultMap = new BLSURFPlugin::TFaceEntryEnfVertexEntryListMap();
const ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexEntryListMap entryEnfVertexEntryListMap =
- this->GetImpl()->_GetAllEnfVertexEntriesByFace();
+ this->GetImpl()->_GetAllEnfVertexEntriesByFace();
resultMap->length(entryEnfVertexEntryListMap.size());
- MESSAGE("Enforced Vertex map size is " << resultMap->length());
::BLSURFPlugin_Hypothesis::TEntryList _enfVertexEntryList;
::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexEntryListMap::const_iterator it_entry =
entryEnfVertexEntryListMap.begin();
for (int i = 0; it_entry != entryEnfVertexEntryListMap.end(); ++it_entry, ++i) {
BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement_var mapElement =
- new BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement();
+ new BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement();
mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str());
- MESSAGE("Face Entry: " << mapElement->faceEntry);
_enfVertexEntryList = it_entry->second;
BLSURFPlugin::TEntryList_var enfVertexEntryList = new BLSURFPlugin::TEntryList();
enfVertexEntryList->length(_enfVertexEntryList.size());
- MESSAGE("Number of enf vertex entries: " << enfVertexEntryList->length());
::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_enfVertexEntry = _enfVertexEntryList.begin();
for (int j = 0; it_enfVertexEntry != _enfVertexEntryList.end(); ++it_enfVertexEntry, ++j) {
enfVertexEntryList[j] = CORBA::string_dup((*it_enfVertexEntry).c_str());
- MESSAGE("Enf Vertex Entry #" << j << ": " << enfVertexEntryList[j]);
}
mapElement->enfVertexEntryList = enfVertexEntryList;
* They are the geom entries of the enforced vertices defined with geom shape (vertex, compound, group).
*/
BLSURFPlugin::TEnfVertexEntryEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByEnfVertexEntry() {
- MESSAGE("IDL: GetAllEnforcedVerticesByEnfVertexEntry()");
ASSERT(myBaseImpl);
BLSURFPlugin::TEnfVertexEntryEnfVertexMap_var resultMap = new BLSURFPlugin::TEnfVertexEntryEnfVertexMap();
const ::BLSURFPlugin_Hypothesis::TEnfVertexEntryEnfVertexMap enfVertexEntryEnfVertexMap =
- this->GetImpl()->_GetAllEnforcedVerticesByEnfVertexEntry();
+ this->GetImpl()->_GetAllEnforcedVerticesByEnfVertexEntry();
resultMap->length(enfVertexEntryEnfVertexMap.size());
- MESSAGE("Enforced Vertex map size is " << resultMap->length());
::BLSURFPlugin_Hypothesis::TEnfVertexEntryEnfVertexMap::const_iterator it_enfVertexEntry = enfVertexEntryEnfVertexMap.begin();
::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
for (int i = 0; it_enfVertexEntry != enfVertexEntryEnfVertexMap.end(); ++it_enfVertexEntry, ++i) {
- MESSAGE("Enforced Vertex #" << i);
currentEnfVertex = it_enfVertexEntry->second;
BLSURFPlugin::TEnfVertexEntryEnfVertexElement_var mapElement = new BLSURFPlugin::TEnfVertexEntryEnfVertexElement();
mapElement->enfVertexEntry = CORBA::string_dup(it_enfVertexEntry->first.c_str());;
- MESSAGE("Enf Vertex Entry #" << i << ": " << mapElement->enfVertexEntry);
BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
// Name
msg << "Enforced vertex: \n"
<< "Name: " << enfVertex->name << "\n";
if (coords->length())
- msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
+ msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n";
msg << "Geom entry: " << enfVertex->geomEntry << "\n"
<< "Group Name: " << enfVertex->grpName;
- MESSAGE(msg.str());
mapElement->enfVertex = enfVertex;
resultMap[i] = mapElement;
* Set/get/unset an enforced vertex on face - OBSOLETE
*/
bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
- CORBA::Double z) throw (SALOME::SALOME_Exception) {
+ CORBA::Double z) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
}
}
if (theFaceEntry.empty())
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
- MESSAGE("IDL : GetName : " << theFace->GetName());
- MESSAGE("IDL : SetEnforcedVertex( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ")");
try {
return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z);
} catch (SALOME_Exception& ex) {
* Set/get/unset an enforced vertex with name on face
*/
bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
- CORBA::Double z, const char* theVertexName) throw (SALOME::SALOME_Exception) {
+ CORBA::Double z, const char* theVertexName) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
}
if (theFaceEntry.empty())
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
- MESSAGE("IDL : GetName : " << theFace->GetName());
- MESSAGE("IDL : SetEnforcedVertexNamed( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ", " << theVertexName << ")");
try {
return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, theVertexName);
} catch (SALOME_Exception& ex) {
* Set/get/unset an enforced vertex with geom object on face
*/
bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
- throw (SALOME::SALOME_Exception) {
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
}
if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
}
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
string theVertexName = theVertex->GetName();
- MESSAGE("IDL : theFace->GetName : " << theFace->GetName());
- MESSAGE("IDL : theVertex->GetName : " << theVertexName);
- MESSAGE("IDL : SetEnforcedVertexGeom( "<< theFaceEntry << ", " << theVertexEntry<< ")");
try {
return SetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str());
} catch (SALOME_Exception& ex) {
* Set an enforced vertex with group name on face
*/
bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
}
}
if (theFaceEntry.empty())
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
- MESSAGE("IDL : GetName : " << theFace->GetName());
- MESSAGE("IDL : SetEnforcedVertexWithGroup( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ", " << theGroupName << ")");
try {
return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, "", "", theGroupName);
} catch (SALOME_Exception& ex) {
*/
bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z,
const char* theVertexName, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
}
}
if (theFaceEntry.empty())
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
- MESSAGE("IDL : GetName : " << theFace->GetName());
- MESSAGE("IDL : SetEnforcedVertexNamedWithGroup( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ", " << theVertexName << ", " << theGroupName << ")");
try {
return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, theVertexName, "", theGroupName);
} catch (SALOME_Exception& ex) {
* Set an enforced vertex with geom entry and group name on face
*/
bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
}
if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
}
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
string theVertexName = theVertex->GetName();
- MESSAGE("IDL : theFace->GetName : " << theFace->GetName());
- MESSAGE("IDL : theVertex->GetName : " << theVertexName);
- MESSAGE("IDL : SetEnforcedVertexGeomWithGroup( "<< theFaceEntry << ", " << theVertexEntry<< ", " << theGroupName<< ")");
try {
return SetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str(), theGroupName);
} catch (SALOME_Exception& ex) {
// ASSERT(myBaseImpl);
// if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
-// MESSAGE("theFace shape type is not FACE or COMPOUND");
// THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
// }
// if (theFaceEntry.empty())
// THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
-// MESSAGE("IDL : GetName : " << theFace->GetName());
-// MESSAGE("IDL : GetInternalEnforcedVertexEntry ( "<< theFaceEntry << ")");
// try {
// return GetInternalEnforcedVertexEntry(theFaceEntry.c_str());
// } catch (SALOME_Exception& ex) {
* Get the list of all enforced vertices
*/
BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEOM::GEOM_Object_ptr theFace)
- throw (SALOME::SALOME_Exception) {
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
}
if (theFaceEntry.empty())
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
- MESSAGE("IDL : GetName : " << theFace->GetName());
- MESSAGE("IDL : GetEnforcedVerticesEntry ( "<< theFaceEntry << ")");
try {
return GetEnforcedVerticesEntry(theFaceEntry.c_str());
} catch (SALOME_Exception& ex) {
}
bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
- CORBA::Double z) throw (SALOME::SALOME_Exception) {
+ CORBA::Double z) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
}
}
if (theFaceEntry.empty())
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
- MESSAGE("IDL : GetName : " << theFace->GetName());
- MESSAGE("IDL : UnsetEnforcedVertex ( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ")");
try {
return UnsetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z);
}
bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
- throw (SALOME::SALOME_Exception) {
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
}
if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
}
if (theVertexEntry.empty())
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
- MESSAGE("IDL : UnsetEnforcedVertexGeom ( "<< theFaceEntry << ", " << theVertexEntry << ")");
try {
return UnsetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexEntry.c_str());
ASSERT(myBaseImpl);
if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
}
if (theFaceEntry.empty())
THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
- MESSAGE("IDL : GetName : " << theFace->GetName());
- MESSAGE("IDL : UnsetEnforcedVertices ( "<< theFaceEntry << ")");
try {
return UnsetEnforcedVerticesEntry(theFaceEntry.c_str());
* Set/get/unset an enforced vertex with geom object on face
*/
bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
}
string theVertexEntry = theVertex->GetStudyEntry();
* Set an enforced vertex with group name on face
*/
bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
*/
bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z,
const char* theVertexName, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
* Set an enforced vertex with geom entry and group name on face
*/
bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
}
}
bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theVertex shape type is not VERTEX or COMPOUND");
THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
}
std::string theVertexEntry = theVertex->GetStudyEntry();
}
BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntry(const char* entry)
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
try {
BLSURFPlugin::TEnfVertexList_var vertexList = new BLSURFPlugin::TEnfVertexList();
::BLSURFPlugin_Hypothesis::TEnfVertexList _vList = this->GetImpl()->GetEnfVertexList(entry);
vertexList->length(_vList.size());
- MESSAGE("Number of enforced vertices: " << vertexList->length());
::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = _vList.begin();
for (int i = 0; evlIt != _vList.end(); ++evlIt, ++i) {
::BLSURFPlugin_Hypothesis::TEnfVertex *_enfVertex = (*evlIt);
vertexList[i] = enfVertex;
}
- MESSAGE("ENGINE : GetEnforcedVerticesEntry END ENTRY : " << entry);
return vertexList._retn();
} catch (const std::invalid_argument& ex) {
SALOME::ExceptionStruct ExDescription;
if (string(theVertexEntry).empty())
SMESH::TPythonDump() << "isDone = " << _this() << ".RemoveEnforcedVertex(" << x << ", " << y << ", " << z
- << ")";
+ << ")";
else
SMESH::TPythonDump() << "isDone = " << _this() << ".RemoveEnforcedVertexGeom(" << theVertexEntry << ")";
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- MESSAGE("ENGINE : UnsetEnforcedVertexEntry END ENTRY : " << theFaceEntry);
return res;
}
bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception)
/*
* Enable internal enforced vertices on specific face if requested by user
*
-void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices)
+ void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices)
throw (SALOME::SALOME_Exception)
-{
- MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexForFace");
- try {
- SetInternalEnforcedVertexWithGroup(theFace, toEnforceInternalVertices);
- } catch (SALOME_Exception& ex) {
- THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
- }
-}
+ {
+ try {
+ SetInternalEnforcedVertexWithGroup(theFace, toEnforceInternalVertices);
+ } catch (SALOME_Exception& ex) {
+ THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+ }
+ }
-void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
+ void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
throw (SALOME::SALOME_Exception)
-{
- MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexForFaceWithGroup");
-
- if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
- MESSAGE("theFace shape type is not FACE or COMPOUND");
- THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
- }
-
- string theFaceEntry = theFace->GetStudyEntry();
-
- if (theFaceEntry.empty()) {
- GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
- SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen();
- string aName;
- if (theFace->GetShapeType() == GEOM::FACE)
- aName = "Face_";
- if (theFace->GetShapeType() == GEOM::COMPOUND)
- aName = "Compound_";
- aName += theFace->GetEntry();
- SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
- if (!theSFace->_is_nil())
- theFaceEntry = theSFace->GetID();
- }
- if (theFaceEntry.empty())
- THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
-
- MESSAGE("IDL : GetName : " << theFace->GetName());
- MESSAGE("IDL : GetInternalEnforcedVertexEntry ( "<< theFaceEntry << ")");
- try {
- SetInternalEnforcedVertexEntry(theFaceEntry.c_str(), toEnforceInternalVertices, theGroupName);
- } catch (SALOME_Exception& ex) {
- THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
- }
-}
+ {
-void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexEntry(const char* theFaceEntry, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
-{
- MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexForFaceEntry");
- ASSERT(myBaseImpl);
- try {
- this->GetImpl()->SetInternalEnforcedVertex(theFaceEntry, toEnforceInternalVertices, theGroupName);
- std::string theValueStr = toEnforceInternalVertices ? "True" : "False";
- if (string(theGroupName).empty())
- SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertex( " << theFaceEntry << ", " << theValueStr.c_str() << " )";
- else
- SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertexWithGroup( " << theFaceEntry << ", " << theValueStr.c_str() << ", \"" << theGroupName << "\" )";
- } catch (const std::exception& ex) {
- std::cout << "Exception: " << ex.what() << std::endl;
- THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
- }
-}
+ if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
+ THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM);
+ }
-*/
+ string theFaceEntry = theFace->GetStudyEntry();
+
+ if (theFaceEntry.empty()) {
+ GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
+ SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen();
+ string aName;
+ if (theFace->GetShapeType() == GEOM::FACE)
+ aName = "Face_";
+ if (theFace->GetShapeType() == GEOM::COMPOUND)
+ aName = "Compound_";
+ aName += theFace->GetEntry();
+ SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
+ if (!theSFace->_is_nil())
+ theFaceEntry = theSFace->GetID();
+ }
+ if (theFaceEntry.empty())
+ THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
-/* TODO GROUPS
- char* BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception)
- {
- ASSERT(myBaseImpl);
- MESSAGE("ENGINE : GetEnforcedVertexGroupName START ");
try {
- return CORBA::string_dup( this->GetImpl()->GetEnforcedVertexGroupName(x, y, z).c_str());
- }
- catch (const std::invalid_argument& ex) {
- SALOME::ExceptionStruct ExDescription;
- ExDescription.text = ex.what();
- ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(entry)";
- ExDescription.lineNumber = 1146;
- throw SALOME::SALOME_Exception(ExDescription);
- }
- catch (SALOME_Exception& ex) {
+ SetInternalEnforcedVertexEntry(theFaceEntry.c_str(), toEnforceInternalVertices, theGroupName);
+ } catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- MESSAGE("ENGINE : GetEnforcedVertexGroupName END ");
- return 0;
}
-
- void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName)
+ void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexEntry(const char* theFaceEntry, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : SetEnforcedVertexGroupName START ");
try {
- this->GetImpl()->SetEnforcedVertexGroupName(x, y, z, groupName);
- }
- catch (const std::invalid_argument& ex) {
- SALOME::ExceptionStruct ExDescription;
- ExDescription.text = ex.what();
- ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetEnforcedVertexGroupName(x,y,z)";
- ExDescription.lineNumber = 1170;
- throw SALOME::SALOME_Exception(ExDescription);
- }
- catch (SALOME_Exception& ex) {
+ this->GetImpl()->SetInternalEnforcedVertex(theFaceEntry, toEnforceInternalVertices, theGroupName);
+ std::string theValueStr = toEnforceInternalVertices ? "True" : "False";
+ if (string(theGroupName).empty())
+ SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertex( " << theFaceEntry << ", " << theValueStr.c_str() << " )";
+ else
+ SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertexWithGroup( " << theFaceEntry << ", " << theValueStr.c_str() << ", \"" << theGroupName << "\" )";
+ } catch (const std::exception& ex) {
+ std::cout << "Exception: " << ex.what() << std::endl;
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
+ }
- SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGroupName("
- << x << ", " << y << ", " << z << ", '" << groupName << "' )";
+*/
- MESSAGE("ENGINE : SetEnforcedVertexGroupName END ");
- }
- */
+/* TODO GROUPS
+ char* BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z)
+ throw (SALOME::SALOME_Exception)
+ {
+ ASSERT(myBaseImpl);
+ try {
+ return CORBA::string_dup( this->GetImpl()->GetEnforcedVertexGroupName(x, y, z).c_str());
+ }
+ catch (const std::invalid_argument& ex) {
+ SALOME::ExceptionStruct ExDescription;
+ ExDescription.text = ex.what();
+ ExDescription.type = SALOME::BAD_PARAM;
+ ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(entry)";
+ ExDescription.lineNumber = 1146;
+ throw SALOME::SALOME_Exception(ExDescription);
+ }
+ catch (SALOME_Exception& ex) {
+ THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+ }
+ return 0;
+ }
+
+
+ void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName)
+ throw (SALOME::SALOME_Exception)
+ {
+ ASSERT(myBaseImpl);
+ try {
+ this->GetImpl()->SetEnforcedVertexGroupName(x, y, z, groupName);
+ }
+ catch (const std::invalid_argument& ex) {
+ SALOME::ExceptionStruct ExDescription;
+ ExDescription.text = ex.what();
+ ExDescription.type = SALOME::BAD_PARAM;
+ ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetEnforcedVertexGroupName(x,y,z)";
+ ExDescription.lineNumber = 1170;
+ throw SALOME::SALOME_Exception(ExDescription);
+ }
+ catch (SALOME_Exception& ex) {
+ THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+ }
+
+ SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGroupName("
+ << x << ", " << y << ", " << z << ", '" << groupName << "' )";
+
+ }
+*/
///////////////////////
///////////////////////
std::string BLSURFPlugin_Hypothesis_i::ShapeTypeToString(GEOM::shape_type theShapeType)
{
-//enum shape_type { COMPOUND, COMPSOLID, SOLID, SHELL, FACE, WIRE, EDGE, VERTEX, SHAPE /*, __max_shape_type=0xffffffff */ };
std::map<GEOM::shape_type, std::string> MapShapeTypeToString;
MapShapeTypeToString[GEOM::COMPOUND] = std::string("COMPOUND");
MapShapeTypeToString[GEOM::COMPSOLID] = std::string("COMPSOLID");
bool ok = false;
std::stringstream typesTxt;
for (std::size_t i=0; i<theShapeTypes.size(); i++)
- {
- GEOM::shape_type theShapeType = theShapeTypes[i];
- if (shape->GetShapeType() == theShapeType)
- ok = true;
- typesTxt << ShapeTypeToString(theShapeType);
- if (i < theShapeTypes.size()-1 )
- typesTxt << ", ";
- }
+ {
+ GEOM::shape_type theShapeType = theShapeTypes[i];
+ if (shape->GetShapeType() == theShapeType)
+ ok = true;
+ typesTxt << ShapeTypeToString(theShapeType);
+ if (i < theShapeTypes.size()-1 )
+ typesTxt << ", ";
+ }
if (!ok){
std::stringstream msg;
- msg << "shape shape type is not in" << typesTxt.str();
- MESSAGE(msg.str());
+ msg << "shape type is not in" << typesTxt.str();
THROW_SALOME_CORBA_EXCEPTION(msg.str().c_str(), SALOME::BAD_PARAM);
}
}
if (shape->GetShapeType() != theShapeType) {
std::stringstream msg;
msg << "shape shape type is not " << ShapeTypeToString(theShapeType);
- MESSAGE(msg.str());
THROW_SALOME_CORBA_EXCEPTION(msg.str().c_str(), SALOME::BAD_PARAM);
}
}
std::stringstream listEntriesTxt;
if (!theSourceVerticesEntries.empty())
+ {
+ listEntriesTxt << ", [" ;
+ size_t i =0;
+ for (std::vector<std::string>::const_iterator it = theSourceVerticesEntries.begin(); it != theSourceVerticesEntries.end(); it++, i++)
{
- listEntriesTxt << ", [" ;
- size_t i =0;
- for (std::vector<std::string>::const_iterator it = theSourceVerticesEntries.begin(); it != theSourceVerticesEntries.end(); it++, i++)
- {
- if (i>0)
- listEntriesTxt << ", ";
- listEntriesTxt << *it;
- }
+ if (i>0)
+ listEntriesTxt << ", ";
+ listEntriesTxt << *it;
+ }
- listEntriesTxt << "], [" ;
- i =0;
- for (std::vector<std::string>::const_iterator it = theTargetVerticesEntries.begin(); it != theTargetVerticesEntries.end(); it++, i++)
- {
- if (i>0)
- listEntriesTxt << ", ";
- listEntriesTxt << *it;
- }
- listEntriesTxt << "]" ;
+ listEntriesTxt << "], [" ;
+ i =0;
+ for (std::vector<std::string>::const_iterator it = theTargetVerticesEntries.begin(); it != theTargetVerticesEntries.end(); it++, i++)
+ {
+ if (i>0)
+ listEntriesTxt << ", ";
+ listEntriesTxt << *it;
}
+ listEntriesTxt << "]" ;
+ }
return listEntriesTxt.str();
}
BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::GetPreCadFacesPeriodicityVector()
{
- MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadFacesPeriodicityVector");
const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector preCadPeriodicityVector =
- this->GetImpl()->_GetPreCadFacesPeriodicityVector();
+ this->GetImpl()->_GetPreCadFacesPeriodicityVector();
BLSURFPlugin::TPeriodicityList_var periodicityList = PreCadVectorToSequence(preCadPeriodicityVector);
- MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadFacesPeriodicityVector end");
return periodicityList._retn();
}
BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::GetPreCadEdgesPeriodicityVector()
{
- MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadEdgesPeriodicityVector");
const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector preCadPeriodicityVector =
- this->GetImpl()->_GetPreCadEdgesPeriodicityVector();
+ this->GetImpl()->_GetPreCadEdgesPeriodicityVector();
BLSURFPlugin::TPeriodicityList_var periodicityList = PreCadVectorToSequence(preCadPeriodicityVector);
- MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadEdgesPeriodicityVector end");
return periodicityList._retn();
}
// convert a vector preCadPeriodicityVector into TPeriodicityList Corba sequence
BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::PreCadVectorToSequence(const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector& preCadPeriodicityVector)
{
- MESSAGE("BLSURFPlugin_Hypothesis_i::PreCadVectorToSequence");
BLSURFPlugin::TPeriodicityList_var periodicityList = new BLSURFPlugin::TPeriodicityList();
- periodicityList->length(preCadPeriodicityVector.size());
+ periodicityList->length(preCadPeriodicityVector.size());
-
for (size_t i = 0; i<preCadPeriodicityVector.size(); i++)
- {
- ::BLSURFPlugin_Hypothesis::TPreCadPeriodicity preCadPeriodicityVector_i = preCadPeriodicityVector[i];
+ for (size_t i = 0; i<preCadPeriodicityVector.size(); i++)
+ {
+ ::BLSURFPlugin_Hypothesis::TPreCadPeriodicity preCadPeriodicityVector_i = preCadPeriodicityVector[i];
- BLSURFPlugin::TPreCadPeriodicity_var myPreCadPeriodicity = new BLSURFPlugin::TPreCadPeriodicity();
- myPreCadPeriodicity->shape1Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape1Entry.c_str());
- myPreCadPeriodicity->shape2Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape2Entry.c_str());
+ BLSURFPlugin::TPreCadPeriodicity_var myPreCadPeriodicity = new BLSURFPlugin::TPreCadPeriodicity();
+ myPreCadPeriodicity->shape1Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape1Entry.c_str());
+ myPreCadPeriodicity->shape2Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape2Entry.c_str());
- BLSURFPlugin::TEntryList_var sourceVertices = new BLSURFPlugin::TEntryList();
- if (! preCadPeriodicityVector_i.theSourceVerticesEntries.empty())
- {
- sourceVertices->length(preCadPeriodicityVector_i.theSourceVerticesEntries.size());
-
for (size_t j=0; j<preCadPeriodicityVector_i.theSourceVerticesEntries.size(); j++)
- sourceVertices[j]=CORBA::string_dup(preCadPeriodicityVector_i.theSourceVerticesEntries[j].c_str());
- }
+ BLSURFPlugin::TEntryList_var sourceVertices = new BLSURFPlugin::TEntryList();
+ if (! preCadPeriodicityVector_i.theSourceVerticesEntries.empty())
+ {
+ sourceVertices->length(preCadPeriodicityVector_i.theSourceVerticesEntries.size());
+ for (size_t j=0; j<preCadPeriodicityVector_i.theSourceVerticesEntries.size(); j++)
+ sourceVertices[j]=CORBA::string_dup(preCadPeriodicityVector_i.theSourceVerticesEntries[j].c_str());
+ }
- myPreCadPeriodicity->theSourceVerticesEntries = sourceVertices;
+ myPreCadPeriodicity->theSourceVerticesEntries = sourceVertices;
- BLSURFPlugin::TEntryList_var targetVertices = new BLSURFPlugin::TEntryList();
- if (! preCadPeriodicityVector_i.theTargetVerticesEntries.empty())
- {
- targetVertices->length(preCadPeriodicityVector_i.theTargetVerticesEntries.size());
-
for (size_t j=0; j<preCadPeriodicityVector_i.theTargetVerticesEntries.size(); j++)
- targetVertices[j]=CORBA::string_dup(preCadPeriodicityVector_i.theTargetVerticesEntries[j].c_str());
- }
+ BLSURFPlugin::TEntryList_var targetVertices = new BLSURFPlugin::TEntryList();
+ if (! preCadPeriodicityVector_i.theTargetVerticesEntries.empty())
+ {
+ targetVertices->length(preCadPeriodicityVector_i.theTargetVerticesEntries.size());
+ for (size_t j=0; j<preCadPeriodicityVector_i.theTargetVerticesEntries.size(); j++)
+ targetVertices[j]=CORBA::string_dup(preCadPeriodicityVector_i.theTargetVerticesEntries[j].c_str());
+ }
- myPreCadPeriodicity->theTargetVerticesEntries = targetVertices;
+ myPreCadPeriodicity->theTargetVerticesEntries = targetVertices;
- periodicityList[i] = myPreCadPeriodicity;
- }
+ periodicityList[i] = myPreCadPeriodicity;
+ }
return periodicityList._retn();
void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicity(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2)
-throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
const GEOM::ListOfGO theSourceVertices;
void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2,
- const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
-throw (SALOME::SALOME_Exception)
+ const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
+ throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
- MESSAGE("BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityWithVertices");
size_t theLength = theSourceVertices.length();
if (theLength != theTargetVertices.length())
GEOM::GEOM_Object_ptr theVtx_i;
string theEntry_i;
for (size_t ind = 0; ind < theLength; ind++) {
- theVtx_i = theSourceVertices[ind];
- theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3);
- theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
+ theVtx_i = theSourceVertices[ind];
+ theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3);
+ theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
}
string prefix4 = "Target_vertex_";
BLSURFPlugin::TEntryList_var theTargetVerticesEntries = new BLSURFPlugin::TEntryList();
theTargetVerticesEntries->length(theLength);
for (size_t ind = 0; ind < theLength; ind++) {
- theVtx_i = theTargetVertices[ind];
- theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4);
- theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
+ theVtx_i = theTargetVertices[ind];
+ theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4);
+ theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
}
string theFace2Name = theFace2->GetName();
- MESSAGE("IDL : theFace1->GetName : " << theFace1->GetName());
- MESSAGE("IDL : theFace2->GetName : " << theFace2->GetName());
- MESSAGE("IDL : AddPreCadFacesPeriodicity( "<< theFace1Entry << ", " << theFace2Entry << ")");
try {
- AddPreCadFacesPeriodicityEntry(theFace1Entry.c_str(), theFace2Entry.c_str(),
- theSourceVerticesEntries, theTargetVerticesEntries);
+ AddPreCadFacesPeriodicityEntry(theFace1Entry.c_str(), theFace2Entry.c_str(),
+ theSourceVerticesEntries, theTargetVerticesEntries);
} catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityEntry(const char* theFace1Entry, const char* theFace2Entry,
- const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
- throw (SALOME::SALOME_Exception)
+ const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
+ throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
// Convert BLSURFPlugin::TEntryList to vector<string>
vector<string> theSourceVerticesEntries, theTargetVerticesEntries;
for (size_t ind = 0; ind < theSourceVerticesEntriesCorba.length(); ind++) {
- theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in());
- theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in());
+ theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in());
+ theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in());
}
string listEntriesTxt = FormatVerticesEntries(theSourceVerticesEntries, theTargetVerticesEntries);
- MESSAGE("IDL : AddPreCadFacesPeriodicityEntry(" << theFace1Entry << ", " << theFace2Entry << listEntriesTxt.c_str() << ")");
this->GetImpl()->AddPreCadFacesPeriodicity(theFace1Entry, theFace2Entry,
- theSourceVerticesEntries, theTargetVerticesEntries);
+ theSourceVerticesEntries, theTargetVerticesEntries);
SMESH::TPythonDump pd;
if (!theSourceVerticesEntries.empty())
- {
- pd << _this() << ".AddPreCadFacesPeriodicityWithVertices(" << theFace1Entry << ", " << theFace2Entry;
- pd << listEntriesTxt.c_str();
- pd << ")";
- }
+ {
+ pd << _this() << ".AddPreCadFacesPeriodicityWithVertices(" << theFace1Entry << ", " << theFace2Entry;
+ pd << listEntriesTxt.c_str();
+ pd << ")";
+ }
else
pd << _this() << ".AddPreCadFacesPeriodicity(" << theFace1Entry << ", " << theFace2Entry << ")";
- MESSAGE("IDL : AddPreCadFacesPeriodicityEntry END");
}
void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicity(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2)
- throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
const GEOM::ListOfGO theSourceVertices;
}
void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2,
- const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
- throw (SALOME::SALOME_Exception)
+ const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
+ throw (SALOME::SALOME_Exception)
{
- MESSAGE("BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices");
ASSERT(myBaseImpl);
size_t theLength = theSourceVertices.length();
GEOM::GEOM_Object_ptr theVtx_i;
string theEntry_i;
for (size_t ind = 0; ind < theLength; ind++) {
- theVtx_i = theSourceVertices[ind];
- theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3);
- theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
+ theVtx_i = theSourceVertices[ind];
+ theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3);
+ theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
}
string prefix4 = "Target_vertex_";
BLSURFPlugin::TEntryList_var theTargetVerticesEntries = new BLSURFPlugin::TEntryList();
theTargetVerticesEntries->length(theLength);
for (size_t ind = 0; ind < theLength; ind++) {
- theVtx_i = theTargetVertices[ind];
- theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4);
- theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
+ theVtx_i = theTargetVertices[ind];
+ theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4);
+ theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str());
}
string theEdge2Name = theEdge2->GetName();
- MESSAGE("IDL : theEdge1->GetName : " << theEdge1->GetName());
- MESSAGE("IDL : theEdge2->GetName : " << theEdge2->GetName());
- MESSAGE("IDL : AddPreCadEdgesPeriodicity( "<< theEdge1Entry << ", " << theEdge2Entry << ")");
try {
- AddPreCadEdgesPeriodicityEntry(theEdge1Entry.c_str(), theEdge2Entry.c_str(),
- theSourceVerticesEntries, theTargetVerticesEntries);
+ AddPreCadEdgesPeriodicityEntry(theEdge1Entry.c_str(), theEdge2Entry.c_str(),
+ theSourceVerticesEntries, theTargetVerticesEntries);
} catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityEntry(const char* theEdge1Entry, const char* theEdge2Entry,
- const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
- throw (SALOME::SALOME_Exception)
+ const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
+ throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
// Convert BLSURFPlugin::TEntryList to vector<string>
vector<string> theSourceVerticesEntries, theTargetVerticesEntries;
for (size_t ind = 0; ind < theSourceVerticesEntriesCorba.length(); ind++) {
- theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in());
- theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in());
+ theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in());
+ theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in());
}
string listEntriesTxt = FormatVerticesEntries(theSourceVerticesEntries, theTargetVerticesEntries);
- MESSAGE("IDL : AddPreCadEdgesPeriodicityEntry(" << theEdge1Entry << ", " << theEdge2Entry << listEntriesTxt.c_str() << ")");
this->GetImpl()->AddPreCadEdgesPeriodicity(theEdge1Entry, theEdge2Entry,
- theSourceVerticesEntries, theTargetVerticesEntries);
+ theSourceVerticesEntries, theTargetVerticesEntries);
SMESH::TPythonDump pd;
if (!theSourceVerticesEntries.empty())
- {
- pd << _this() << ".AddPreCadEdgesPeriodicityWithVertices(" << theEdge1Entry << ", " << theEdge2Entry;
- pd << listEntriesTxt.c_str();
- pd << ")";
- }
+ {
+ pd << _this() << ".AddPreCadEdgesPeriodicityWithVertices(" << theEdge1Entry << ", " << theEdge2Entry;
+ pd << listEntriesTxt.c_str();
+ pd << ")";
+ }
else
pd << _this() << ".AddPreCadEdgesPeriodicity(" << theEdge1Entry << ", " << theEdge2Entry << ")";
- MESSAGE("IDL : AddPreCadEdgesPeriodicityEntry END");
}
// void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName, CORBA::Boolean isBinary) {
void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName) {
ASSERT(myBaseImpl);
- MESSAGE("IDL : SetGMFFile(" << theFileName << ")");
bool valueChanged/*, modeChanged*/ = false;
try {
valueChanged = (this->GetImpl()->GetGMFFile() != theFileName);
-// modeChanged = (this->GetImpl()->GetGMFFileMode() != isBinary);
+ // modeChanged = (this->GetImpl()->GetGMFFileMode() != isBinary);
if (valueChanged)// or (!valueChanged && modeChanged))
this->GetImpl()->SetGMFFile(theFileName);// ,isBinary);
} catch (const std::exception& ex) {
}
if (valueChanged)// or (!valueChanged && modeChanged))
SMESH::TPythonDump() << _this() << ".SetGMFFile(\"" << theFileName << "\")"; //", " << isBinary << ")";
- MESSAGE("IDL : SetGMFFile END ");
}
//================================================================================
//================================================================================
char* BLSURFPlugin_Hypothesis_i::GetGMFFile() {
ASSERT(myBaseImpl);
-// MESSAGE("IDL : GetGMFFile()");
return CORBA::string_dup(this->GetImpl()->GetGMFFile().c_str());
}
// //================================================================================
// CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetGMFFileMode() {
// ASSERT(myBaseImpl);
-// MESSAGE("IDL : GetGMFFileMode()");
// return this->GetImpl()->GetGMFFileMode();
// }
*/
//=============================================================================
::BLSURFPlugin_Hypothesis* BLSURFPlugin_Hypothesis_i::GetImpl() {
- // MESSAGE("BLSURFPlugin_Hypothesis_i::GetImpl");
return (::BLSURFPlugin_Hypothesis*) myBaseImpl;
}
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetDecimesh() {
std::string theValueStr = this->GetOptionValue("respect_geometry");
if (theValueStr.empty() || theValueStr == "respect")
- return true;
+ return true;
return false;
}
void BLSURFPlugin_Hypothesis_i::SetPreCADRemoveNanoEdges(CORBA::Boolean theValue) {
CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADRemoveNanoEdges() {
std::string theValueStr = this->GetPreCADOption("remove_tiny_edges");
if (theValueStr == "1")
- return true;
+ return true;
return false;
}
void BLSURFPlugin_Hypothesis_i::SetPreCADEpsNano(CORBA::Double theValue) {
