find resources -name Makefile.in | xargs rm -f
find adm_local -name Makefile.in | xargs rm -f
find src -name Makefile.in | xargs rm -f
+rm -f adm_local/unix/config_files/config*
+rm -f adm_local/unix/config_files/depcomp
+rm -f adm_local/unix/config_files/install-sh
+rm -f adm_local/unix/config_files/libtool.m4
+rm -f adm_local/unix/config_files/ltmain.sh
+rm -f adm_local/unix/config_files/ltoptions.m4
+rm -f adm_local/unix/config_files/ltsugar.m4
+rm -f adm_local/unix/config_files/ltversion.m4
+rm -f adm_local/unix/config_files/lt~obsolete.m4
+rm -f adm_local/unix/config_files/missing
rm -f Makefile.in
rm -Rf salome_adm
typedef sequence<string> string_array;
// Entry
- typedef string TEnfEntry;
- // Enforced vertex = 3 coordinates
- typedef sequence<double,3> TEnfVertex;
+ typedef string TEntry;
+ typedef sequence<TEntry> TEntryList;
+ // Enforced vertex name
+ typedef string TEnfName;
+ // Group name
+ typedef string TEnfGroupName;
+
+ // Coordinates of enforced vertex
+ typedef sequence<double,3> TEnfVertexCoords;
+ // List of coords
+ typedef sequence<TEnfVertexCoords> TEnfVertexCoordsList;
+
+ // Enforced vertex
+ struct TEnfVertex {
+ TEnfName name;
+ TEntry geomEntry;
+ TEnfVertexCoords coords;
+ TEnfGroupName grpName;
+ TEntryList faceEntries;
+ };
// List of enforced vertices
typedef sequence<TEnfVertex> TEnfVertexList;
- // Map Entry / List of enforced vertices
- struct TEntryEnfVertexListMapElement {
- TEnfEntry entry;
- TEnfVertexList vertexList;
+
+ // Map Face Entry / List of enforced vertices
+ struct TFaceEntryEnfVertexListMapElement {
+ TEntry faceEntry;
+ TEnfVertexList enfVertexList;
+ };
+ typedef sequence<TFaceEntryEnfVertexListMapElement> TFaceEntryEnfVertexListMap;
+
+ // Map Face Entry / List of coords
+ struct TFaceEntryCoordsListMapElement {
+ TEntry faceEntry;
+ TEnfVertexCoordsList coordsList;
+ };
+ typedef sequence<TFaceEntryCoordsListMapElement> TFaceEntryCoordsListMap;
+
+ // Map Face Entry / List of enf vertex entries
+ struct TFaceEntryEnfVertexEntryListMapElement {
+ TEntry faceEntry;
+ TEntryList enfVertexEntryList;
+ };
+ typedef sequence<TFaceEntryEnfVertexEntryListMapElement> TFaceEntryEnfVertexEntryListMap;
+
+ // Map Coords / Enforced vertex
+ struct TCoordsEnfVertexElement {
+ TEnfVertexCoords coords;
+ TEnfVertex enfVertex;
};
- typedef sequence<TEntryEnfVertexListMapElement> TEntryEnfVertexListMap;
+ typedef sequence<TCoordsEnfVertexElement> TCoordsEnfVertexMap;
+
+ // Map Enf Vertex Entry / Enforced vertex
+ struct TEnfVertexEntryEnfVertexElement {
+ TEntry enfVertexEntry;
+ TEnfVertex enfVertex;
+ };
+ typedef sequence<TEnfVertexEntryEnfVertexElement> TEnfVertexEntryEnfVertexMap;
+
/* TODO GROUPS
- // Group name
- typedef string TEnfGroupName;
// Map Group Name / List of enforced vertices
struct TGroupNameEnfVertexListMapElement {
TEnfGroupName groupName;
TEnfVertexList vertexList;
};
typedef sequence<TGroupNameEnfVertexListMapElement> TGroupNameEnfVertexListMap;
- // Map Enforced vertex / Group Name
- struct TEnfVertexGroupNameMapElement {
- TEnfVertex vertex;
- TEnfGroupName groupName;
- };
- typedef sequence<TEnfVertexGroupNameMapElement> TEnfVertexGroupNameMap;
*/
// ENFORCED VERTEXES //
///////////////////////
- TEntryEnfVertexListMap GetAllEnforcedVertices();
- void ClearAllEnforcedVertices();
+ TFaceEntryEnfVertexListMap GetAllEnforcedVerticesByFace();
+ TEnfVertexList GetAllEnforcedVertices();
+
+ TFaceEntryCoordsListMap GetAllCoordsByFace();
+ TCoordsEnfVertexMap GetAllEnforcedVerticesByCoords();
+
+ TFaceEntryEnfVertexEntryListMap GetAllEnfVertexEntriesByFace();
+ TEnfVertexEntryEnfVertexMap GetAllEnforcedVerticesByEnfVertexEntry();
+
+ void ClearAllEnforcedVertices();
/*!
- * Set/get/unset an enforced vertex on geom object
+ * Set/get/unset an enforced vertex on geom face
*/
- void SetEnforcedVertex(in GEOM::GEOM_Object GeomObj, in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
- /* TODO GROUPS
- void SetEnforcedVertexWithGroup(in GEOM::GEOM_Object GeomObj, in double x, in double y, in double z, in TEnfGroupName groupName) raises (SALOME::SALOME_Exception);
- */
-// void SetEnforcedVertexList(in GEOM::GEOM_Object GeomObj, in TEnfVertexList vertexList) raises (SALOME::SALOME_Exception);
+ boolean SetEnforcedVertex(in GEOM::GEOM_Object theFace, in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
+ boolean SetEnforcedVertexNamed(in GEOM::GEOM_Object theFace, in double x, in double y, in double z, in TEnfName theVertexName) raises (SALOME::SALOME_Exception);
+ boolean SetEnforcedVertexGeom(in GEOM::GEOM_Object theFace, in GEOM::GEOM_Object theVertex) raises (SALOME::SALOME_Exception);
+ boolean SetEnforcedVertexWithGroup(in GEOM::GEOM_Object theFace, in double x, in double y, in double z, in TEnfGroupName groupName) raises (SALOME::SALOME_Exception);
+ boolean SetEnforcedVertexNamedWithGroup(in GEOM::GEOM_Object theFace, in double x, in double y, in double z, in TEnfName theVertexName, in TEnfGroupName groupName) raises (SALOME::SALOME_Exception);
+ boolean SetEnforcedVertexGeomWithGroup(in GEOM::GEOM_Object theFace, in GEOM::GEOM_Object theVertex, in TEnfGroupName groupName) raises (SALOME::SALOME_Exception);
+
- TEnfVertexList GetEnforcedVertices(in GEOM::GEOM_Object GeomObj) raises (SALOME::SALOME_Exception);
+ TEnfVertexList GetEnforcedVertices(in GEOM::GEOM_Object theFace) raises (SALOME::SALOME_Exception);
- void UnsetEnforcedVertex(in GEOM::GEOM_Object GeomObj, in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
-// void UnsetEnforcedVertexList(in GEOM::GEOM_Object GeomObj, in TEnfVertexList vertexList) raises (SALOME::SALOME_Exception);
- void UnsetEnforcedVertices(in GEOM::GEOM_Object GeomObj) raises (SALOME::SALOME_Exception);
+ boolean UnsetEnforcedVertex(in GEOM::GEOM_Object theFace, in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
+ boolean UnsetEnforcedVertexGeom(in GEOM::GEOM_Object theFace, in GEOM::GEOM_Object theVertex) raises (SALOME::SALOME_Exception);
+ boolean UnsetEnforcedVertices(in GEOM::GEOM_Object theFace) raises (SALOME::SALOME_Exception);
/*!
- * Set/get/unset an enforced vertex on geom object given by entry
+ * Set/get/unset an enforced vertex on geom face given by entry
*/
- void SetEnforcedVertexEntry(in TEnfEntry entry, in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
+ boolean SetEnforcedVertexEntry(in TEntry theFaceEntry, in double x, in double y, in double z,
+ in TEnfName theVertexName, in TEntry theVertexEntry, in string groupName) raises (SALOME::SALOME_Exception);
+// boolean SetEnforcedVertexEntryNamed(in TEntry theFaceEntry, in double x, in double y, in double z, in TEnfName theVertexName) raises (SALOME::SALOME_Exception);
+// boolean SetEnforcedVertexEntryGeom(in TEntry theFaceEntry, in TEntry theVertexEntry, in TEnfName theVertexName) raises (SALOME::SALOME_Exception);
/* TODO GROUPS
- void SetEnforcedVertexEntryWithGroup(in TEnfEntry entry, in double x, in double y, in double z, in TEnfGroupName groupName)
+ void SetEnforcedVertexEntryWithGroup(in string theFaceEntry, in double x, in double y, in double z, in TEnfGroupName groupName)
raises (SALOME::SALOME_Exception);
*/
-// void SetEnforcedVertexListEntry(in TEnfEntry entry, in TEnfVertexList vertexList) raises (SALOME::SALOME_Exception);
//
- TEnfVertexList GetEnforcedVerticesEntry(in TEnfEntry entry) raises (SALOME::SALOME_Exception);
+ TEnfVertexList GetEnforcedVerticesEntry(in TEntry theFaceEntry) raises (SALOME::SALOME_Exception);
//
- void UnsetEnforcedVertexEntry(in TEnfEntry entry, in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
-// void UnsetEnforcedVertexListEntry(in TEnfEntry entry, in TEnfVertexList vertexList) raises (SALOME::SALOME_Exception);
- void UnsetEnforcedVerticesEntry(in TEnfEntry entry) raises (SALOME::SALOME_Exception);
+ boolean UnsetEnforcedVertexEntry(in TEntry theFaceEntry, in double x, in double y, in double z, in TEntry theVertexEntry) raises (SALOME::SALOME_Exception);
+// boolean UnsetEnforcedVertexEntryGeom(in TEntry theFaceEntry, in TEntry theVertexEntry) raises (SALOME::SALOME_Exception);
+ boolean UnsetEnforcedVerticesEntry(in TEntry theFaceEntry) raises (SALOME::SALOME_Exception);
/*!
* Set/get an enforced vertex on geom object and add it to a group
// ---
//
#include "BLSURFPlugin_BLSURF.hxx"
-#include "BLSURFPlugin_Hypothesis.hxx"
extern "C"{
#include <distene/api.h>
std::map<int,PyObject*> EdgeId2PythonSmp;
std::map<int,PyObject*> VertexId2PythonSmp;
-std::map<int,std::vector<double> > FaceId2AttractorCoords;
+std::map<int,BLSURFPlugin_Hypothesis::TEnfVertexCoords > FaceId2AttractorCoords;
TopTools_IndexedMapOfShape FacesWithEnforcedVertices;
-std::map< int, std::set< std::vector<double> > > FaceId2EnforcedVertexCoords;
-std::map< std::vector<double>, std::vector<double> > EnfVertex2ProjVertex;
+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;
bool HasSizeMapOnFace=false;
bool HasSizeMapOnEdge=false;
FaceId2AttractorCoords.clear();
FacesWithEnforcedVertices.Clear();
FaceId2EnforcedVertexCoords.clear();
- EnfVertex2ProjVertex.clear();
+ EnfVertexCoords2ProjVertex.clear();
+ EnfVertexCoords2EnfVertexList.clear();
}
//=============================================================================
gp_XYZ xyz;
} projectionPoint;
/////////////////////////////////////////////////////////
-projectionPoint getProjectionPoint(const TopoDS_Face& face, const gp_XYZ& point)
+projectionPoint getProjectionPoint(const TopoDS_Face& face, const gp_Pnt& point)
{
projectionPoint myPoint;
Handle(Geom_Surface) surface = BRep_Tool::Surface(face);
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
-double getT(const TopoDS_Edge& edge, const gp_XYZ& point)
+double getT(const TopoDS_Edge& edge, const gp_Pnt& point)
{
Standard_Real f,l;
Handle(Geom_Curve) curve = BRep_Tool::Curve(edge, f,l);
return S;
}
-/////////////////////////////////////////////////////////
-void createEnforcedVertexOnFace(TopoDS_Shape GeomShape, BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList)
+void _createEnforcedVertexOnFace(TopoDS_Face faceShape, gp_Pnt aPnt, BLSURFPlugin_Hypothesis::TEnfVertex *enfVertex)
{
- double xe, ye, ze;
- std::vector<double> coords;
- std::vector<double> s_coords;
- std::vector<double> enfVertex;
-// BLSURFPlugin_Hypothesis::TEnfVertex enfVertex;
- BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = enfVertexList.begin();
-
- for( ; evlIt != enfVertexList.end() ; ++evlIt ) {
- coords.clear();
- s_coords.clear();
- enfVertex = *evlIt;
- xe = enfVertex[0];
- ye = enfVertex[1];
- ze = enfVertex[2];
- MESSAGE("Enforced Vertex: " << xe << ", " << ye << ", " << ze);
- // Get the (u,v) values of the enforced vertex on the face
- projectionPoint myPoint = getProjectionPoint(TopoDS::Face(GeomShape),gp_XYZ(xe,ye,ze));
- gp_XY uvPoint = myPoint.uv;
- gp_XYZ xyzPoint = myPoint.xyz;
- Standard_Real u0 = uvPoint.X();
- Standard_Real v0 = uvPoint.Y();
- Standard_Real x0 = xyzPoint.X();
- Standard_Real y0 = xyzPoint.Y();
- Standard_Real z0 = xyzPoint.Z();
- MESSAGE("Projected Vertex: " << x0 << ", " << y0 << ", " << z0);
- MESSAGE("Parametric coordinates: " << u0 << ", " << v0 );
- coords.push_back(u0);
- coords.push_back(v0);
- coords.push_back(x0);
- coords.push_back(y0);
- coords.push_back(z0);
-
- s_coords.push_back(x0);
- s_coords.push_back(y0);
- s_coords.push_back(z0);
-
- // Save pair projected vertex / enf vertex
- MESSAGE("Storing pair projected vertex / enf vertex:");
- MESSAGE("("<< x0 << ", " << y0 << ", " << z0 <<") / (" << xe << ", " << ye << ", " << ze<<")");
- EnfVertex2ProjVertex[s_coords] = enfVertex;
-
- int key = 0;
- if (! FacesWithEnforcedVertices.Contains(TopoDS::Face(GeomShape))) {
- key = FacesWithEnforcedVertices.Add(TopoDS::Face(GeomShape));
- }
- else {
- key = FacesWithEnforcedVertices.FindIndex(TopoDS::Face(GeomShape));
+ BLSURFPlugin_Hypothesis::TEnfVertexCoords enf_coords, coords, s_coords;
+ enf_coords.clear();
+ coords.clear();
+ s_coords.clear();
+
+ // Get the (u,v) values of the enforced vertex on the face
+ projectionPoint myPoint = getProjectionPoint(faceShape,aPnt);
+
+ MESSAGE("Enforced Vertex: " << aPnt.X() << ", " << aPnt.Y() << ", " << aPnt.Z());
+ MESSAGE("Projected Vertex: " << myPoint.xyz.X() << ", " << myPoint.xyz.Y() << ", " << myPoint.xyz.Z());
+ MESSAGE("Parametric coordinates: " << myPoint.uv.X() << ", " << myPoint.uv.Y() );
+
+ enf_coords.push_back(aPnt.X());
+ enf_coords.push_back(aPnt.Y());
+ enf_coords.push_back(aPnt.Z());
+
+ coords.push_back(myPoint.uv.X());
+ coords.push_back(myPoint.uv.Y());
+ coords.push_back(myPoint.xyz.X());
+ coords.push_back(myPoint.xyz.Y());
+ coords.push_back(myPoint.xyz.Z());
+
+ s_coords.push_back(myPoint.xyz.X());
+ s_coords.push_back(myPoint.xyz.Y());
+ s_coords.push_back(myPoint.xyz.Z());
+
+ // Save pair projected vertex / enf vertex
+ MESSAGE("Storing pair projected vertex / enf vertex:");
+ MESSAGE("("<< myPoint.xyz.X() << ", " << myPoint.xyz.Y() << ", " << myPoint.xyz.Z() <<") / (" << aPnt.X() << ", " << aPnt.Y() << ", " << aPnt.Z()<<")");
+ EnfVertexCoords2ProjVertex[s_coords] = enf_coords;
+ MESSAGE("Group name is: \"" << enfVertex->grpName << "\"");
+ EnfVertexCoords2EnfVertexList[s_coords].insert(enfVertex);
+
+ int key = 0;
+ if (! FacesWithEnforcedVertices.Contains(faceShape)) {
+ key = FacesWithEnforcedVertices.Add(faceShape);
+ }
+ else {
+ key = FacesWithEnforcedVertices.FindIndex(faceShape);
+ }
+
+ // If a node is already created by an attractor, do not create enforced vertex
+ int attractorKey = FacesWithSizeMap.FindIndex(faceShape);
+ bool sameAttractor = false;
+ if (attractorKey >= 0)
+ if (FaceId2AttractorCoords.count(attractorKey) > 0)
+ if (FaceId2AttractorCoords[attractorKey] == coords)
+ sameAttractor = true;
+
+ if (FaceId2EnforcedVertexCoords.find(key) != FaceId2EnforcedVertexCoords.end()) {
+ MESSAGE("Map of enf. vertex has key " << key)
+ MESSAGE("Enf. vertex list size is: " << FaceId2EnforcedVertexCoords[key].size())
+ if (! sameAttractor)
+ FaceId2EnforcedVertexCoords[key].insert(coords); // there should be no redondant coords here (see std::set management)
+ else
+ MESSAGE("An attractor node is already defined: I don't add the enforced vertex");
+ MESSAGE("New Enf. vertex list size is: " << FaceId2EnforcedVertexCoords[key].size())
+ }
+ else {
+ MESSAGE("Map of enf. vertex has not key " << key << ": creating it")
+ if (! sameAttractor) {
+ BLSURFPlugin_Hypothesis::TEnfVertexCoordsList ens;
+ ens.insert(coords);
+ FaceId2EnforcedVertexCoords[key] = ens;
}
+ else
+ MESSAGE("An attractor node is already defined: I don't add the enforced vertex");
+ }
+}
- // If a node is already created by an attractor, do not create enforced vertex
- int attractorKey = FacesWithSizeMap.FindIndex(TopoDS::Face(GeomShape));
- bool sameAttractor = false;
- if (attractorKey >= 0)
- if (FaceId2AttractorCoords.count(attractorKey) > 0)
- if (FaceId2AttractorCoords[attractorKey] == coords)
- sameAttractor = true;
-
- if (FaceId2EnforcedVertexCoords.find(key) != FaceId2EnforcedVertexCoords.end()) {
- MESSAGE("Map of enf. vertex has key " << key)
- MESSAGE("Enf. vertex list size is: " << FaceId2EnforcedVertexCoords[key].size())
- if (! sameAttractor)
- FaceId2EnforcedVertexCoords[key].insert(coords); // there should be no redondant coords here (see std::set management)
- else
- MESSAGE("An attractor node is already defined: I don't add the enforced vertex");
- MESSAGE("New Enf. vertex list size is: " << FaceId2EnforcedVertexCoords[key].size())
+/////////////////////////////////////////////////////////
+void BLSURFPlugin_BLSURF::createEnforcedVertexOnFace(TopoDS_Shape faceShape, BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList)
+{
+ BLSURFPlugin_Hypothesis::TEnfVertex* enfVertex;
+ gp_Pnt aPnt;
+
+ BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator enfVertexListIt = enfVertexList.begin();
+
+ for( ; enfVertexListIt != enfVertexList.end() ; ++enfVertexListIt ) {
+ enfVertex = *enfVertexListIt;
+ // Case of manual coords
+ if (enfVertex->coords.size() != 0) {
+ aPnt.SetCoord(enfVertex->coords[0],enfVertex->coords[1],enfVertex->coords[2]);
+ _createEnforcedVertexOnFace( TopoDS::Face(faceShape), aPnt, enfVertex);
}
- else {
- MESSAGE("Map of enf. vertex has not key " << key << ": creating it")
- if (! sameAttractor) {
- std::set< std::vector<double> > ens;
- ens.insert(coords);
- FaceId2EnforcedVertexCoords[key] = ens;
- }
- else
- MESSAGE("An attractor node is already defined: I don't add the enforced vertex");
+
+ // Case of geom vertex coords
+ if (enfVertex->geomEntry != "") {
+ TopoDS_Shape GeomShape = entryToShape(enfVertex->geomEntry);
+ TopAbs_ShapeEnum GeomType = GeomShape.ShapeType();
+ if (GeomType == TopAbs_VERTEX){
+ aPnt = BRep_Tool::Pnt(TopoDS::Vertex(GeomShape));
+ _createEnforcedVertexOnFace( TopoDS::Face(faceShape), aPnt, enfVertex);
+ }
+ // Group Management
+ if (GeomType == TopAbs_COMPOUND){
+ for (TopoDS_Iterator it (GeomShape); it.More(); it.Next()){
+ if (it.Value().ShapeType() == TopAbs_VERTEX){
+ aPnt = BRep_Tool::Pnt(TopoDS::Vertex(it.Value()));
+ _createEnforcedVertexOnFace( TopoDS::Face(faceShape), aPnt, enfVertex);
+ }
+ }
+ }
}
}
}
}
// Get the (u,v) values of the attractor on the face
- projectionPoint myPoint = getProjectionPoint(TopoDS::Face(GeomShape),gp_XYZ(xa,ya,za));
+ projectionPoint myPoint = getProjectionPoint(TopoDS::Face(GeomShape),gp_Pnt(xa,ya,za));
gp_XY uvPoint = myPoint.uv;
gp_XYZ xyzPoint = myPoint.xyz;
Standard_Real u0 = uvPoint.X();
// Enforced Vertices
//
MESSAGE("Setting Enforced Vertices");
- const BLSURFPlugin_Hypothesis::TEntryEnfVertexListMap entryEnfVertexListMap = BLSURFPlugin_Hypothesis::GetAllEnforcedVertices(hyp);
- BLSURFPlugin_Hypothesis::TEntryEnfVertexListMap::const_iterator enfIt = entryEnfVertexListMap.begin();
+ const BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap entryEnfVertexListMap = BLSURFPlugin_Hypothesis::GetAllEnforcedVerticesByFace(hyp);
+ BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap::const_iterator enfIt = entryEnfVertexListMap.begin();
for ( ; enfIt != entryEnfVertexListMap.end(); ++enfIt ) {
if ( !enfIt->second.empty() ) {
GeomShape = entryToShape(enfIt->first);
// Enforced Vertices
faceKey = FacesWithEnforcedVertices.FindIndex(f);
- std::map<int,std::set<std::vector<double> > >::const_iterator evmIt = FaceId2EnforcedVertexCoords.find(faceKey);
+ std::map<int,BLSURFPlugin_Hypothesis::TEnfVertexCoordsList >::const_iterator evmIt = FaceId2EnforcedVertexCoords.find(faceKey);
if (evmIt != FaceId2EnforcedVertexCoords.end()) {
MESSAGE("Some enforced vertices are defined");
-// int ienf = 0;
- std::set<std::vector<double> > evl;
-// std::vector<double> ev;
+ BLSURFPlugin_Hypothesis::TEnfVertexCoordsList evl;
MESSAGE("Face indice: " << iface);
MESSAGE("Adding enforced vertices");
evl = evmIt->second;
MESSAGE("Number of vertices to add: "<< evl.size());
- std::set< std::vector<double> >::const_iterator evlIt = evl.begin();
+ BLSURFPlugin_Hypothesis::TEnfVertexCoordsList::const_iterator evlIt = evl.begin();
for (; evlIt != evl.end(); ++evlIt) {
- std::vector<double> xyzCoords;
+ BLSURFPlugin_Hypothesis::TEnfVertexCoords xyzCoords;
xyzCoords.push_back(evlIt->at(2));
xyzCoords.push_back(evlIt->at(3));
xyzCoords.push_back(evlIt->at(4));
-// double xyzCoords[3] = {evlIt->at(2), evlIt->at(3), evlIt->at(4)};
MESSAGE("Check position of vertex =(" << xyzCoords[0] << "," << xyzCoords[1] << "," << xyzCoords[2] << ")");
gp_Pnt P(xyzCoords[0],xyzCoords[1],xyzCoords[2]);
BRepClass_FaceClassifier scl(f,P,1e-7);
TopAbs_State result = scl.State();
MESSAGE("Position of point on face: "<<result);
if ( result == TopAbs_OUT ) {
- MESSAGE("Point is out of face: node is not created");
- if (EnfVertex2ProjVertex.find(xyzCoords) != EnfVertex2ProjVertex.end())
- EnfVertex2ProjVertex.erase(xyzCoords);
+ MESSAGE("Point is out of face: node is not created");
+ if (EnfVertexCoords2ProjVertex.find(xyzCoords) != EnfVertexCoords2ProjVertex.end()) {
+ EnfVertexCoords2ProjVertex.erase(xyzCoords);
+ EnfVertexCoords2EnfVertexList.erase(xyzCoords);
+ }
}
if ( result == TopAbs_UNKNOWN ) {
MESSAGE("Point position on face is unknown: node is not created");
- if (EnfVertex2ProjVertex.find(xyzCoords) != EnfVertex2ProjVertex.end())
- EnfVertex2ProjVertex.erase(xyzCoords);
+ if (EnfVertexCoords2ProjVertex.find(xyzCoords) != EnfVertexCoords2ProjVertex.end()) {
+ EnfVertexCoords2ProjVertex.erase(xyzCoords);
+ EnfVertexCoords2EnfVertexList.erase(xyzCoords);
+ }
}
if ( result == TopAbs_ON ) {
MESSAGE("Point is on border of face: node is not created");
- if (EnfVertex2ProjVertex.find(xyzCoords) != EnfVertex2ProjVertex.end())
- EnfVertex2ProjVertex.erase(xyzCoords);
+ if (EnfVertexCoords2ProjVertex.find(xyzCoords) != EnfVertexCoords2ProjVertex.end()) {
+ EnfVertexCoords2ProjVertex.erase(xyzCoords);
+ EnfVertexCoords2EnfVertexList.erase(xyzCoords);
+ }
}
if ( result == TopAbs_IN )
{
// Point is inside face and not on border
MESSAGE("Point is in face: node is created");
-// double uvCoords[2] = {ev[0],ev[1]};
double uvCoords[2] = {evlIt->at(0),evlIt->at(1)};
ienf++;
MESSAGE("Add cad point on (u,v)=(" << uvCoords[0] << "," << uvCoords[1] << ") with id = " << ienf);
if(*ip <= 0)
*ip = pmap.Add(v);
- //vertexKey = VerticesWithSizeMap.FindIndex(v);
if (HasSizeMapOnVertex){
vertexKey = VerticesWithSizeMap.FindIndex(v);
if (VertexId2SizeMap.find(vertexKey)!=VertexId2SizeMap.end()){
}
nodes[iv] = meshDS->AddNode(xyz[0], xyz[1], xyz[2]);
- /* TODO GROUPS
// Create group of enforced vertices if requested
if(_hypothesis) {
- std::vector<double> projVertex;
+ BLSURFPlugin_Hypothesis::TEnfVertexCoords projVertex;
+ projVertex.clear();
projVertex.push_back((double)xyz[0]);
projVertex.push_back((double)xyz[1]);
projVertex.push_back((double)xyz[2]);
- std::map< std::vector<double>, std::vector<double> >::const_iterator projIt = EnfVertex2ProjVertex.find(projVertex);
- if (projIt != EnfVertex2ProjVertex.end()) {
- double x = (projIt->second)[0];
- double y = (projIt->second)[1];
- double z = (projIt->second)[2];
- BLSURFPlugin_Hypothesis::TEnfVertex enfVertex;
- enfVertex.push_back(x);
- enfVertex.push_back(y);
- enfVertex.push_back(z);
-
- BLSURFPlugin_Hypothesis::TEnfVertexGroupNameMap groupNameMap = _hypothesis->_GetEnforcedVertexGroupNameMap();
- BLSURFPlugin_Hypothesis::TEnfVertexGroupNameMap::const_iterator groupNameMapIt = groupNameMap.find(enfVertex);
- if (groupNameMapIt != groupNameMap.end()) {
- MESSAGE("Found enforced vertex @ " << xyz[0] << ", " << xyz[1] << ", " << xyz[2])
- BLSURFPlugin_Hypothesis::TEnfGroupName groupName = groupNameMapIt->second;
- if (groupName != "") {
+ std::map< BLSURFPlugin_Hypothesis::TEnfVertexCoords, BLSURFPlugin_Hypothesis::TEnfVertexList >::const_iterator enfCoordsIt = EnfVertexCoords2EnfVertexList.find(projVertex);
+ if (enfCoordsIt != EnfVertexCoords2EnfVertexList.end()) {
+ MESSAGE("Found enforced vertex @ " << xyz[0] << ", " << xyz[1] << ", " << xyz[2])
+ BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator enfListIt = enfCoordsIt->second.begin();
+ BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
+ for (; enfListIt != enfCoordsIt->second.end(); ++enfListIt) {
+ currentEnfVertex = (*enfListIt);
+ if (currentEnfVertex->grpName != "") {
bool groupDone = false;
- const set<SMESHDS_GroupBase*>& allGroups = meshDS->GetGroups();
- set<SMESHDS_GroupBase*>::const_iterator grIt;
+ SMESH_Mesh::GroupIteratorPtr grIt = aMesh.GetGroups();
+ MESSAGE("currentEnfVertex->grpName: " << currentEnfVertex->grpName);
MESSAGE("Parsing the groups of the mesh");
- for ( grIt = allGroups.begin(); grIt != allGroups.end(); ++grIt ) {
- SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>( *grIt );
- MESSAGE("Group: " << group->GetStoreName());
- if ( group && group->SMDSGroup().GetType()==SMDSAbs_Node
- && groupName.compare(group->GetStoreName())==0) {
- group->SMDSGroup().Add(nodes[iv]);
-// int id = // recuperer l'id SMESH du noeud
-// _hypothesis->AddEnfVertexIDs(groupName,id)
+ while (grIt->more()) {
+ SMESH_Group * group = grIt->next();
+ if ( !group ) continue;
+ MESSAGE("Group: " << group->GetName());
+ SMESHDS_GroupBase* groupDS = group->GetGroupDS();
+ if ( !groupDS ) continue;
+ MESSAGE("group->SMDSGroup().GetType(): " << (groupDS->GetType()));
+ MESSAGE("group->SMDSGroup().GetType()==SMDSAbs_Node: " << (groupDS->GetType()==SMDSAbs_Node));
+ MESSAGE("currentEnfVertex->grpName.compare(group->GetStoreName())==0: " << (currentEnfVertex->grpName.compare(group->GetName())==0));
+ if ( groupDS->GetType()==SMDSAbs_Node && currentEnfVertex->grpName.compare(group->GetName())==0) {
+ SMESHDS_Group* aGroupDS = static_cast<SMESHDS_Group*>( groupDS );
+ aGroupDS->SMDSGroup().Add(nodes[iv]);
+ MESSAGE("Node ID: " << nodes[iv]->GetID());
+ // How can I inform the hypothesis ?
+// _hypothesis->AddEnfVertexNodeID(currentEnfVertex->grpName,nodes[iv]->GetID());
groupDone = true;
- MESSAGE("Successfully added enforced vertex to existing group " << groupName);
+ MESSAGE("Successfully added enforced vertex to existing group " << currentEnfVertex->grpName);
break;
}
}
if (!groupDone)
{
int groupId;
- SMESH_Group* aGroup = aMesh.AddGroup(SMDSAbs_Node, groupName.c_str(), groupId);
- if ( aGroup ) {
- SMESHDS_Group* aGroupDS = dynamic_cast<SMESHDS_Group*>( aGroup->GetGroupDS() );
- if ( aGroupDS ) {
- aGroupDS->SetStoreName( groupName.c_str() );
- aGroupDS->SMDSGroup().Add(nodes[iv]);
- MESSAGE("Successfully created enforced vertex group " << groupName);
- groupDone = true;
- }
- }
+ SMESH_Group* aGroup = aMesh.AddGroup(SMDSAbs_Node, currentEnfVertex->grpName.c_str(), groupId);
+ aGroup->SetName( currentEnfVertex->grpName.c_str() );
+ SMESHDS_Group* aGroupDS = static_cast<SMESHDS_Group*>( aGroup->GetGroupDS() );
+ aGroupDS->SMDSGroup().Add(nodes[iv]);
+ MESSAGE("Successfully created enforced vertex group " << currentEnfVertex->grpName);
+ groupDone = true;
}
if (!groupDone)
throw SALOME_Exception(LOCALIZED("A enforced vertex node was not added to a group"));
}
else
- MESSAGE("Group name is empty: '"<<groupName<<"' => group is not created");
+ MESSAGE("Group name is empty: '"<<currentEnfVertex->grpName<<"' => group is not created");
}
- else
- MESSAGE("No group name for projected vertex ("<<x<<","<<y<<","<<z<<")")
}
-// else
-// MESSAGE("No group name for vertex ("<<xyz[0]<<","<<xyz[1]<<","<<xyz[2]<<")")
}
- */
+
// internal point are tagged to zero
if(tag > 0 && tag <= pmap.Extent() ){
#include <BRepTools.hxx>
#include <BRepAdaptor_HSurface.hxx>
-class BLSURFPlugin_Hypothesis;
+#include "BLSURFPlugin_Hypothesis.hxx"
+
class TopoDS_Shape;
class BLSURFPlugin_BLSURF: public SMESH_2D_Algo {
public:
BLSURFPlugin_BLSURF(int hypId, int studyId, SMESH_Gen* gen);
- TopoDS_Shape entryToShape(std::string entry);
-
virtual ~BLSURFPlugin_BLSURF();
virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
const BLSURFPlugin_Hypothesis* _hypothesis;
private:
+ TopoDS_Shape entryToShape(std::string entry);
+ void createEnforcedVertexOnFace(TopoDS_Shape FaceShape, BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList);
void Set_NodeOnEdge(SMESHDS_Mesh* meshDS, SMDS_MeshNode* node, const TopoDS_Shape& ed);
void BRepClass_FaceClassifierPerform(BRepClass_FaceClassifier* fc, const TopoDS_Face& face, const gp_Pnt& P, const Standard_Real Tol);
// File : BLSURFPlugin_Hypothesis.cxx
// Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA)
// & Aurelien ALLEAUME (DISTENE)
-// Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
+// Size maps development: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE)
// ---
//
#include "BLSURFPlugin_Hypothesis.hxx"
#include <sstream>
//=============================================================================
-BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis (int hypId, int studyId,
- SMESH_Gen * gen)
- : SMESH_Hypothesis(hypId, studyId, gen),
- _topology(GetDefaultTopology()),
- _physicalMesh(GetDefaultPhysicalMesh()),
- _phySize(GetDefaultPhySize()),
- _phyMax(GetDefaultMaxSize()),
- _phyMin(GetDefaultMinSize()),
- _hgeoMax(GetDefaultMaxSize()),
- _hgeoMin(GetDefaultMinSize()),
- _geometricMesh(GetDefaultGeometricMesh()),
- _angleMeshS(GetDefaultAngleMeshS()),
- _angleMeshC(GetDefaultAngleMeshC()),
- _gradation(GetDefaultGradation()),
- _quadAllowed(GetDefaultQuadAllowed()),
- _decimesh(GetDefaultDecimesh()),
- _verb( GetDefaultVerbosity() ),
- _sizeMap(GetDefaultSizeMap()),
- _attractors(GetDefaultSizeMap()),
- _enfVertexList(GetDefaultEnfVertexList()),
- _entryEnfVertexListMap(GetDefaultEntryEnfVertexListMap())
- /* TODO GROUPS
- _groupNameEnfVertexListMap(GetDefaultGroupNameEnfVertexListMap()),
- _enfVertexGroupNameMap(GetDefaultEnfVertexGroupNameMap())
- */
+BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen) :
+ SMESH_Hypothesis(hypId, studyId, gen), _topology(GetDefaultTopology()),
+ _physicalMesh(GetDefaultPhysicalMesh()),
+ _phySize(GetDefaultPhySize()),
+ _phyMax(GetDefaultMaxSize()),
+ _phyMin(GetDefaultMinSize()),
+ _hgeoMax(GetDefaultMaxSize()),
+ _hgeoMin(GetDefaultMinSize()),
+ _geometricMesh(GetDefaultGeometricMesh()),
+ _angleMeshS(GetDefaultAngleMeshS()),
+ _angleMeshC(GetDefaultAngleMeshC()),
+ _gradation(GetDefaultGradation()),
+ _quadAllowed(GetDefaultQuadAllowed()),
+ _decimesh(GetDefaultDecimesh()),
+ _verb(GetDefaultVerbosity()),
+ _sizeMap(GetDefaultSizeMap()),
+ _attractors(GetDefaultSizeMap()),
+ _faceEntryEnfVertexListMap(GetDefaultFaceEntryEnfVertexListMap()),
+ _enfVertexList(GetDefaultEnfVertexList()),
+ _faceEntryCoordsListMap(GetDefaultFaceEntryCoordsListMap()),
+ _coordsEnfVertexMap(GetDefaultCoordsEnfVertexMap()),
+ _faceEntryEnfVertexEntryListMap(GetDefaultFaceEntryEnfVertexEntryListMap()),
+ _enfVertexEntryEnfVertexMap(GetDefaultEnfVertexEntryEnfVertexMap()),
+ _groupNameNodeIDMap(GetDefaultGroupNameNodeIDMap())
+
+/* TODO GROUPS
+ _groupNameEnfVertexListMap(GetDefaultGroupNameEnfVertexListMap()),
+ _enfVertexGroupNameMap(GetDefaultEnfVertexGroupNameMap())
+ */
{
_name = "BLSURF_Parameters";
_param_algo_dim = 2;
- // to desable writing boundaries
+ // to disable writing boundaries
//_phyMin = _phyMax = _hgeoMin = _hgeoMax = undefinedDouble();
- const char* intOptionNames[] = {
- "addsurf_ivertex",
- "background",
- "CheckAdjacentEdges",
- "CheckCloseEdges",
- "CheckWellDefined",
- "coiter",
- "communication",
- "decim",
- "export_flag",
- "file_h",
- "frontal",
- "gridnu",
- "gridnv",
- "hinterpol_flag",
- "hmean_flag",
- "intermedfile",
- "memory",
- "normals",
- "optim",
- "pardom_flag",
- "pinch",
- "refs",
- "rigid",
- "surforient",
- "tconf",
- "topo_collapse",
- "" // mark of end
- };
- const char* doubleOptionNames[] = {
- "addsurf_angle",
- "addsurf_R",
- "addsurf_H",
- "addsurf_FG",
- "addsurf_r",
- "addsurf_PA",
- "angle_compcurv",
- "angle_ridge",
- "CoefRectangle",
- "eps_collapse",
- "eps_ends",
- "eps_pardom",
- "LSS",
- "topo_eps1",
- "topo_eps2",
- "" // mark of end
- };
- const char* charOptionNames[] = {
- "export_format",
- "export_option",
- "import_option",
- "prefix",
- "" // mark of end
- };
+ const char* intOptionNames[] = { "addsurf_ivertex", "background", "CheckAdjacentEdges", "CheckCloseEdges",
+ "CheckWellDefined", "coiter", "communication", "decim", "export_flag", "file_h", "frontal", "gridnu", "gridnv",
+ "hinterpol_flag", "hmean_flag", "intermedfile", "memory", "normals", "optim", "pardom_flag", "pinch", "refs",
+ "rigid", "surforient", "tconf", "topo_collapse", "" // mark of end
+ };
+ const char* doubleOptionNames[] = { "addsurf_angle", "addsurf_R", "addsurf_H", "addsurf_FG", "addsurf_r",
+ "addsurf_PA", "angle_compcurv", "angle_ridge", "CoefRectangle", "eps_collapse", "eps_ends", "eps_pardom", "LSS",
+ "topo_eps1", "topo_eps2", "" // mark of end
+ };
+ const char* charOptionNames[] = { "export_format", "export_option", "import_option", "prefix", "" // mark of end
+ };
int i = 0;
- while ( intOptionNames[i][0] )
- _option2value[ intOptionNames[i++] ].clear();
+ while (intOptionNames[i][0])
+ _option2value[intOptionNames[i++]].clear();
i = 0;
- while ( doubleOptionNames[i][0] ) {
- _doubleOptions.insert( doubleOptionNames[i] );
- _option2value[ doubleOptionNames[i++] ].clear();
+ while (doubleOptionNames[i][0]) {
+ _doubleOptions.insert(doubleOptionNames[i]);
+ _option2value[doubleOptionNames[i++]].clear();
}
i = 0;
- while ( charOptionNames[i][0] ) {
- _charOptions.insert( charOptionNames[i] );
- _option2value[ charOptionNames[i++] ].clear();
+ while (charOptionNames[i][0]) {
+ _charOptions.insert(charOptionNames[i]);
+ _option2value[charOptionNames[i++]].clear();
}
_sizeMap.clear();
_attractors.clear();
+ _faceEntryEnfVertexListMap.clear();
_enfVertexList.clear();
- _entryEnfVertexListMap.clear();
+ _faceEntryCoordsListMap.clear();
+ _coordsEnfVertexMap.clear();
+ _faceEntryEnfVertexEntryListMap.clear();
+ _enfVertexEntryEnfVertexMap.clear();
+ _groupNameNodeIDMap.clear();
+
/* TODO GROUPS
- _groupNameEnfVertexListMap.clear();
- _enfVertexGroupNameMap.clear();
- */
+ _groupNameEnfVertexListMap.clear();
+ _enfVertexGroupNameMap.clear();
+ */
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetTopology(Topology theTopology)
-{
+void BLSURFPlugin_Hypothesis::SetTopology(Topology theTopology) {
if (theTopology != _topology) {
_topology = theTopology;
NotifySubMeshesHypothesisModification();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetPhysicalMesh(PhysicalMesh thePhysicalMesh)
-{
+void BLSURFPlugin_Hypothesis::SetPhysicalMesh(PhysicalMesh thePhysicalMesh) {
if (thePhysicalMesh != _physicalMesh) {
_physicalMesh = thePhysicalMesh;
- switch( _physicalMesh ) {
+ switch (_physicalMesh) {
case DefaultSize:
default:
_phySize = GetDefaultPhySize();
- _gradation = GetDefaultGradation();
+ _gradation = GetDefaultGradation();
break;
- }
+ }
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetPhySize(double theVal)
-{
+void BLSURFPlugin_Hypothesis::SetPhySize(double theVal) {
if (theVal != _phySize) {
_phySize = theVal;
NotifySubMeshesHypothesisModification();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetPhyMin(double theMinSize)
-{
+void BLSURFPlugin_Hypothesis::SetPhyMin(double theMinSize) {
if (theMinSize != _phyMin) {
_phyMin = theMinSize;
NotifySubMeshesHypothesisModification();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetPhyMax(double theMaxSize)
-{
+void BLSURFPlugin_Hypothesis::SetPhyMax(double theMaxSize) {
if (theMaxSize != _phyMax) {
_phyMax = theMaxSize;
NotifySubMeshesHypothesisModification();
}
}
-
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetGeoMin(double theMinSize)
-{
+void BLSURFPlugin_Hypothesis::SetGeoMin(double theMinSize) {
if (theMinSize != _hgeoMin) {
_hgeoMin = theMinSize;
NotifySubMeshesHypothesisModification();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetGeoMax(double theMaxSize)
-{
+void BLSURFPlugin_Hypothesis::SetGeoMax(double theMaxSize) {
if (theMaxSize != _hgeoMax) {
_hgeoMax = theMaxSize;
NotifySubMeshesHypothesisModification();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetGeometricMesh(GeometricMesh theGeometricMesh)
-{
+void BLSURFPlugin_Hypothesis::SetGeometricMesh(GeometricMesh theGeometricMesh) {
if (theGeometricMesh != _geometricMesh) {
_geometricMesh = theGeometricMesh;
- switch( _geometricMesh ) {
+ switch (_geometricMesh) {
case DefaultGeom:
default:
_angleMeshS = GetDefaultAngleMeshS();
- _gradation = GetDefaultGradation();
+ _gradation = GetDefaultGradation();
break;
- }
+ }
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetAngleMeshS(double theVal)
-{
+void BLSURFPlugin_Hypothesis::SetAngleMeshS(double theVal) {
if (theVal != _angleMeshS) {
_angleMeshS = theVal;
NotifySubMeshesHypothesisModification();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetAngleMeshC(double theVal)
-{
+void BLSURFPlugin_Hypothesis::SetAngleMeshC(double theVal) {
if (theVal != _angleMeshC) {
_angleMeshC = theVal;
NotifySubMeshesHypothesisModification();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetGradation(double theVal)
-{
+void BLSURFPlugin_Hypothesis::SetGradation(double theVal) {
if (theVal != _gradation) {
_gradation = theVal;
NotifySubMeshesHypothesisModification();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetQuadAllowed(bool theVal)
-{
+void BLSURFPlugin_Hypothesis::SetQuadAllowed(bool theVal) {
if (theVal != _quadAllowed) {
_quadAllowed = theVal;
NotifySubMeshesHypothesisModification();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetDecimesh(bool theVal)
-{
+void BLSURFPlugin_Hypothesis::SetDecimesh(bool theVal) {
if (theVal != _decimesh) {
_decimesh = theVal;
NotifySubMeshesHypothesisModification();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetVerbosity(int theVal)
-{
+void BLSURFPlugin_Hypothesis::SetVerbosity(int theVal) {
if (theVal != _verb) {
_verb = theVal;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::SetOptionValue(const std::string& optionName,
- const std::string& optionValue)
- throw (std::invalid_argument)
-{
- TOptionValues::iterator op_val = _option2value.find( optionName );
- if ( op_val == _option2value.end() ) {
+void BLSURFPlugin_Hypothesis::SetOptionValue(const std::string& optionName, const std::string& optionValue)
+ throw (std::invalid_argument) {
+ TOptionValues::iterator op_val = _option2value.find(optionName);
+ if (op_val == _option2value.end()) {
std::string msg = "Unknown BLSURF option: '" + optionName + "'";
throw std::invalid_argument(msg);
}
- if ( op_val->second != optionValue ) {
+ if (op_val->second != optionValue) {
const char* ptr = optionValue.c_str();
// strip white spaces
- while ( ptr[0] == ' ' )
+ while (ptr[0] == ' ')
ptr++;
- int i = strlen( ptr );
- while ( i != 0 && ptr[i-1] == ' ')
+ int i = strlen(ptr);
+ while (i != 0 && ptr[i - 1] == ' ')
i--;
// check value type
bool typeOk = true;
std::string typeName;
- if ( i == 0 ) {
+ if (i == 0) {
// empty string
- }
- else if ( _charOptions.find( optionName ) != _charOptions.end() ) {
+ } else if (_charOptions.find(optionName) != _charOptions.end()) {
// do not check strings
- }
- else if ( _doubleOptions.find( optionName ) != _doubleOptions.end() ) {
+ } else if (_doubleOptions.find(optionName) != _doubleOptions.end()) {
// check if value is double
char * endPtr;
strtod(ptr, &endPtr);
- typeOk = ( ptr != endPtr );
+ typeOk = (ptr != endPtr);
typeName = "real";
- }
- else {
+ } else {
// check if value is int
char * endPtr;
- strtol(ptr, &endPtr,10);
- typeOk = ( ptr != endPtr );
+ strtol(ptr, &endPtr, 10);
+ typeOk = (ptr != endPtr);
typeName = "integer";
}
- if ( !typeOk ) {
- std::string msg = "Advanced option '" + optionName + "' = '" + optionValue +
- "' but must be " + typeName;
+ if (!typeOk) {
+ std::string msg = "Advanced option '" + optionName + "' = '" + optionValue + "' but must be " + typeName;
throw std::invalid_argument(msg);
}
op_val->second = optionValue;
}
//=============================================================================
-std::string BLSURFPlugin_Hypothesis::GetOptionValue(const std::string& optionName)
- throw (std::invalid_argument)
-{
- TOptionValues::iterator op_val = _option2value.find( optionName );
- if ( op_val == _option2value.end() ) {
+std::string BLSURFPlugin_Hypothesis::GetOptionValue(const std::string& optionName) throw (std::invalid_argument) {
+ TOptionValues::iterator op_val = _option2value.find(optionName);
+ if (op_val == _option2value.end()) {
std::string msg = "Unknown BLSURF option: <";
msg += optionName + ">";
throw std::invalid_argument(msg);
}
//=============================================================================
-void BLSURFPlugin_Hypothesis::ClearOption(const std::string& optionName)
-{
- TOptionValues::iterator op_val = _option2value.find( optionName );
- if ( op_val != _option2value.end() )
+void BLSURFPlugin_Hypothesis::ClearOption(const std::string& optionName) {
+ TOptionValues::iterator op_val = _option2value.find(optionName);
+ if (op_val != _option2value.end())
op_val->second.clear();
}
//=======================================================================
//function : SetSizeMapEntry
//=======================================================================
-void BLSURFPlugin_Hypothesis::SetSizeMapEntry(const std::string& entry,const std::string& sizeMap)
-{
+void BLSURFPlugin_Hypothesis::SetSizeMapEntry(const std::string& entry, const std::string& sizeMap) {
if (_sizeMap[entry].compare(sizeMap) != 0) {
- _sizeMap[entry]=sizeMap;
+ _sizeMap[entry] = sizeMap;
NotifySubMeshesHypothesisModification();
}
}
//=======================================================================
//function : GetSizeMapEntry
//=======================================================================
-std::string BLSURFPlugin_Hypothesis::GetSizeMapEntry(const std::string& entry)
-{
- TSizeMap::iterator it = _sizeMap.find( entry );
- if ( it != _sizeMap.end() )
- return it->second;
- else
- return "No_Such_Entry";
+std::string BLSURFPlugin_Hypothesis::GetSizeMapEntry(const std::string& entry) {
+ TSizeMap::iterator it = _sizeMap.find(entry);
+ if (it != _sizeMap.end())
+ return it->second;
+ else
+ return "No_Such_Entry";
}
- /*!
- * \brief Return the size maps
- */
-BLSURFPlugin_Hypothesis::TSizeMap BLSURFPlugin_Hypothesis::GetSizeMapEntries(const BLSURFPlugin_Hypothesis* hyp)
-{
- return hyp ? hyp->_GetSizeMapEntries():GetDefaultSizeMap();
+/*!
+ * \brief Return the size maps
+ */
+BLSURFPlugin_Hypothesis::TSizeMap BLSURFPlugin_Hypothesis::GetSizeMapEntries(const BLSURFPlugin_Hypothesis* hyp) {
+ return hyp ? hyp->_GetSizeMapEntries() : GetDefaultSizeMap();
}
//=======================================================================
//function : SetAttractorEntry
//=======================================================================
-void BLSURFPlugin_Hypothesis::SetAttractorEntry(const std::string& entry,const std::string& attractor)
-{
+void BLSURFPlugin_Hypothesis::SetAttractorEntry(const std::string& entry, const std::string& attractor) {
if (_attractors[entry].compare(attractor) != 0) {
- _attractors[entry]=attractor;
+ _attractors[entry] = attractor;
NotifySubMeshesHypothesisModification();
}
}
//=======================================================================
//function : GetAttractorEntry
//=======================================================================
-std::string BLSURFPlugin_Hypothesis::GetAttractorEntry(const std::string& entry)
-{
- TSizeMap::iterator it = _attractors.find( entry );
- if ( it != _attractors.end() )
- return it->second;
- else
- return "No_Such_Entry";
+std::string BLSURFPlugin_Hypothesis::GetAttractorEntry(const std::string& entry) {
+ TSizeMap::iterator it = _attractors.find(entry);
+ if (it != _attractors.end())
+ return it->second;
+ else
+ return "No_Such_Entry";
}
- /*!
- * \brief Return the attractors
- */
-BLSURFPlugin_Hypothesis::TSizeMap BLSURFPlugin_Hypothesis::GetAttractorEntries(const BLSURFPlugin_Hypothesis* hyp)
-{
- return hyp ? hyp->_GetAttractorEntries():GetDefaultSizeMap();
+/*!
+ * \brief Return the attractors
+ */
+BLSURFPlugin_Hypothesis::TSizeMap BLSURFPlugin_Hypothesis::GetAttractorEntries(const BLSURFPlugin_Hypothesis* hyp) {
+ return hyp ? hyp->_GetAttractorEntries() : GetDefaultSizeMap();
}
//=======================================================================
//function : ClearEntry
//=======================================================================
-void BLSURFPlugin_Hypothesis::ClearEntry(const std::string& entry)
-{
- TSizeMap::iterator it = _sizeMap.find( entry );
- if ( it != _sizeMap.end() ) {
- _sizeMap.erase(it);
- NotifySubMeshesHypothesisModification();
- }
- else {
- TSizeMap::iterator itAt = _attractors.find( entry );
- if ( itAt != _attractors.end() ) {
- _attractors.erase(itAt);
- NotifySubMeshesHypothesisModification();
- }
- else
- std::cout<<"No_Such_Entry"<<std::endl;
- }
+void BLSURFPlugin_Hypothesis::ClearEntry(const std::string& entry) {
+ TSizeMap::iterator it = _sizeMap.find(entry);
+ if (it != _sizeMap.end()) {
+ _sizeMap.erase(it);
+ NotifySubMeshesHypothesisModification();
+ } else {
+ TSizeMap::iterator itAt = _attractors.find(entry);
+ if (itAt != _attractors.end()) {
+ _attractors.erase(itAt);
+ NotifySubMeshesHypothesisModification();
+ } else
+ std::cout << "No_Such_Entry" << std::endl;
+ }
}
//=======================================================================
//function : ClearSizeMaps
//=======================================================================
-void BLSURFPlugin_Hypothesis::ClearSizeMaps()
-{
+void BLSURFPlugin_Hypothesis::ClearSizeMaps() {
_sizeMap.clear();
_attractors.clear();
}
-
-
//=======================================================================
//function : SetEnforcedVertex
//=======================================================================
-/* TODO GROUPS
-void BLSURFPlugin_Hypothesis::SetEnforcedVertex(const TEnfEntry& entry,
- double x, double y, double z,
- const TEnfGroupName& groupName)
-*/
-void BLSURFPlugin_Hypothesis::SetEnforcedVertex(const TEnfEntry& entry,
- double x, double y, double z)
-{
- /* TODO GROUPS
- MESSAGE("BLSURFPlugin_Hypothesis::SetEnforcedVertex START - entry: " << entry << " vertex: " << x << " " << y << " " << z << " group name: " << groupName);
- */
- MESSAGE("BLSURFPlugin_Hypothesis::SetEnforcedVertex START - entry: " << entry << " vertex: " << x << " " << y << " " << z);
- TEnfVertex enfVertex;
- enfVertex.push_back(x);
- enfVertex.push_back(y);
- enfVertex.push_back(z);
+bool BLSURFPlugin_Hypothesis::SetEnforcedVertex(TEntry theFaceEntry, TEnfName theVertexName, TEntry theVertexEntry,
+ TEnfGroupName theGroupName, double x, double y, double z) {
+
+ MESSAGE("BLSURFPlugin_Hypothesis::SetEnforcedVertex("<< theFaceEntry << ", "
+ << x << ", " << y << ", " << z << ", " << theVertexName << ", " << theVertexEntry << ", " << theGroupName << ")");
+ // TEnfVertexList::iterator it;
bool toNotify = false;
- if (_entryEnfVertexListMap.count(entry)>0)
- if (_entryEnfVertexListMap[entry].count(enfVertex)==0)
+ bool toCreate = true;
+
+ TEnfVertex *oldEnVertex;
+ TEnfVertex *newEnfVertex = new TEnfVertex();
+ newEnfVertex->name = theVertexName;
+ newEnfVertex->geomEntry = theVertexEntry;
+ newEnfVertex->coords.clear();
+ if (theVertexEntry == "") {
+ newEnfVertex->coords.push_back(x);
+ newEnfVertex->coords.push_back(y);
+ newEnfVertex->coords.push_back(z);
+ }
+ newEnfVertex->grpName = theGroupName;
+ newEnfVertex->faceEntries.clear();
+ newEnfVertex->faceEntries.insert(theFaceEntry);
+
+
+ // update _enfVertexList
+ TEnfVertexList::iterator it = _enfVertexList.find(newEnfVertex);
+ if (it != _enfVertexList.end()) {
+ toCreate = false;
+ oldEnVertex = (*it);
+ MESSAGE("Enforced Vertex was found => Update");
+ if (oldEnVertex->name != theVertexName) {
+ MESSAGE("Update name from \"" << oldEnVertex->name << "\" to \"" << theVertexName << "\"");
+ oldEnVertex->name = theVertexName;
toNotify = true;
- else
- toNotify = true;
+ }
+ if (oldEnVertex->grpName != theGroupName) {
+ MESSAGE("Update group name from \"" << oldEnVertex->grpName << "\" to \"" << theGroupName << "\"");
+ oldEnVertex->grpName = theGroupName;
+ toNotify = true;
+ }
+ TEntryList::iterator it_faceEntries = oldEnVertex->faceEntries.find(theFaceEntry);
+ if (it_faceEntries == oldEnVertex->faceEntries.end()) {
+ MESSAGE("Update face list by adding \"" << theFaceEntry << "\"");
+ oldEnVertex->faceEntries.insert(theFaceEntry);
+ _faceEntryEnfVertexListMap[theFaceEntry].insert(oldEnVertex);
+ toNotify = true;
+ }
+ if (toNotify) {
+ // update map coords / enf vertex if needed
+ if (oldEnVertex->coords.size()) {
+ _coordsEnfVertexMap[oldEnVertex->coords] = oldEnVertex;
+ _faceEntryCoordsListMap[theFaceEntry].insert(oldEnVertex->coords);
+ }
- _enfVertexList.insert(enfVertex);
-// _entryEnfVertexListMap[entry].insert(enfVertex);
- TEnfVertexList& entryEnfVertexList = _entryEnfVertexListMap[entry];
- entryEnfVertexList.insert(enfVertex);
+ // update map geom entry / enf vertex if needed
+ if (oldEnVertex->geomEntry != "") {
+ _enfVertexEntryEnfVertexMap[oldEnVertex->geomEntry] = oldEnVertex;
+ _faceEntryEnfVertexEntryListMap[theFaceEntry].insert(oldEnVertex->geomEntry);
+ }
+ }
+ }
- /* TODO GROUPS
- bool toNotify2 = _setEnfVertexWithGroup(x,y,z,groupName);
+// //////// CREATE ////////////
+ if (toCreate) {
+ toNotify = true;
+ MESSAGE("Creating new enforced vertex");
+ _faceEntryEnfVertexListMap[theFaceEntry].insert(newEnfVertex);
+ _enfVertexList.insert(newEnfVertex);
+ if (theVertexEntry == "") {
+ _faceEntryCoordsListMap[theFaceEntry].insert(newEnfVertex->coords);
+ _coordsEnfVertexMap[newEnfVertex->coords] = newEnfVertex;
+ }
+ else {
+ _faceEntryEnfVertexEntryListMap[theFaceEntry].insert(newEnfVertex->geomEntry);
+ _enfVertexEntryEnfVertexMap[newEnfVertex->geomEntry] = newEnfVertex;
+ }
+ }
- if (toNotify || toNotify2)
- NotifySubMeshesHypothesisModification();
- */
if (toNotify)
NotifySubMeshesHypothesisModification();
-
+
MESSAGE("BLSURFPlugin_Hypothesis::SetEnforcedVertex END");
+ return toNotify;
}
-/* TODO GROUPS
-bool BLSURFPlugin_Hypothesis::_setEnfVertexWithGroup(double x, double y, double z, const std::string groupName) throw (std::invalid_argument)
-{
- bool isModified = false;
- std::vector<double> enfVertex;
- enfVertex.push_back(x);
- enfVertex.push_back(y);
- enfVertex.push_back(z);
- if (_enfVertexList.find(enfVertex) != _enfVertexList.end()) {
- TEnfGroupName oldGroupName = _enfVertexGroupNameMap[enfVertex];
- _enfVertexGroupNameMap[enfVertex] = groupName;
- if ((groupName != "") && (groupName != oldGroupName)) {
- MESSAGE("Group name is not empty");
- TEnfVertexList& enfVertexList = _groupNameEnfVertexListMap[groupName];
- enfVertexList.insert(enfVertex);
- isModified = true;
- }
- else {
- if (oldGroupName != "") {
- // groupName = "" => remove group name
- TGroupNameEnfVertexListMap::iterator it = _groupNameEnfVertexListMap.find(oldGroupName);
- if (it != _groupNameEnfVertexListMap.end()) {
- _groupNameEnfVertexListMap[oldGroupName].erase(enfVertex);
- if (_groupNameEnfVertexListMap[oldGroupName].size() == 0)
- _groupNameEnfVertexListMap.erase(oldGroupName);
- isModified = true;
- }
- }
- }
- return isModified;
- }
- std::ostringstream msg ;
- msg << "No enforced vertex at (" << x << "," << y << "," << z << ")" ;
+//=======================================================================
+//function : GetEnforcedVertices
+//=======================================================================
+
+BLSURFPlugin_Hypothesis::TEnfVertexList BLSURFPlugin_Hypothesis::GetEnfVertexList(const TEntry& theFaceEntry)
+ throw (std::invalid_argument) {
+
+ if (_faceEntryEnfVertexListMap.count(theFaceEntry) > 0)
+ return _faceEntryEnfVertexListMap[theFaceEntry];
+ else
+ return GetDefaultEnfVertexList();
+
+ std::ostringstream msg;
+ msg << "No enforced vertex for face entry " << theFaceEntry;
throw std::invalid_argument(msg.str());
}
//=======================================================================
-//function : SetEnforcedVertexGroupName
+//function : GetEnfVertexCoordsList
//=======================================================================
-void BLSURFPlugin_Hypothesis::SetEnforcedVertexGroupName(double x, double y, double z,
- const TEnfGroupName& groupName)
- throw (std::invalid_argument)
-{
- bool toNotify = _setEnfVertexWithGroup(x,y,z,groupName);
- if (toNotify)
- NotifySubMeshesHypothesisModification();
-// bool toNotify = false;
-// TEnfVertex enfVertex;
-// enfVertex.push_back(x);
-// enfVertex.push_back(y);
-// enfVertex.push_back(z);
-//
-// if (_enfVertexList.find(enfVertex) != _enfVertexList.end()) {
-// TEnfGroupName oldGroupName = _enfVertexGroupNameMap[enfVertex];
-// _enfVertexGroupNameMap[enfVertex] = groupName;
-// if ((groupName != "") && (groupName != oldGroupName)) {
-// MESSAGE("Group name is not empty");
-// TEnfVertexList& enfVertexList = _groupNameEnfVertexListMap[groupName];
-// enfVertexList.insert(enfVertex);
-// toNotify = true;
-// }
-// else {
-// if (oldGroupName != "") {
-// // groupName = "" => remove group name
-// TGroupNameEnfVertexListMap::iterator it = _groupNameEnfVertexListMap.find(oldGroupName);
-// if (it != _groupNameEnfVertexListMap.end()) {
-// _groupNameEnfVertexListMap[oldGroupName].erase(enfVertex);
-// if (_groupNameEnfVertexListMap[oldGroupName].size() == 0)
-// _groupNameEnfVertexListMap.erase(oldGroupName);
-// toNotify = true;
-// }
-// }
-// }
-// if (toNotify)
-// NotifySubMeshesHypothesisModification();
-// return;
-// }
-
-// // std::ostringstream msg ;
-// // msg << "No enforced vertex at (" << x << "," << y << "," << z << ")" ;
-// // throw std::invalid_argument(msg.str());
-}
+BLSURFPlugin_Hypothesis::TEnfVertexCoordsList BLSURFPlugin_Hypothesis::GetEnfVertexCoordsList(
+ const TEntry& theFaceEntry) throw (std::invalid_argument) {
+
+ if (_faceEntryCoordsListMap.count(theFaceEntry) > 0)
+ return _faceEntryCoordsListMap[theFaceEntry];
+
+ std::ostringstream msg;
+ msg << "No enforced vertex coords for face entry " << theFaceEntry;
+ throw std::invalid_argument(msg.str());
+}
//=======================================================================
-//function : GetEnforcedVertexGroupName
+//function : GetEnfVertexEntryList
//=======================================================================
-BLSURFPlugin_Hypothesis::TEnfGroupName BLSURFPlugin_Hypothesis::GetEnforcedVertexGroupName(double x, double y, double z)
- throw (std::invalid_argument)
-{
- TEnfVertex enfVertex;
- enfVertex.push_back(x);
- enfVertex.push_back(y);
- enfVertex.push_back(z);
- if (_enfVertexGroupNameMap.find(enfVertex) != _enfVertexGroupNameMap.end())
- return _enfVertexGroupNameMap[enfVertex];
+BLSURFPlugin_Hypothesis::TEntryList BLSURFPlugin_Hypothesis::GetEnfVertexEntryList(const TEntry& theFaceEntry)
+ throw (std::invalid_argument) {
+
+ if (_faceEntryEnfVertexEntryListMap.count(theFaceEntry) > 0)
+ return _faceEntryEnfVertexEntryListMap[theFaceEntry];
- std::ostringstream msg ;
- msg << "No enforced vertex at (" << x << "," << y << "," << z << ")" ;
+ std::ostringstream msg;
+ msg << "No enforced vertex entry for face entry " << theFaceEntry;
throw std::invalid_argument(msg.str());
}
-*/
-/*
//=======================================================================
-//function : SetEnforcedVertexList
+//function : GetEnfVertex(TEnfVertexCoords coords)
//=======================================================================
-void BLSURFPlugin_Hypothesis::SetEnforcedVertexList(const TEnfEntry& entry,
- const TEnfVertexList vertexList)
-{
- TEnfVertexList::const_iterator it;
- bool toNotify = false;
- for(it = vertexList.begin();it!=vertexList.end();++it) {
- if (_entryEnfVertexListMap.count(entry)>0)
- if (_entryEnfVertexListMap[entry].count(*it)==0)
- toNotify = true;
- else
- toNotify = true;
- _entryEnfVertexListMap[entry].insert(*it);
- _enfVertexList.insert(*it);
- }
- if (toNotify)
- NotifySubMeshesHypothesisModification();
+BLSURFPlugin_Hypothesis::TEnfVertex* BLSURFPlugin_Hypothesis::GetEnfVertex(TEnfVertexCoords coords)
+ throw (std::invalid_argument) {
+
+ if (_coordsEnfVertexMap.count(coords) > 0)
+ return _coordsEnfVertexMap[coords];
+
+ std::ostringstream msg;
+ msg << "No enforced vertex with coords (" << coords[0] << ", " << coords[1] << ", " << coords[2] << ")";
+ throw std::invalid_argument(msg.str());
}
-*/
//=======================================================================
-//function : GetEnforcedVertices
+//function : GetEnfVertex(const TEntry& theEnfVertexEntry)
//=======================================================================
-BLSURFPlugin_Hypothesis::TEnfVertexList BLSURFPlugin_Hypothesis::GetEnforcedVertices(const TEnfEntry& entry)
- throw (std::invalid_argument)
-{
- if (_entryEnfVertexListMap.count(entry)>0)
- return _entryEnfVertexListMap[entry];
- std::ostringstream msg ;
- msg << "No enforced vertex for entry " << entry ;
+BLSURFPlugin_Hypothesis::TEnfVertex* BLSURFPlugin_Hypothesis::GetEnfVertex(const TEntry& theEnfVertexEntry)
+ throw (std::invalid_argument) {
+
+ if (_enfVertexEntryEnfVertexMap.count(theEnfVertexEntry) > 0)
+ return _enfVertexEntryEnfVertexMap[theEnfVertexEntry];
+
+ std::ostringstream msg;
+ msg << "No enforced vertex with entry " << theEnfVertexEntry;
throw std::invalid_argument(msg.str());
}
//function : ClearEnforcedVertex
//=======================================================================
-void BLSURFPlugin_Hypothesis::ClearEnforcedVertex(const TEnfEntry& entry, double x, double y, double z)
- throw (std::invalid_argument)
-{
- std::ostringstream msg ;
-
- TEnfVertex enfVertex;
- enfVertex.push_back(x);
- enfVertex.push_back(y);
- enfVertex.push_back(z);
-
- // check that enf vertex with given coords exists
- if (_enfVertexList.count(enfVertex) == 0) {
- msg << "No enforced vertex for " << entry;
- throw std::invalid_argument(msg.str());
+bool BLSURFPlugin_Hypothesis::ClearEnforcedVertex(const TEntry& theFaceEntry, double x, double y, double z,
+ const TEntry& theVertexEntry) throw (std::invalid_argument) {
+
+ bool toNotify = false;
+ std::ostringstream msg;
+ TEnfVertex *oldEnfVertex;
+ TEnfVertexCoords coords;
+ coords.clear();
+ coords.push_back(x);
+ coords.push_back(y);
+ coords.push_back(z);
+
+ // check that enf vertex with given enf vertex entry exists
+ TEnfVertexEntryEnfVertexMap::iterator it_enfVertexEntry = _enfVertexEntryEnfVertexMap.find(theVertexEntry);
+ if (it_enfVertexEntry != _enfVertexEntryEnfVertexMap.end()) {
+ // Success
+ MESSAGE("Found enforced vertex with geom entry " << theVertexEntry);
+ oldEnfVertex = it_enfVertexEntry->second;
+
+ _enfVertexEntryEnfVertexMap.erase(it_enfVertexEntry);
+
+ TEntryList& enfVertexEntryList = _faceEntryEnfVertexEntryListMap[theFaceEntry];
+ enfVertexEntryList.erase(theVertexEntry);
+ if (enfVertexEntryList.size() == 0)
+ _faceEntryEnfVertexEntryListMap.erase(theFaceEntry);
+ // TFaceEntryEnfVertexEntryListMap::iterator it_entry_entry = _faceEntryEnfVertexEntryListMap.find(theFaceEntry);
+ // TEntryList::iterator it_entryList = it_entry_entry->second.find(theVertexEntry);
+ // it_entry_entry->second.erase(it_entryList);
+ // if (it_entry_entry->second.size() == 0)
+ // _faceEntryEnfVertexEntryListMap.erase(it_entry_entry);
+ } else {
+ // Fail
+ MESSAGE("Enforced vertex with geom entry " << theVertexEntry << " not found");
+ msg << "No enforced vertex with geom entry " << theVertexEntry;
+ // check that enf vertex with given coords exists
+ TCoordsEnfVertexMap::iterator it_coords_enf = _coordsEnfVertexMap.find(coords);
+ if (it_coords_enf != _coordsEnfVertexMap.end()) {
+ // Success
+ MESSAGE("Found enforced vertex with coords " << x << ", " << y << ", " << z);
+ oldEnfVertex = it_coords_enf->second;
+
+ _coordsEnfVertexMap.erase(it_coords_enf);
+
+ TEnfVertexCoordsList& enfVertexCoordsList = _faceEntryCoordsListMap[theFaceEntry];
+ enfVertexCoordsList.erase(coords);
+ if (enfVertexCoordsList.size() == 0)
+ _faceEntryCoordsListMap.erase(theFaceEntry);
+ // TFaceEntryCoordsListMap::iterator it_entry_coords = _faceEntryCoordsListMap.find(theFaceEntry);
+ // TEnfVertexCoordsList::iterator it_coordsList = it_entry_coords->second.find(coords);
+ // it_entry_coords->second.erase(it_coordsList);
+ // if (it_entry_coords->second.size() == 0)
+ // _faceEntryCoordsListMap.erase(it_entry_coords);
+ } else {
+ // Fail
+ MESSAGE("Enforced vertex with coords " << x << ", " << y << ", " << z << " not found");
+ msg << std::endl;
+ msg << "No enforced vertex at " << x << ", " << y << ", " << z;
+ throw std::invalid_argument(msg.str());
+ }
}
+ MESSAGE("Remove enf vertex from _enfVertexList");
- TEntryEnfVertexListMap::iterator it_enf = _entryEnfVertexListMap.find(entry);
- if (it_enf != _entryEnfVertexListMap.end()) {
- bool toNotify = false;
- TEnfVertexList::iterator it = _entryEnfVertexListMap[entry].find(enfVertex);
- if (it != _entryEnfVertexListMap[entry].end()) {
+ // update _enfVertexList
+ TEnfVertexList::iterator it = _enfVertexList.find(oldEnfVertex);
+ if (it != _enfVertexList.end()) {
+ (*it)->faceEntries.erase(theFaceEntry);
+ if ((*it)->faceEntries.size() == 0){
+ _enfVertexList.erase(it);
toNotify = true;
+ }
+ MESSAGE("Done");
+ }
- // Update entry2enfList map
- _entryEnfVertexListMap[entry].erase(it);
- if (_entryEnfVertexListMap[entry].size() == 0)
- _entryEnfVertexListMap.erase(it_enf);
-
- /* TODO GROUPS
- // Update groupName2enfCoord map
- TEnfGroupName groupName = _enfVertexGroupNameMap[enfVertex];
- if (groupName != "") {
- TGroupNameEnfVertexListMap::iterator it_grp =_groupNameEnfVertexListMap.find(groupName);
- if (it_grp != _groupNameEnfVertexListMap.end()) {
- _groupNameEnfVertexListMap[groupName].erase(enfVertex);
- if (_groupNameEnfVertexListMap[groupName].size() == 0)
- _groupNameEnfVertexListMap.erase(it_grp);
- }
- }
-
- // Update _enfVertexGroupNameMap
- _enfVertexGroupNameMap.erase(enfVertex);
- */
-
- // Update _enfVertexList
- _enfVertexList.erase(enfVertex);
+ // update _faceEntryEnfVertexListMap
+ TEnfVertexList& currentEnfVertexList = _faceEntryEnfVertexListMap[theFaceEntry];
+ currentEnfVertexList.erase(oldEnfVertex);
- }
- if (toNotify)
- NotifySubMeshesHypothesisModification();
- return;
+ if (currentEnfVertexList.size() == 0) {
+ MESSAGE("Remove _faceEntryEnfVertexListMap[" << theFaceEntry <<"]");
+ _faceEntryEnfVertexListMap.erase(theFaceEntry);
+ MESSAGE("Done");
}
- msg << "No enforced vertex for " << entry;
- throw std::invalid_argument(msg.str());
+ if (toNotify)
+ NotifySubMeshesHypothesisModification();
+
+ return toNotify;
}
-/*
+
//=======================================================================
-//function : ClearEnforcedVertexList
+//function : ClearEnforcedVertices
//=======================================================================
-void BLSURFPlugin_Hypothesis::ClearEnforcedVertexList(const std::string& entry, TEnfVertexList vertexList)
- throw (std::invalid_argument)
-{
- TEnfVertex coord;
- TEnfVertexList::const_iterator it_toRemove;
- TEnfVertexList::iterator it;
+bool BLSURFPlugin_Hypothesis::ClearEnforcedVertices(const TEntry& theFaceEntry) throw (std::invalid_argument) {
+
bool toNotify = false;
+ TEnfVertex *oldEnfVertex;
- TEntryEnfVertexListMap::iterator it_enf = _entryEnfVertexListMap.find(entry);
- if (it_enf != _entryEnfVertexListMap.end()) {
- for (it_toRemove = vertexList.begin() ; it_toRemove != vertexList.end() ; ++it_toRemove) {
- coord = *it_toRemove;
- it = _entryEnfVertexListMap[entry].find(coord);
- if (it != _entryEnfVertexListMap[entry].end()) {
- toNotify = true;
- _entryEnfVertexListMap[entry].erase(it);
- _enfVertexList.erase(it);
+ TFaceEntryCoordsListMap::iterator it_entry_coords = _faceEntryCoordsListMap.find(theFaceEntry);
+ if (it_entry_coords != _faceEntryCoordsListMap.end()) {
+ toNotify = true;
+ TEnfVertexCoordsList coordsList = it_entry_coords->second;
+ TEnfVertexCoordsList::iterator it_coordsList = coordsList.begin();
+ for (; it_coordsList != coordsList.end(); ++it_coordsList) {
+ TEnfVertexCoords coords = (*it_coordsList);
+ oldEnfVertex = _coordsEnfVertexMap[coords];
+ _coordsEnfVertexMap.erase(coords);
+ // update _enfVertexList
+ TEnfVertexList::iterator it = _enfVertexList.find(oldEnfVertex);
+ if (it != _enfVertexList.end()) {
+ (*it)->faceEntries.erase(theFaceEntry);
+ if ((*it)->faceEntries.size() == 0){
+ _enfVertexList.erase(it);
+ toNotify = true;
+ }
+ MESSAGE("Done");
}
}
- if (_entryEnfVertexListMap[entry].size() == 0) {
- toNotify = true;
- _entryEnfVertexListMap.erase(it_enf);
- }
- if (toNotify)
- NotifySubMeshesHypothesisModification();
- return;
+ _faceEntryCoordsListMap.erase(it_entry_coords);
+ _faceEntryEnfVertexListMap.erase(theFaceEntry);
}
- std::ostringstream msg ;
- msg << "No enforced vertex for " << entry;
- throw std::invalid_argument(msg.str());
-}
-*/
-//=======================================================================
-//function : ClearEnforcedVertices
-//=======================================================================
-
-void BLSURFPlugin_Hypothesis::ClearEnforcedVertices(const TEnfEntry& entry)
- throw (std::invalid_argument)
-{
- TEntryEnfVertexListMap::iterator it_enf = _entryEnfVertexListMap.find(entry);
- if (it_enf != _entryEnfVertexListMap.end()) {
- TEnfVertexList enfList = it_enf->second;
- TEnfVertexList::iterator it;
- for(it = enfList.begin();it!=enfList.end();++it) {
- /* TODO GROUPS
- TEnfGroupName groupName = _enfVertexGroupNameMap[*it];
- if (groupName != "") {
- TGroupNameEnfVertexListMap::iterator it_grp =_groupNameEnfVertexListMap.find(groupName);
- if (it_grp != _groupNameEnfVertexListMap.end()) {
- _groupNameEnfVertexListMap[groupName].erase(it);
- if (_groupNameEnfVertexListMap[groupName].size() == 0)
- _groupNameEnfVertexListMap.erase(it_grp);
+ TFaceEntryEnfVertexEntryListMap::iterator it_entry_entry = _faceEntryEnfVertexEntryListMap.find(theFaceEntry);
+ if (it_entry_entry != _faceEntryEnfVertexEntryListMap.end()) {
+ toNotify = true;
+ TEntryList enfVertexEntryList = it_entry_entry->second;
+ TEntryList::iterator it_enfVertexEntryList = enfVertexEntryList.begin();
+ for (; it_enfVertexEntryList != enfVertexEntryList.end(); ++it_enfVertexEntryList) {
+ TEntry enfVertexEntry = (*it_enfVertexEntryList);
+ oldEnfVertex = _enfVertexEntryEnfVertexMap[enfVertexEntry];
+ _enfVertexEntryEnfVertexMap.erase(enfVertexEntry);
+ // update _enfVertexList
+ TEnfVertexList::iterator it = _enfVertexList.find(oldEnfVertex);
+ if (it != _enfVertexList.end()) {
+ (*it)->faceEntries.erase(theFaceEntry);
+ if ((*it)->faceEntries.size() == 0){
+ _enfVertexList.erase(it);
+ toNotify = true;
}
+ MESSAGE("Done");
}
- _enfVertexGroupNameMap.erase(*it);
- */
- _enfVertexList.erase(it);
}
- _entryEnfVertexListMap.erase(it_enf);
- NotifySubMeshesHypothesisModification();
- return;
+ _faceEntryEnfVertexEntryListMap.erase(it_entry_entry);
+ _faceEntryEnfVertexListMap.erase(theFaceEntry);
}
- std::ostringstream msg ;
- msg << "No enforced vertex for " << entry;
- throw std::invalid_argument(msg.str());
+ if (toNotify)
+ NotifySubMeshesHypothesisModification();
+
+ return toNotify;
+ // std::ostringstream msg;
+ // msg << "No enforced vertex for " << theFaceEntry;
+ // throw std::invalid_argument(msg.str());
}
//=======================================================================
//function : ClearAllEnforcedVertices
//=======================================================================
-void BLSURFPlugin_Hypothesis::ClearAllEnforcedVertices()
-{
- _enfVertexList.clear();
- _entryEnfVertexListMap.clear();
- /* TODO GROUPS
- _groupNameEnfVertexListMap.clear();
- _enfVertexGroupNameMap.clear();
- */
- NotifySubMeshesHypothesisModification();
+void BLSURFPlugin_Hypothesis::ClearAllEnforcedVertices() {
+ _faceEntryEnfVertexListMap.clear();
+ _enfVertexList.clear();
+ _faceEntryCoordsListMap.clear();
+ _coordsEnfVertexMap.clear();
+ _faceEntryEnfVertexEntryListMap.clear();
+ _enfVertexEntryEnfVertexMap.clear();
+ NotifySubMeshesHypothesisModification();
}
//================================================================================
/*!
-* \brief Return the enforced vertices
-*/
+ * \brief Return the enforced vertices
+ */
//================================================================================
-BLSURFPlugin_Hypothesis::TEntryEnfVertexListMap BLSURFPlugin_Hypothesis::GetAllEnforcedVertices(const BLSURFPlugin_Hypothesis* hyp)
+
+BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap BLSURFPlugin_Hypothesis::GetAllEnforcedVerticesByFace(
+ const BLSURFPlugin_Hypothesis* hyp) {
+ return hyp ? hyp->_GetAllEnforcedVerticesByFace() : GetDefaultFaceEntryEnfVertexListMap();
+}
+
+BLSURFPlugin_Hypothesis::TEnfVertexList BLSURFPlugin_Hypothesis::GetAllEnforcedVertices(
+ const BLSURFPlugin_Hypothesis* hyp) {
+ return hyp ? hyp->_GetAllEnforcedVertices() : GetDefaultEnfVertexList();
+}
+
+BLSURFPlugin_Hypothesis::TFaceEntryCoordsListMap BLSURFPlugin_Hypothesis::GetAllCoordsByFace(
+ const BLSURFPlugin_Hypothesis* hyp) {
+ return hyp ? hyp->_GetAllCoordsByFace() : GetDefaultFaceEntryCoordsListMap();
+}
+
+BLSURFPlugin_Hypothesis::TCoordsEnfVertexMap BLSURFPlugin_Hypothesis::GetAllEnforcedVerticesByCoords(
+ const BLSURFPlugin_Hypothesis* hyp) {
+ return hyp ? hyp->_GetAllEnforcedVerticesByCoords() : GetDefaultCoordsEnfVertexMap();
+}
+
+BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexEntryListMap BLSURFPlugin_Hypothesis::GetAllEnfVertexEntriesByFace(
+ const BLSURFPlugin_Hypothesis* hyp) {
+ return hyp ? hyp->_GetAllEnfVertexEntriesByFace() : GetDefaultFaceEntryEnfVertexEntryListMap();
+}
+
+BLSURFPlugin_Hypothesis::TEnfVertexEntryEnfVertexMap BLSURFPlugin_Hypothesis::GetAllEnforcedVerticesByEnfVertexEntry(
+ const BLSURFPlugin_Hypothesis* hyp) {
+ return hyp ? hyp->_GetAllEnforcedVerticesByEnfVertexEntry() : GetDefaultEnfVertexEntryEnfVertexMap();
+}
+
+std::set<int> BLSURFPlugin_Hypothesis::GetEnfVertexNodeIDs(TEnfGroupName theGroupName) throw (std::invalid_argument)
{
- return hyp ? hyp->_GetAllEnforcedVertices():GetDefaultEntryEnfVertexListMap();
+ TGroupNameNodeIDMap::const_iterator it = _groupNameNodeIDMap.find(theGroupName);
+ if (it != _groupNameNodeIDMap.end()) {
+ return it->second;
+ }
+ std::ostringstream msg;
+ msg << "No group " << theGroupName;
+ throw std::invalid_argument(msg.str());
}
+void BLSURFPlugin_Hypothesis::AddEnfVertexNodeID(TEnfGroupName theGroupName,int theNodeID)
+{
+ _groupNameNodeIDMap[theGroupName].insert(theNodeID);
+}
+void BLSURFPlugin_Hypothesis::RemoveEnfVertexNodeID(TEnfGroupName theGroupName,int theNodeID) throw (std::invalid_argument)
+{
+ TGroupNameNodeIDMap::iterator it = _groupNameNodeIDMap.find(theGroupName);
+ if (it != _groupNameNodeIDMap.end()) {
+ std::set<int>::iterator IDit = it->second.find(theNodeID);
+ if (IDit != it->second.end())
+ it->second.erase(IDit);
+ std::ostringstream msg;
+ msg << "No node IDs " << theNodeID << " for group " << theGroupName;
+ throw std::invalid_argument(msg.str());
+ }
+ std::ostringstream msg;
+ msg << "No group " << theGroupName;
+ throw std::invalid_argument(msg.str());
+}
//=============================================================================
-std::ostream & BLSURFPlugin_Hypothesis::SaveTo(std::ostream & save)
-{
- save << " " << (int)_topology
- << " " << (int)_physicalMesh
- << " " << (int)_geometricMesh
- << " " << _phySize
- << " " << _angleMeshS
- << " " << _gradation
- << " " << (int)_quadAllowed
- << " " << (int)_decimesh;
- save << " " << _phyMin
- << " " << _phyMax
- << " " << _angleMeshC
- << " " << _hgeoMin
- << " " << _hgeoMax
- << " " << _verb;
+std::ostream & BLSURFPlugin_Hypothesis::SaveTo(std::ostream & save) {
+ save << " " << (int) _topology << " " << (int) _physicalMesh << " " << (int) _geometricMesh << " " << _phySize << " "
+ << _angleMeshS << " " << _gradation << " " << (int) _quadAllowed << " " << (int) _decimesh;
+ save << " " << _phyMin << " " << _phyMax << " " << _angleMeshC << " " << _hgeoMin << " " << _hgeoMax << " " << _verb;
TOptionValues::iterator op_val = _option2value.begin();
if (op_val != _option2value.end()) {
save << " " << "__OPTIONS_BEGIN__";
- for ( ; op_val != _option2value.end(); ++op_val ) {
- if ( !op_val->second.empty() )
- save << " " << op_val->first
- << " " << op_val->second << "%#"; // "%#" is a mark of value end
+ for (; op_val != _option2value.end(); ++op_val) {
+ if (!op_val->second.empty())
+ save << " " << op_val->first << " " << op_val->second << "%#"; // "%#" is a mark of value end
}
save << " " << "__OPTIONS_END__";
}
- TSizeMap::iterator it_sm = _sizeMap.begin();
+ TSizeMap::iterator it_sm = _sizeMap.begin();
if (it_sm != _sizeMap.end()) {
save << " " << "__SIZEMAP_BEGIN__";
- for ( ; it_sm != _sizeMap.end(); ++it_sm ) {
- save << " " << it_sm->first
- << " " << it_sm->second << "%#"; // "%#" is a mark of value end
+ for (; it_sm != _sizeMap.end(); ++it_sm) {
+ save << " " << it_sm->first << " " << it_sm->second << "%#"; // "%#" is a mark of value end
}
save << " " << "__SIZEMAP_END__";
}
- TSizeMap::iterator it_at = _attractors.begin();
+ TSizeMap::iterator it_at = _attractors.begin();
if (it_at != _attractors.end()) {
save << " " << "__ATTRACTORS_BEGIN__";
- for ( ; it_at != _attractors.end(); ++it_at ) {
- save << " " << it_at->first
- << " " << it_at->second << "%#"; // "%#" is a mark of value end
+ for (; it_at != _attractors.end(); ++it_at) {
+ save << " " << it_at->first << " " << it_at->second << "%#"; // "%#" is a mark of value end
}
save << " " << "__ATTRACTORS_END__";
}
- TEntryEnfVertexListMap::const_iterator it_enf = _entryEnfVertexListMap.begin();
- if (it_enf != _entryEnfVertexListMap.end()) {
+ TFaceEntryEnfVertexListMap::const_iterator it_enf = _faceEntryEnfVertexListMap.begin();
+ if (it_enf != _faceEntryEnfVertexListMap.end()) {
save << " " << "__ENFORCED_VERTICES_BEGIN__";
- for ( ; it_enf != _entryEnfVertexListMap.end(); ++it_enf ) {
+ for (; it_enf != _faceEntryEnfVertexListMap.end(); ++it_enf) {
save << " " << it_enf->first;
- TEnfVertexList evl = it_enf->second;
- TEnfVertexList::const_iterator it_evl = evl.begin();
- for ( ; it_evl != evl.end() ; ++it_evl) {
- save << " " << (*it_evl)[0];
- save << " " << (*it_evl)[1];
- save << " " << (*it_evl)[2];
- /* TODO GROUPS
- TEnfVertexGroupNameMap::const_iterator it_enfGroup = _enfVertexGroupNameMap.find(*it_evl);
- if (it_enfGroup != _enfVertexGroupNameMap.end()) {
- save << " " << "__ENF_GROUP_BEGIN__";
- save << " " << it_enfGroup->second ;
- save << " " << "__ENF_GROUP_END__";
+ TEnfVertexList enfVertexList = it_enf->second;
+ TEnfVertexList::const_iterator it_enfVertexList = enfVertexList.begin();
+ for (; it_enfVertexList != enfVertexList.end(); ++it_enfVertexList) {
+ TEnfVertex *enfVertex = (*it_enfVertexList);
+ save << " " << enfVertex->name << ";";
+ save << " " << enfVertex->geomEntry << ";";
+ if (enfVertex->coords.size()) {
+ save << " " << enfVertex->coords[0] << ";";
+ save << " " << enfVertex->coords[1] << ";";
+ save << " " << enfVertex->coords[2] << ";";
}
- */
+ else {
+ save <<" ; ; ;";
+ }
+ save << " " << enfVertex->grpName;
save << " " << "$"; // "$" is a mark of enforced vertex end
}
save << "#"; // "#" is a mark of enforced shape end
}
//=============================================================================
-std::istream & BLSURFPlugin_Hypothesis::LoadFrom(std::istream & load)
-{
+std::istream & BLSURFPlugin_Hypothesis::LoadFrom(std::istream & load) {
bool isOK = true;
int i;
double val;
isOK = (load >> optValue);
}
if (isOK) {
- std::string & value = _option2value[ optName ];
+ std::string & value = _option2value[optName];
value = optValue;
int len = value.size();
// continue reading until "%#" encountered
- while ( value[len-1] != '#' || value[len-2] != '%' )
- {
+ while (value[len - 1] != '#' || value[len - 2] != '%') {
isOK = (load >> optValue);
if (isOK) {
value += " ";
value += optValue;
len = value.size();
- }
- else {
+ } else {
break;
}
}
- value[ len-2 ] = '\0'; //cut off "%#"
+ value[len - 2] = '\0'; //cut off "%#"
}
}
isOK = (load >> smValue);
}
if (isOK) {
- std::string & value2 = _sizeMap[ smEntry ];
+ std::string & value2 = _sizeMap[smEntry];
value2 = smValue;
- int len2= value2.size();
+ int len2 = value2.size();
// continue reading until "%#" encountered
- while ( value2[len2-1] != '#' || value2[len2-2] != '%' )
- {
+ while (value2[len2 - 1] != '#' || value2[len2 - 2] != '%') {
isOK = (load >> smValue);
if (isOK) {
value2 += " ";
value2 += smValue;
len2 = value2.size();
- }
- else {
+ } else {
break;
}
}
- value2[ len2-2 ] = '\0'; //cut off "%#"
+ value2[len2 - 2] = '\0'; //cut off "%#"
}
}
isOK = (load >> atValue);
}
if (isOK) {
- std::string & value3 = _attractors[ atEntry ];
+ std::string & value3 = _attractors[atEntry];
value3 = atValue;
- int len3= value3.size();
+ int len3 = value3.size();
// continue reading until "%#" encountered
- while ( value3[len3-1] != '#' || value3[len3-2] != '%' )
- {
+ while (value3[len3 - 1] != '#' || value3[len3 - 2] != '%') {
isOK = (load >> atValue);
if (isOK) {
value3 += " ";
value3 += atValue;
len3 = value3.size();
- }
- else {
+ } else {
break;
}
}
- value3[ len3-2 ] = '\0'; //cut off "%#"
+ value3[len3 - 2] = '\0'; //cut off "%#"
}
}
-
+
if (hasAttractor) {
isOK = (load >> option_or_sm);
if (isOK)
if (option_or_sm == "__ENFORCED_VERTICES_BEGIN__")
hasEnforcedVertex = true;
}
-
- std::string enfEntry, enfValue, enfGroup, trace;
+
+// MAPS TO FILL
+// TFaceEntryEnfVertexListMap _faceEntryEnfVertexListMap;
+// TEnfVertexList _enfVertexList;
+// // maps to get "manual" enf vertex (through their coordinates)
+// TFaceEntryCoordsListMap _faceEntryCoordsListMap;
+// TCoordsEnfVertexMap _coordsEnfVertexMap;
+// // maps to get "geom" enf vertex (through their geom entries)
+// TFaceEntryEnfVertexEntryListMap _faceEntryEnfVertexEntryListMap;
+// TEnfVertexEntryEnfVertexMap _enfVertexEntryEnfVertexMap;
+
+ std::string enfVertexEntry, enfValue, enfGroup, trace;
std::ostringstream oss;
while (isOK && hasEnforcedVertex) {
- isOK = (load >> enfEntry);
+ isOK = (load >> enfVertexEntry);
if (isOK) {
- MESSAGE("enfEntry: " <<enfEntry);
- if (enfEntry == "__ENFORCED_VERTICES_END__")
+ MESSAGE("enfVertexEntry: " <<enfVertexEntry);
+ if (enfVertexEntry == "__ENFORCED_VERTICES_END__")
break;
/* TODO GROUPS
- bool hasGroup = false;
- */
+ bool hasGroup = false;
+ */
enfValue = "begin";
int len4 = enfValue.size();
- TEnfVertexList & evl = _entryEnfVertexListMap[enfEntry];
- evl.clear();
- TEnfVertex enfVertex;
+ TEnfVertexCoordsList & coordsList = _faceEntryCoordsListMap[enfVertexEntry];
+ coordsList.clear();
+ TEnfVertexCoords coords;
+ TEnfVertex *enfVertex;
// continue reading until "#" encountered
- while ( enfValue[len4-1] != '#') {
+ while (enfValue[len4 - 1] != '#') {
// New vector begin
- enfVertex.clear();
- while ( enfValue[len4-1] != '$') {
+ coords.clear();
+ enfVertex->coords.clear();
+
+ while (enfValue[len4 - 1] != '$') {
isOK = (load >> enfValue);
if (isOK) {
MESSAGE("enfValue: " <<enfValue);
len4 = enfValue.size();
// End of vertex list
- if (enfValue[len4-1] == '#')
+ if (enfValue[len4 - 1] == '#')
break;
/* TODO GROUPS
- if (enfValue == "__ENF_GROUP_BEGIN__") {
- hasGroup = true;
- isOK = (load >> enfGroup);
- MESSAGE("enfGroup: " <<enfGroup);
- TEnfGroupName& groupName = _enfVertexGroupNameMap[ enfVertex ];
- groupName = enfGroup;
- while ( isOK) {
- isOK = (load >> enfGroup);
- if (isOK) {
- MESSAGE("enfGroup: " <<enfGroup);
- if (enfGroup == "__ENF_GROUP_END__")
- break;
- groupName += " ";
- groupName += enfGroup;
- }
- }
- }
- else {
+ if (enfValue == "__ENF_GROUP_BEGIN__") {
+ hasGroup = true;
+ isOK = (load >> enfGroup);
+ MESSAGE("enfGroup: " <<enfGroup);
+ TEnfGroupName& groupName = _enfVertexGroupNameMap[ enfVertex ];
+ groupName = enfGroup;
+ while ( isOK) {
+ isOK = (load >> enfGroup);
+ if (isOK) {
+ MESSAGE("enfGroup: " <<enfGroup);
+ if (enfGroup == "__ENF_GROUP_END__")
+ break;
+ groupName += " ";
+ groupName += enfGroup;
+ }
+ }
+ }
+ else {
+ // Add to vertex
+ enfVertex.push_back(atof(enfValue.c_str()));
+ }
+ */
+ if (enfValue[len4 - 1] != '$') {
// Add to vertex
- enfVertex.push_back(atof(enfValue.c_str()));
+ // name
+ enfVertex->name = enfValue;
+ isOK = (load >> enfValue);
+ len4 = enfValue.size();
}
- */
- if (enfValue[len4-1] != '$') {
- // Add to vertex
- enfVertex.push_back(atof(enfValue.c_str()));
+ if (enfValue[len4 - 1] != '$') {
+ // X coord
+ enfVertex->coords.push_back(atof(enfValue.c_str()));
+ isOK = (load >> enfValue);
+ len4 = enfValue.size();
+ }
+ if (enfValue[len4 - 1] != '$') {
+ // Y coord
+ enfVertex->coords.push_back(atof(enfValue.c_str()));
+ isOK = (load >> enfValue);
+ len4 = enfValue.size();
+ }
+ if (enfValue[len4 - 1] != '$') {
+ // Z coord
+ enfVertex->coords.push_back(atof(enfValue.c_str()));
+ isOK = (load >> enfValue);
+ len4 = enfValue.size();
}
- }
- else
+ } else
break;
}
- if (enfValue[len4-1] == '$') {
+ if (enfValue[len4 - 1] == '$') {
MESSAGE("enfValue is $");
- enfValue[len4-1] = '\0'; //cut off "$"
+ enfValue[len4 - 1] = '\0'; //cut off "$"
/* TODO GROUPS
- if (!hasGroup) {
- MESSAGE("no group: remove $");
- // Remove '$' and add to vertex
-// enfValue[len4-1] = '\0'; //cut off "$#"
- enfVertex.push_back(atof(enfValue.c_str()));
- }
- */
- enfValue[len4-1] = '\0'; //cut off "$#"
- enfVertex.push_back(atof(enfValue.c_str()));
+ if (!hasGroup) {
+ MESSAGE("no group: remove $");
+ // Remove '$' and add to vertex
+ // enfValue[len4-1] = '\0'; //cut off "$#"
+ enfVertex.push_back(atof(enfValue.c_str()));
+ }
+ */
+ enfValue[len4 - 1] = '\0'; //cut off "$#"
+ enfVertex->coords.push_back(atof(enfValue.c_str()));
MESSAGE("Add vertex to list");
// Add vertex to list of vertex
- evl.insert(enfVertex);
+ coordsList.insert(enfVertex->coords);
+ _coordsEnfVertexMap[enfVertex->coords] = enfVertex;
+ // _enfVertexList.insert(enfVertex);
}
}
- if (enfValue[len4-1] == '#') {
+ if (enfValue[len4 - 1] == '#') {
/* TODO GROUPS
- if (!hasGroup) {
- // Remove '$#' and add to vertex
- enfValue[len4-2] = '\0'; //cut off "$#"
- enfVertex.push_back(atof(enfValue.c_str()));
- }
- */
+ if (!hasGroup) {
+ // Remove '$#' and add to vertex
+ enfValue[len4-2] = '\0'; //cut off "$#"
+ enfVertex.push_back(atof(enfValue.c_str()));
+ }
+ */
// Remove '$#' and add to vertex
- enfValue[len4-2] = '\0'; //cut off "$#"
- enfVertex.push_back(atof(enfValue.c_str()));
+ enfValue[len4 - 2] = '\0'; //cut off "$#"
+ enfVertex->coords.push_back(atof(enfValue.c_str()));
// Add vertex to list of vertex
- evl.insert(enfVertex);
+ coordsList.insert(enfVertex->coords);
+ _coordsEnfVertexMap[enfVertex->coords] = enfVertex;
+ // _enfVertexList.insert(enfVertex);
}
- }
- else
+ } else
break;
}
}
//=============================================================================
-std::ostream & operator <<(std::ostream & save, BLSURFPlugin_Hypothesis & hyp)
-{
- return hyp.SaveTo( save );
+std::ostream & operator <<(std::ostream & save, BLSURFPlugin_Hypothesis & hyp) {
+ return hyp.SaveTo(save);
}
//=============================================================================
-std::istream & operator >>(std::istream & load, BLSURFPlugin_Hypothesis & hyp)
-{
- return hyp.LoadFrom( load );
+std::istream & operator >>(std::istream & load, BLSURFPlugin_Hypothesis & hyp) {
+ return hyp.LoadFrom(load);
}
//================================================================================
*/
//================================================================================
-bool BLSURFPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh* theMesh,
- const TopoDS_Shape& theShape)
-{
+bool BLSURFPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape) {
return false;
}
*/
//=============================================================================
-bool BLSURFPlugin_Hypothesis::SetParametersByDefaults(const TDefaults& dflts,
- const SMESH_Mesh* theMesh)
-{
- return bool( _phySize = dflts._elemLength );
+bool BLSURFPlugin_Hypothesis::SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh) {
+ return bool(_phySize = dflts._elemLength);
}
//=============================================================================
-BLSURFPlugin_Hypothesis::Topology BLSURFPlugin_Hypothesis::GetDefaultTopology()
-{
+BLSURFPlugin_Hypothesis::Topology BLSURFPlugin_Hypothesis::GetDefaultTopology() {
return FromCAD;
}
//=============================================================================
-BLSURFPlugin_Hypothesis::PhysicalMesh BLSURFPlugin_Hypothesis::GetDefaultPhysicalMesh()
-{
+BLSURFPlugin_Hypothesis::PhysicalMesh BLSURFPlugin_Hypothesis::GetDefaultPhysicalMesh() {
return PhysicalUserDefined;
}
//=============================================================================
-double BLSURFPlugin_Hypothesis::GetDefaultPhySize()
-{
+double BLSURFPlugin_Hypothesis::GetDefaultPhySize() {
return 10;
}
//======================================================================
-double BLSURFPlugin_Hypothesis::GetDefaultMaxSize()
-{
+double BLSURFPlugin_Hypothesis::GetDefaultMaxSize() {
return undefinedDouble(); // 1e+4;
}
//======================================================================
-double BLSURFPlugin_Hypothesis::GetDefaultMinSize()
-{
+double BLSURFPlugin_Hypothesis::GetDefaultMinSize() {
return undefinedDouble(); //1e-4;
}
//======================================================================
-BLSURFPlugin_Hypothesis::GeometricMesh BLSURFPlugin_Hypothesis::GetDefaultGeometricMesh()
-{
+BLSURFPlugin_Hypothesis::GeometricMesh BLSURFPlugin_Hypothesis::GetDefaultGeometricMesh() {
return DefaultGeom;
}
//=============================================================================
-double BLSURFPlugin_Hypothesis::GetDefaultAngleMeshS()
-{
+double BLSURFPlugin_Hypothesis::GetDefaultAngleMeshS() {
return 8;
}
//=============================================================================
-double BLSURFPlugin_Hypothesis::GetDefaultGradation()
-{
+double BLSURFPlugin_Hypothesis::GetDefaultGradation() {
return 1.1;
}
//=============================================================================
-bool BLSURFPlugin_Hypothesis::GetDefaultQuadAllowed()
-{
+bool BLSURFPlugin_Hypothesis::GetDefaultQuadAllowed() {
return false;
}
//=============================================================================
-bool BLSURFPlugin_Hypothesis::GetDefaultDecimesh()
-{
+bool BLSURFPlugin_Hypothesis::GetDefaultDecimesh() {
return false;
}
#include <set>
#include <stdexcept>
#include <string>
+#include <cstring>
+#include <sstream>
+#include <utilities.h>
// Parameters for work of BLSURF
* To set/get/unset an enforced vertex
*/
// Entry
- typedef std::string TEnfEntry;
- // Enforced vertex = 3 coordinates
- typedef std::vector<double> TEnfVertex;
- // List of enforced vertices
- typedef std::set< TEnfVertex > TEnfVertexList;
- // Map Entry / List of enforced vertices
- typedef std::map< TEnfEntry , TEnfVertexList > TEntryEnfVertexListMap;
- /* TODO GROUPS
+ typedef std::string TEntry;
+ // List of entries
+ typedef std::set<TEntry> TEntryList;
+ // Name
+ typedef std::string TEnfName;
// Group name
typedef std::string TEnfGroupName;
+ // Coordinates
+ typedef std::vector<double> TEnfVertexCoords;
+ typedef std::set< TEnfVertexCoords > TEnfVertexCoordsList;
+
+ // Enforced vertex
+ struct TEnfVertex {
+ TEnfName name;
+ TEntry geomEntry;
+ TEnfVertexCoords coords;
+ TEnfGroupName grpName;
+ TEntryList faceEntries;
+ };
+
+ struct CompareEnfVertices
+ {
+ bool operator () (const TEnfVertex* e1, const TEnfVertex* e2) const {
+ if (e1 && e2) {
+ if (e1->coords.size() && e2->coords.size())
+ return (e1->coords < e2->coords);
+ else
+ return (e1->geomEntry < e2->geomEntry);
+ }
+ return false;
+ }
+ };
+
+ // List of enforced vertices
+ typedef std::set< TEnfVertex*, CompareEnfVertices > TEnfVertexList;
+
+ // Map Face Entry / List of enforced vertices
+ typedef std::map< TEntry, TEnfVertexList > TFaceEntryEnfVertexListMap;
+
+ // Map Face Entry / List of coords
+ typedef std::map< TEntry, TEnfVertexCoordsList > TFaceEntryCoordsListMap;
+
+ // Map Face Entry / List of Vertex entry
+ typedef std::map< TEntry, TEntryList > TFaceEntryEnfVertexEntryListMap;
+
+ // Map Coords / Enforced vertex
+ typedef std::map< TEnfVertexCoords, TEnfVertex* > TCoordsEnfVertexMap;
+
+ // Map Vertex entry / Enforced vertex
+ typedef std::map< TEntry, TEnfVertex* > TEnfVertexEntryEnfVertexMap;
+
+ typedef std::map< TEnfGroupName, std::set<int> > TGroupNameNodeIDMap;
+ /* TODO GROUPS
// Map Group Name / List of enforced vertices
typedef std::map< TEnfGroupName , TEnfVertexList > TGroupNameEnfVertexListMap;
- // Map Enforced vertex / Group Name
- typedef std::map< TEnfVertex , TEnfGroupName > TEnfVertexGroupNameMap;
*/
- /* TODO GROUPS
- void SetEnforcedVertex(const TEnfEntry& entry, double x, double y, double z, const TEnfGroupName& groupName="");
- */
- void SetEnforcedVertex(const TEnfEntry& entry, double x, double y, double z);
-// void SetEnforcedVertexList(const TEnfEntry& entry, const TEnfVertexList vertexList);
- TEnfVertexList GetEnforcedVertices(const TEnfEntry& entry) throw (std::invalid_argument);
- void ClearEnforcedVertex(const TEnfEntry& entry, double x, double y, double z) throw (std::invalid_argument);
-// void ClearEnforcedVertexList(const TEnfEntry& entry, TEnfVertexList vertexList) throw (std::invalid_argument);
- void ClearEnforcedVertices(const TEnfEntry& entry) throw (std::invalid_argument);
+// TODO GROUPS
+// void SetEnforcedVertex(const TEntry& entry, double x, double y, double z, const TEnfGroupName& groupName="");
+ bool SetEnforcedVertex(TEntry theFaceEntry, TEnfName theVertexName, TEntry theVertexEntry, TEnfGroupName theGroupName,
+ double x = 0.0, double y = 0.0, double z = 0.0);
+ TEnfVertexList GetEnfVertexList(const TEntry& theFaceEntry) throw (std::invalid_argument);
+ TEnfVertexCoordsList GetEnfVertexCoordsList(const TEntry& theFaceEntry) throw (std::invalid_argument);
+ TEntryList GetEnfVertexEntryList (const TEntry& theFaceEntry) throw (std::invalid_argument);
+ TEnfVertex* GetEnfVertex(TEnfVertexCoords coords) throw (std::invalid_argument);
+ TEnfVertex* GetEnfVertex(const TEntry& theEnfVertexEntry) throw (std::invalid_argument);
+ void AddEnfVertexNodeID(TEnfGroupName theGroupName,int theNodeID);
+ std::set<int> GetEnfVertexNodeIDs(TEnfGroupName theGroupName) throw (std::invalid_argument);
+ void RemoveEnfVertexNodeID(TEnfGroupName theGroupName,int theNodeID) throw (std::invalid_argument);
+
+ bool ClearEnforcedVertex(const TEntry& theFaceEntry, double x = 0.0, double y = 0.0, double z = 0.0, const TEntry& theVertexEntry="") throw (std::invalid_argument);
+ bool ClearEnforcedVertices(const TEntry& theFaceEntry) throw (std::invalid_argument);
void ClearAllEnforcedVertices();
- const TEntryEnfVertexListMap _GetAllEnforcedVertices() const { return _entryEnfVertexListMap; }
- /* TODO GROUPS
- const TEnfVertexGroupNameMap _GetEnforcedVertexGroupNameMap() const { return _enfVertexGroupNameMap; }
- */
+
+ const TFaceEntryEnfVertexListMap _GetAllEnforcedVerticesByFace() const { return _faceEntryEnfVertexListMap; }
+ const TEnfVertexList _GetAllEnforcedVertices() const { return _enfVertexList; }
+
+ const TFaceEntryCoordsListMap _GetAllCoordsByFace() const { return _faceEntryCoordsListMap; }
+ const TCoordsEnfVertexMap _GetAllEnforcedVerticesByCoords() const { return _coordsEnfVertexMap; }
+
+ const TFaceEntryEnfVertexEntryListMap _GetAllEnfVertexEntriesByFace() const { return _faceEntryEnfVertexEntryListMap; }
+ const TEnfVertexEntryEnfVertexMap _GetAllEnforcedVerticesByEnfVertexEntry() const { return _enfVertexEntryEnfVertexMap; }
+
+// TODO GROUPS
+// const TEnfVertexGroupNameMap _GetEnforcedVertexGroupNameMap() const { return _enfVertexGroupNameMap; }
+
/*!
* \brief Return the enforced vertices
*/
- static TEntryEnfVertexListMap GetAllEnforcedVertices(const BLSURFPlugin_Hypothesis* hyp);
+ static TFaceEntryEnfVertexListMap GetAllEnforcedVerticesByFace(const BLSURFPlugin_Hypothesis* hyp);
+ static TEnfVertexList GetAllEnforcedVertices(const BLSURFPlugin_Hypothesis* hyp);
+
+ static TFaceEntryCoordsListMap GetAllCoordsByFace(const BLSURFPlugin_Hypothesis* hyp);
+ static TCoordsEnfVertexMap GetAllEnforcedVerticesByCoords(const BLSURFPlugin_Hypothesis* hyp);
+
+ static TFaceEntryEnfVertexEntryListMap GetAllEnfVertexEntriesByFace(const BLSURFPlugin_Hypothesis* hyp);
+ static TEnfVertexEntryEnfVertexMap GetAllEnforcedVerticesByEnfVertexEntry(const BLSURFPlugin_Hypothesis* hyp);
+
/*!
* \brief Set/get node group to an enforced vertex
static bool GetDefaultDecimesh();
static int GetDefaultVerbosity() { return 10; }
static TSizeMap GetDefaultSizeMap() { return TSizeMap();}
- static TEnfVertexList GetDefaultEnfVertexList() { return TEnfVertexList(); }
- static TEntryEnfVertexListMap GetDefaultEntryEnfVertexListMap() { return TEntryEnfVertexListMap(); }
+
+ static TFaceEntryEnfVertexListMap GetDefaultFaceEntryEnfVertexListMap() { return TFaceEntryEnfVertexListMap(); }
+ static TEnfVertexList GetDefaultEnfVertexList() { return TEnfVertexList(); }
+ static TFaceEntryCoordsListMap GetDefaultFaceEntryCoordsListMap() { return TFaceEntryCoordsListMap(); }
+ static TCoordsEnfVertexMap GetDefaultCoordsEnfVertexMap() { return TCoordsEnfVertexMap(); }
+ static TFaceEntryEnfVertexEntryListMap GetDefaultFaceEntryEnfVertexEntryListMap() { return TFaceEntryEnfVertexEntryListMap(); }
+ static TEnfVertexEntryEnfVertexMap GetDefaultEnfVertexEntryEnfVertexMap() { return TEnfVertexEntryEnfVertexMap(); }
+ static TGroupNameNodeIDMap GetDefaultGroupNameNodeIDMap() { return TGroupNameNodeIDMap(); }
+
/* TODO GROUPS
static TGroupNameEnfVertexListMap GetDefaultGroupNameEnfVertexListMap() { return TGroupNameEnfVertexListMap(); }
static TEnfVertexGroupNameMap GetDefaultEnfVertexGroupNameMap() { return TEnfVertexGroupNameMap(); }
*/
virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0);
-/* TODO GROUPS
-private:
- bool _setEnfVertexWithGroup(double x, double y, double z, const std::string groupName) throw (std::invalid_argument);
-*/
private:
Topology _topology;
TOptionNames _doubleOptions, _charOptions;
TSizeMap _sizeMap;
TSizeMap _attractors;
- TEnfVertexList _enfVertexList;
- TEntryEnfVertexListMap _entryEnfVertexListMap;
+
+ TFaceEntryEnfVertexListMap _faceEntryEnfVertexListMap;
+ TEnfVertexList _enfVertexList;
+ // maps to get "manual" enf vertex (through their coordinates)
+ TFaceEntryCoordsListMap _faceEntryCoordsListMap;
+ TCoordsEnfVertexMap _coordsEnfVertexMap;
+ // maps to get "geom" enf vertex (through their geom entries)
+ TFaceEntryEnfVertexEntryListMap _faceEntryEnfVertexEntryListMap;
+ TEnfVertexEntryEnfVertexMap _enfVertexEntryEnfVertexMap;
+ TGroupNameNodeIDMap _groupNameNodeIDMap;
+
/* TODO GROUPS
TGroupNameEnfVertexListMap _groupNameEnfVertexListMap;
- TEnfVertexGroupNameMap _enfVertexGroupNameMap;
*/
// TSizeMap _customSizeMap;
};
//
#include "BLSURFPlugin_Hypothesis_i.hxx"
#include "SMESH_Gen.hxx"
+#include "SMESH_Gen_i.hxx"
#include "SMESH_PythonDump.hxx"
#include "GEOM_Object.hxx"
* Constructor
*/
//=============================================================================
-BLSURFPlugin_Hypothesis_i::
-BLSURFPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
- int theStudyId,
- ::SMESH_Gen* theGenImpl)
- : SALOME::GenericObj_i( thePOA ),
- SMESH_Hypothesis_i( thePOA )
-{
+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);
+ myBaseImpl = new ::BLSURFPlugin_Hypothesis(theGenImpl->GetANewId(), theStudyId, theGenImpl);
}
//=============================================================================
* Destructor
*/
//=============================================================================
-BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i()
-{
+BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i() {
MESSAGE( "BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i" );
}
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetTopology (CORBA::Long theValue)
-{
+void BLSURFPlugin_Hypothesis_i::SetTopology(CORBA::Long theValue) {
// MESSAGE("BLSURFPlugin_Hypothesis_i::SetTopology");
ASSERT(myBaseImpl);
- this->GetImpl()->SetTopology((::BLSURFPlugin_Hypothesis::Topology)theValue);
+ this->GetImpl()->SetTopology((::BLSURFPlugin_Hypothesis::Topology) theValue);
SMESH::TPythonDump() << _this() << ".SetTopology( " << theValue << " )";
}
* Get Topology
*/
//=============================================================================
-CORBA::Long BLSURFPlugin_Hypothesis_i::GetTopology()
-{
+CORBA::Long BLSURFPlugin_Hypothesis_i::GetTopology() {
// MESSAGE("BLSURFPlugin_Hypothesis_i::GetTopology");
ASSERT(myBaseImpl);
return this->GetImpl()->GetTopology();
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh (CORBA::Long theValue)
-{
+void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh(CORBA::Long theValue) {
// MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhysicalMesh");
ASSERT(myBaseImpl);
- this->GetImpl()->SetPhysicalMesh((::BLSURFPlugin_Hypothesis::PhysicalMesh)theValue);
+ this->GetImpl()->SetPhysicalMesh((::BLSURFPlugin_Hypothesis::PhysicalMesh) theValue);
SMESH::TPythonDump() << _this() << ".SetPhysicalMesh( " << theValue << " )";
}
* Get PhysicalMesh
*/
//=============================================================================
-CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh()
-{
+CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh() {
// MESSAGE("BLSURFPlugin_Hypothesis_i::GetPhysicalMesh");
ASSERT(myBaseImpl);
return this->GetImpl()->GetPhysicalMesh();
* Set PhySize
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetPhySize (CORBA::Double theValue)
-{
+void BLSURFPlugin_Hypothesis_i::SetPhySize(CORBA::Double theValue) {
// MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhySize");
ASSERT(myBaseImpl);
this->GetImpl()->SetPhySize(theValue);
* Get PhySize
*/
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize()
-{
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize() {
// MESSAGE("BLSURFPlugin_Hypothesis_i::GetPhySize");
ASSERT(myBaseImpl);
return this->GetImpl()->GetPhySize();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetPhyMin(CORBA::Double theMinSize)
-{
+void BLSURFPlugin_Hypothesis_i::SetPhyMin(CORBA::Double theMinSize) {
ASSERT(myBaseImpl);
- if ( GetPhyMin() != theMinSize ) {
+ if (GetPhyMin() != theMinSize) {
this->GetImpl()->SetPhyMin(theMinSize);
SMESH::TPythonDump() << _this() << ".SetPhyMin( " << theMinSize << " )";
}
}
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhyMin()
-{
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhyMin() {
ASSERT(myBaseImpl);
return this->GetImpl()->GetPhyMin();
}
-
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetPhyMax(CORBA::Double theMaxSize)
-{
+void BLSURFPlugin_Hypothesis_i::SetPhyMax(CORBA::Double theMaxSize) {
ASSERT(myBaseImpl);
- if ( GetPhyMax() != theMaxSize ) {
+ if (GetPhyMax() != theMaxSize) {
this->GetImpl()->SetPhyMax(theMaxSize);
SMESH::TPythonDump() << _this() << ".SetPhyMax( " << theMaxSize << " )";
}
}
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhyMax()
-{
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhyMax() {
ASSERT(myBaseImpl);
return this->GetImpl()->GetPhyMax();
}
-
//=============================================================================
/*!
* BLSURFPlugin_Hypothesis_i::SetGeometricMesh
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetGeometricMesh (CORBA::Long theValue)
-{
+void BLSURFPlugin_Hypothesis_i::SetGeometricMesh(CORBA::Long theValue) {
// MESSAGE("BLSURFPlugin_Hypothesis_i::SetGeometricMesh");
ASSERT(myBaseImpl);
- this->GetImpl()->SetGeometricMesh((::BLSURFPlugin_Hypothesis::GeometricMesh)theValue);
+ this->GetImpl()->SetGeometricMesh((::BLSURFPlugin_Hypothesis::GeometricMesh) theValue);
SMESH::TPythonDump() << _this() << ".SetGeometricMesh( " << theValue << " )";
}
* Get GeometricMesh
*/
//=============================================================================
-CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh()
-{
+CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh() {
// MESSAGE("BLSURFPlugin_Hypothesis_i::GetGeometricMesh");
ASSERT(myBaseImpl);
return this->GetImpl()->GetGeometricMesh();
* Set AngleMeshS
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetAngleMeshS (CORBA::Double theValue)
-{
+void BLSURFPlugin_Hypothesis_i::SetAngleMeshS(CORBA::Double theValue) {
// MESSAGE("BLSURFPlugin_Hypothesis_i::SetAngleMeshS");
ASSERT(myBaseImpl);
this->GetImpl()->SetAngleMeshS(theValue);
* Get AngleMeshS
*/
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMeshS()
-{
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMeshS() {
// MESSAGE("BLSURFPlugin_Hypothesis_i::GetAngleMeshS");
ASSERT(myBaseImpl);
return this->GetImpl()->GetAngleMeshS();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetAngleMeshC(CORBA::Double angle)
-{
+void BLSURFPlugin_Hypothesis_i::SetAngleMeshC(CORBA::Double angle) {
ASSERT(myBaseImpl);
this->GetImpl()->SetAngleMeshC(angle);
SMESH::TPythonDump() << _this() << ".SetAngleMeshC( " << angle << " )";
}
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMeshC()
-{
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMeshC() {
ASSERT(myBaseImpl);
return this->GetImpl()->GetAngleMeshC();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetGeoMin(CORBA::Double theMinSize)
-{
+void BLSURFPlugin_Hypothesis_i::SetGeoMin(CORBA::Double theMinSize) {
ASSERT(myBaseImpl);
- if ( GetGeoMin() != theMinSize ) {
+ if (GetGeoMin() != theMinSize) {
this->GetImpl()->SetGeoMin(theMinSize);
SMESH::TPythonDump() << _this() << ".SetGeoMin( " << theMinSize << " )";
}
}
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetGeoMin()
-{
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetGeoMin() {
ASSERT(myBaseImpl);
return this->GetImpl()->GetGeoMin();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetGeoMax(CORBA::Double theMaxSize)
-{
+void BLSURFPlugin_Hypothesis_i::SetGeoMax(CORBA::Double theMaxSize) {
ASSERT(myBaseImpl);
- if ( GetGeoMax() != theMaxSize ) {
+ if (GetGeoMax() != theMaxSize) {
this->GetImpl()->SetGeoMax(theMaxSize);
SMESH::TPythonDump() << _this() << ".SetGeoMax( " << theMaxSize << " )";
}
}
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetGeoMax()
-{
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetGeoMax() {
ASSERT(myBaseImpl);
return this->GetImpl()->GetGeoMax();
}
* Set Gradation
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetGradation (CORBA::Double theValue)
-{
+void BLSURFPlugin_Hypothesis_i::SetGradation(CORBA::Double theValue) {
// MESSAGE("BLSURFPlugin_Hypothesis_i::SetGradation");
ASSERT(myBaseImpl);
this->GetImpl()->SetGradation(theValue);
* Get Gradation
*/
//=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetGradation()
-{
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetGradation() {
// MESSAGE("BLSURFPlugin_Hypothesis_i::GetGradation");
ASSERT(myBaseImpl);
return this->GetImpl()->GetGradation();
* Set true or false
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetQuadAllowed (CORBA::Boolean theValue)
-{
+void BLSURFPlugin_Hypothesis_i::SetQuadAllowed(CORBA::Boolean theValue) {
// MESSAGE("BLSURFPlugin_Hypothesis_i::SetQuadAllowed");
ASSERT(myBaseImpl);
this->GetImpl()->SetQuadAllowed(theValue);
* Get true or false
*/
//=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadAllowed()
-{
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadAllowed() {
// MESSAGE("BLSURFPlugin_Hypothesis_i::GetQuadAllowed");
ASSERT(myBaseImpl);
return this->GetImpl()->GetQuadAllowed();
* Set true or false
*/
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetDecimesh (CORBA::Boolean theValue)
-{
+void BLSURFPlugin_Hypothesis_i::SetDecimesh(CORBA::Boolean theValue) {
// MESSAGE("BLSURFPlugin_Hypothesis_i::SetDecimesh");
ASSERT(myBaseImpl);
this->GetImpl()->SetDecimesh(theValue);
* Get true or false
*/
//=============================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetDecimesh()
-{
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetDecimesh() {
// MESSAGE("BLSURFPlugin_Hypothesis_i::GetDecimesh");
ASSERT(myBaseImpl);
return this->GetImpl()->GetDecimesh();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetVerbosity(CORBA::Short theVal)
- throw (SALOME::SALOME_Exception)
-{
+void BLSURFPlugin_Hypothesis_i::SetVerbosity(CORBA::Short theVal) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- if ( theVal < 0 || theVal > 100 )
+ if (theVal < 0 || theVal > 100)
THROW_SALOME_CORBA_EXCEPTION( "Invalid verbosity level",SALOME::BAD_PARAM );
this->GetImpl()->SetVerbosity(theVal);
SMESH::TPythonDump() << _this() << ".SetVerbosity( " << theVal << " )";
//=============================================================================
-CORBA::Short BLSURFPlugin_Hypothesis_i::GetVerbosity()
-{
+CORBA::Short BLSURFPlugin_Hypothesis_i::GetVerbosity() {
ASSERT(myBaseImpl);
return (CORBA::Short) this->GetImpl()->GetVerbosity();
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetOptionValue(const char* optionName,
- const char* optionValue)
- throw (SALOME::SALOME_Exception)
-{
+void BLSURFPlugin_Hypothesis_i::SetOptionValue(const char* optionName, const char* optionValue)
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
bool valueChanged = false;
try {
- valueChanged = ( this->GetImpl()->GetOptionValue(optionName) != optionValue );
- if ( valueChanged )
+ valueChanged = (this->GetImpl()->GetOptionValue(optionName) != optionValue);
+ if (valueChanged)
this->GetImpl()->SetOptionValue(optionName, optionValue);
- }
- catch (const std::invalid_argument& ex) {
+ } catch (const std::invalid_argument& ex) {
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetOptionValue(name,value)";
ExDescription.lineNumber = 0;
throw SALOME::SALOME_Exception(ExDescription);
- }
- catch (SALOME_Exception& ex) {
+ } catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- if ( valueChanged )
- SMESH::TPythonDump() << _this() << ".SetOptionValue( '"
- << optionName << "', '" << optionValue << "' )";
+ if (valueChanged)
+ SMESH::TPythonDump() << _this() << ".SetOptionValue( '" << optionName << "', '" << optionValue << "' )";
}
//=============================================================================
-char* BLSURFPlugin_Hypothesis_i::GetOptionValue(const char* optionName)
- throw (SALOME::SALOME_Exception)
-{
+char* BLSURFPlugin_Hypothesis_i::GetOptionValue(const char* optionName) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
try {
- return CORBA::string_dup( this->GetImpl()->GetOptionValue(optionName).c_str() );
- }
- catch (const std::invalid_argument& ex) {
+ return CORBA::string_dup(this->GetImpl()->GetOptionValue(optionName).c_str());
+ } catch (const std::invalid_argument& ex) {
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::GetOptionValue(name)";
ExDescription.lineNumber = 0;
throw SALOME::SALOME_Exception(ExDescription);
- }
- catch (SALOME_Exception& ex) {
+ } catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
return 0;
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::UnsetOption(const char* optionName)
-{
+void BLSURFPlugin_Hypothesis_i::UnsetOption(const char* optionName) {
ASSERT(myBaseImpl);
this->GetImpl()->ClearOption(optionName);
SMESH::TPythonDump() << _this() << ".UnsetOption( '" << optionName << "' )";
//=============================================================================
-BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetOptionValues()
-{
+BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetOptionValues() {
ASSERT(myBaseImpl);
BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array();
const ::BLSURFPlugin_Hypothesis::TOptionValues & opts = this->GetImpl()->GetOptionValues();
- result->length( opts.size() );
+ result->length(opts.size());
::BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt = opts.begin();
- for ( int i = 0 ; opIt != opts.end(); ++opIt, ++i ) {
+ for (int i = 0; opIt != opts.end(); ++opIt, ++i) {
string name_value = opIt->first;
- if ( !opIt->second.empty() ) {
+ if (!opIt->second.empty()) {
name_value += ":";
name_value += opIt->second;
}
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetOptionValues(const BLSURFPlugin::string_array& options)
- throw (SALOME::SALOME_Exception)
-{
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- for (int i = 0; i < options.length(); ++i)
- {
+ for (int i = 0; i < options.length(); ++i) {
string name_value = options[i].in();
- int colonPos = name_value.find( ':' );
+ int colonPos = name_value.find(':');
string name, value;
- if ( colonPos == string::npos ) // ':' not found
+ if (colonPos == string::npos) // ':' not found
name = name_value;
else {
- name = name_value.substr( 0, colonPos);
- if ( colonPos < name_value.size()-1 && name_value[colonPos] != ' ')
- value = name_value.substr( colonPos+1 );
+ name = name_value.substr(0, colonPos);
+ if (colonPos < name_value.size() - 1 && name_value[colonPos] != ' ')
+ value = name_value.substr(colonPos + 1);
}
- SetOptionValue( name.c_str(), value.c_str() );
+ SetOptionValue(name.c_str(), value.c_str());
}
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry,const char* sizeMap)
- throw (SALOME::SALOME_Exception)
-{
+void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* sizeMap)
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : SETSIZEMAP START ENTRY : " << entry);
+ MESSAGE("ENGINE : SETSIZEMAP START ENTRY : " << entry);
bool valueChanged = false;
try {
- valueChanged = ( this->GetImpl()->GetSizeMapEntry(entry) != sizeMap );
- if ( valueChanged )
+ valueChanged = (this->GetImpl()->GetSizeMapEntry(entry) != sizeMap);
+ if (valueChanged)
this->GetImpl()->SetSizeMapEntry(entry, sizeMap);
- }
- catch (const std::invalid_argument& ex) {
+ } catch (const std::invalid_argument& ex) {
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetSizeMapEntry(entry,sizemap)";
ExDescription.lineNumber = 0;
throw SALOME::SALOME_Exception(ExDescription);
- }
- catch (SALOME_Exception& ex) {
+ } 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 << "' )";
+ if (valueChanged)
+ SMESH::TPythonDump() << _this() << ".SetSizeMap(" << entry << ", '" << sizeMap << "' )";
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry,const char* attractor )
- throw (SALOME::SALOME_Exception)
-{
+void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry, const char* attractor)
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
MESSAGE("ENGINE : SETATTRACTOR START ENTRY : " << entry);
bool valueChanged = false;
throw std::invalid_argument("Error: an attractor is defined with the following pattern: ATTRACTOR(xa;ya;za;a;b;True|False;d(opt.))");
this->GetImpl()->SetAttractorEntry(entry, attractor);
}
- }
- catch (const std::invalid_argument& ex) {
+ } catch (const std::invalid_argument& ex) {
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetAttractorEntry(entry,attractor)";
ExDescription.lineNumber = 0;
throw SALOME::SALOME_Exception(ExDescription);
- }
- catch (SALOME_Exception& ex) {
+ } 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 << "' )";
+ if (valueChanged)
+ SMESH::TPythonDump() << _this() << ".SetAttractor(" << entry << ", '" << attractor << "' )";
}
-
//=============================================================================
-char* BLSURFPlugin_Hypothesis_i::GetSizeMapEntry(const char* entry)
- throw (SALOME::SALOME_Exception)
-{
+char* BLSURFPlugin_Hypothesis_i::GetSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
try {
- return CORBA::string_dup( this->GetImpl()->GetSizeMapEntry(entry).c_str());
- }
- catch (const std::invalid_argument& ex) {
+ return CORBA::string_dup(this->GetImpl()->GetSizeMapEntry(entry).c_str());
+ } catch (const std::invalid_argument& ex) {
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::GetSizeMapEntry(name)";
ExDescription.lineNumber = 0;
throw SALOME::SALOME_Exception(ExDescription);
- }
- catch (SALOME_Exception& ex) {
+ } catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
return 0;
//=============================================================================
-char* BLSURFPlugin_Hypothesis_i::GetAttractorEntry(const char* entry)
- throw (SALOME::SALOME_Exception)
-{
+char* BLSURFPlugin_Hypothesis_i::GetAttractorEntry(const char* entry) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
try {
- return CORBA::string_dup( this->GetImpl()->GetAttractorEntry(entry).c_str());
- }
- catch (const std::invalid_argument& ex) {
+ return CORBA::string_dup(this->GetImpl()->GetAttractorEntry(entry).c_str());
+ } catch (const std::invalid_argument& ex) {
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::GetAttractorEntry(name)";
ExDescription.lineNumber = 0;
throw SALOME::SALOME_Exception(ExDescription);
- }
- catch (SALOME_Exception& ex) {
+ } catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
return 0;
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::UnsetEntry(const char* entry)
-{
- ASSERT(myBaseImpl);
+void BLSURFPlugin_Hypothesis_i::UnsetEntry(const char* entry) {
+ ASSERT(myBaseImpl);
this->GetImpl()->ClearEntry(entry);
-// SMESH::TPythonDump() << _this() << ".UnsetSizeMap( " << entry << " )";
+ // SMESH::TPythonDump() << _this() << ".UnsetSizeMap( " << entry << " )";
}
//=============================================================================
-BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetSizeMapEntries()
-{
+BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetSizeMapEntries() {
ASSERT(myBaseImpl);
BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array();
- const ::BLSURFPlugin_Hypothesis::TSizeMap sizeMaps= this->GetImpl()->_GetSizeMapEntries();
- result->length( sizeMaps.size() );
+ const ::BLSURFPlugin_Hypothesis::TSizeMap sizeMaps = this->GetImpl()->_GetSizeMapEntries();
+ result->length(sizeMaps.size());
::BLSURFPlugin_Hypothesis::TSizeMap::const_iterator smIt = sizeMaps.begin();
- for ( int i = 0 ; smIt != sizeMaps.end(); ++smIt, ++i ) {
+ for (int i = 0; smIt != sizeMaps.end(); ++smIt, ++i) {
string entry_sizemap = smIt->first;
- if ( !smIt->second.empty() ) {
+ if (!smIt->second.empty()) {
entry_sizemap += "|";
entry_sizemap += smIt->second;
}
//=============================================================================
-BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetAttractorEntries()
-{
+BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetAttractorEntries() {
ASSERT(myBaseImpl);
BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array();
- const ::BLSURFPlugin_Hypothesis::TSizeMap attractors= this->GetImpl()->_GetAttractorEntries();
- result->length( attractors.size() );
+ const ::BLSURFPlugin_Hypothesis::TSizeMap attractors = this->GetImpl()->_GetAttractorEntries();
+ result->length(attractors.size());
::BLSURFPlugin_Hypothesis::TSizeMap::const_iterator atIt = attractors.begin();
- for ( int i = 0 ; atIt != attractors.end(); ++atIt, ++i ) {
+ for (int i = 0; atIt != attractors.end(); ++atIt, ++i) {
string entry_attractor = atIt->first;
- if ( !atIt->second.empty() ) {
+ if (!atIt->second.empty()) {
entry_attractor += "|";
entry_attractor += atIt->second;
}
//=============================================================================
void BLSURFPlugin_Hypothesis_i::SetSizeMapEntries(const BLSURFPlugin::string_array& sizeMaps)
- throw (SALOME::SALOME_Exception)
-{
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- for (int i = 0; i < sizeMaps.length(); ++i)
- {
+ for (int i = 0; i < sizeMaps.length(); ++i) {
string entry_sizemap = sizeMaps[i].in();
- int colonPos = entry_sizemap.find( '|' );
+ int colonPos = entry_sizemap.find('|');
string entry, sizemap;
- if ( colonPos == string::npos ) // '|' separator not found
+ if (colonPos == string::npos) // '|' separator not found
entry = entry_sizemap;
else {
- entry = entry_sizemap.substr( 0, colonPos);
- if ( colonPos < entry_sizemap.size()-1 && entry_sizemap[colonPos] != ' ')
- sizemap = entry_sizemap.substr( colonPos+1 );
+ entry = entry_sizemap.substr(0, colonPos);
+ if (colonPos < entry_sizemap.size() - 1 && entry_sizemap[colonPos] != ' ')
+ sizemap = entry_sizemap.substr(colonPos + 1);
}
- this->GetImpl()->SetSizeMapEntry( entry.c_str(), sizemap.c_str() );
+ this->GetImpl()->SetSizeMapEntry(entry.c_str(), sizemap.c_str());
}
}
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::ClearSizeMaps()
-{
+void BLSURFPlugin_Hypothesis_i::ClearSizeMaps() {
ASSERT(myBaseImpl);
this->GetImpl()->ClearSizeMaps();
}
-
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetSizeMap(const GEOM::GEOM_Object_ptr GeomObj,const char* sizeMap)
-{
+void BLSURFPlugin_Hypothesis_i::SetSizeMap(const GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap) {
ASSERT(myBaseImpl);
string entry;
- entry=GeomObj->GetStudyEntry();
+ entry = GeomObj->GetStudyEntry();
MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : SETSIZEMAP ( "<< entry << " , " << sizeMap << ")");
- SetSizeMapEntry( entry.c_str(),sizeMap);
+ MESSAGE("IDL : SETSIZEMAP ( "<< entry << " , " << sizeMap << ")");
+ SetSizeMapEntry(entry.c_str(), sizeMap);
}
-
+
//=============================================================================
-void BLSURFPlugin_Hypothesis_i::UnsetSizeMap(const GEOM::GEOM_Object_ptr GeomObj)
-{
+void BLSURFPlugin_Hypothesis_i::UnsetSizeMap(const GEOM::GEOM_Object_ptr GeomObj) {
ASSERT(myBaseImpl);
string entry;
- entry=GeomObj->GetStudyEntry();
+ entry = GeomObj->GetStudyEntry();
MESSAGE("IDL : GetName : " << GeomObj->GetName());
MESSAGE("IDL : UNSETSIZEMAP ( "<< entry << ")");
- UnsetEntry( entry.c_str());
+ UnsetEntry(entry.c_str());
SMESH::TPythonDump() << _this() << ".UnsetSizeMap( " << entry.c_str() << " )";
}
-
-void BLSURFPlugin_Hypothesis_i::SetAttractor(GEOM::GEOM_Object_ptr GeomObj, const char* attractor)
-{
+void BLSURFPlugin_Hypothesis_i::SetAttractor(GEOM::GEOM_Object_ptr GeomObj, const char* attractor) {
ASSERT(myBaseImpl);
string entry;
- entry=GeomObj->GetStudyEntry();
+ entry = GeomObj->GetStudyEntry();
MESSAGE("IDL : GetName : " << GeomObj->GetName());
MESSAGE("IDL : SETATTRACTOR ( "<< entry << " , " << attractor << ")");
- SetAttractorEntry( entry.c_str(),attractor);
+ SetAttractorEntry(entry.c_str(), attractor);
}
-void BLSURFPlugin_Hypothesis_i::UnsetAttractor(GEOM::GEOM_Object_ptr GeomObj)
-{
+void BLSURFPlugin_Hypothesis_i::UnsetAttractor(GEOM::GEOM_Object_ptr GeomObj) {
ASSERT(myBaseImpl);
string entry;
- entry=GeomObj->GetStudyEntry();
+ entry = GeomObj->GetStudyEntry();
MESSAGE("IDL : GetName : " << GeomObj->GetName());
MESSAGE("IDL : UNSETATTRACTOR ( "<< entry << ")");
- UnsetEntry( entry.c_str());
+ UnsetEntry(entry.c_str());
SMESH::TPythonDump() << _this() << ".UnsetAttractor( " << entry.c_str() << " )";
}
+/*
+ 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::SetCustomSizeMapEntry(const char* entry,const char* sizeMap ) throw (SALOME::SALOME_Exception)
+ {}
-/*
-void BLSURFPlugin_Hypothesis_i::SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap)
-{}
+ char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception)
+ {}
-void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj)
-{}
+ void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry)
+ {
+ ASSERT(myBaseImpl);
+ this->GetImpl()->UnsetCustomSizeMap(entry);
+ SMESH::TPythonDump() << _this() << ".UnsetCustomSizeMap( " << entry << " )";
+ }
-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)
-{}
+ BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntries()
+ {}
-void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry)
-{
+ */
+
+// ///////////////////////
+// // ENFORCED VERTICES //
+// ///////////////////////
+
+
+/**
+ * Returns the list of enforced vertices for a given Face entry
+ * @return A map of Face entry / List of enforced vertices
+ *
+ */
+BLSURFPlugin::TFaceEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByFace() {
+ MESSAGE("IDL: GetAllEnforcedVerticesByFace()");
ASSERT(myBaseImpl);
- this->GetImpl()->UnsetCustomSizeMap(entry);
- SMESH::TPythonDump() << _this() << ".UnsetCustomSizeMap( " << entry << " )";
-}
+ BLSURFPlugin::TFaceEntryEnfVertexListMap_var resultMap = new BLSURFPlugin::TFaceEntryEnfVertexListMap();
-BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntries()
-{}
+ const ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap faceEntryEnfVertexListMap =
+ 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();
+ 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());
-///////////////////////
-// ENFORCED VERTEXES //
-///////////////////////
+ ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator it_enfVertex = _enfVertexList.begin();
+ ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex;
+ for (int j = 0; it_enfVertex != _enfVertexList.end(); ++it_enfVertex, ++j) {
+ currentEnfVertex = (*it_enfVertex);
-BLSURFPlugin::TEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices()
-{
+ BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
+
+ // Name
+ enfVertex->name = CORBA::string_dup(currentEnfVertex->name.c_str());
+
+ // Geom entry
+ enfVertex->geomEntry = CORBA::string_dup(currentEnfVertex->geomEntry.c_str());
+
+ // Coords
+ BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
+ coords->length(currentEnfVertex->coords.size());
+ for (int i=0;i<coords->length();i++)
+ coords[i] = currentEnfVertex->coords[i];
+ enfVertex->coords = coords;
+
+ // Group name
+ enfVertex->grpName = CORBA::string_dup(currentEnfVertex->grpName.c_str());
+
+ // Face entry list
+ BLSURFPlugin::TEntryList_var faceEntryList = new BLSURFPlugin::TEntryList();
+ faceEntryList->length(currentEnfVertex->faceEntries.size());
+ ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_entry = currentEnfVertex->faceEntries.begin();
+ for (int ind = 0; it_entry != currentEnfVertex->faceEntries.end();++it_entry, ++ind)
+ faceEntryList[ind] = CORBA::string_dup((*it_entry).c_str());
+ enfVertex->faceEntries = faceEntryList;
+
+ ostringstream msg;
+ msg << "Enforced vertex: \n"
+ << "Name: " << enfVertex->name << "\n";
+ if (coords->length())
+ 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;
+ }
+ mapElement->enfVertexList = enfVertexList;
+
+ resultMap[i] = mapElement;
+
+ }
+ return resultMap._retn();
+}
+
+/**
+ * Returns the list of all enforced vertices
+ * @return a list of enforced vertices
+ *
+ */
+BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices() {
MESSAGE("IDL: GetAllEnforcedVertices()");
ASSERT(myBaseImpl);
- BLSURFPlugin::TEntryEnfVertexListMap_var resultMap = new BLSURFPlugin::TEntryEnfVertexListMap();
- const ::BLSURFPlugin_Hypothesis::TEntryEnfVertexListMap entryEnfVertexListMap = this->GetImpl()->_GetAllEnforcedVertices();
- resultMap->length(entryEnfVertexListMap.size());
- MESSAGE("Enforced Vertex map size is " << entryEnfVertexListMap.size());
-
- ::BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList;
- ::BLSURFPlugin_Hypothesis::TEntryEnfVertexListMap::const_iterator evmIt = entryEnfVertexListMap.begin();
- for ( int i = 0 ; evmIt != entryEnfVertexListMap.end(); ++evmIt, ++i ) {
- std::string entry = evmIt->first;
- MESSAGE("Entry: " << entry);
- enfVertexList = evmIt->second;
+ 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
+ enfVertex->name = CORBA::string_dup(currentEnfVertex->name.c_str());
+ // Geom entry
+ enfVertex->geomEntry = CORBA::string_dup(currentEnfVertex->geomEntry.c_str());
+ // Coords
+ BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
+ coords->length(currentEnfVertex->coords.size());
+ for (int ind = 0; ind < coords->length(); ind++)
+ coords[ind] = currentEnfVertex->coords[ind];
+ enfVertex->coords = coords;
+ // Group name
+ enfVertex->grpName = CORBA::string_dup(currentEnfVertex->grpName.c_str());
+ // Face entry list
+ BLSURFPlugin::TEntryList_var faceEntryList = new BLSURFPlugin::TEntryList();
+ faceEntryList->length(currentEnfVertex->faceEntries.size());
+ ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_entry = currentEnfVertex->faceEntries.begin();
+ for (int ind = 0; it_entry != currentEnfVertex->faceEntries.end();++it_entry, ++ind)
+ faceEntryList[ind] = CORBA::string_dup((*it_entry).c_str());
+ enfVertex->faceEntries = faceEntryList;
+
+ ostringstream msg;
+ msg << "Enforced vertex: \n"
+ << "Name: " << enfVertex->name << "\n";
+ if (coords->length())
+ 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;
+ }
+ return resultMap._retn();
- BLSURFPlugin::TEntryEnfVertexListMapElement_var mapElement = new BLSURFPlugin::TEntryEnfVertexListMapElement();
+}
- BLSURFPlugin::TEnfVertexList_var vertexList = new BLSURFPlugin::TEnfVertexList();
- vertexList->length(enfVertexList.size());
- MESSAGE("Number of enforced vertices: " << enfVertexList.size());
+/**
+ * Returns the list of enforced vertices coords for a given Face entry.
+ * They are the coords of the "manual" enforced vertices.
+ * @return A map of Face entry / List of enforced vertices coords
+ *
+ */
+BLSURFPlugin::TFaceEntryCoordsListMap* BLSURFPlugin_Hypothesis_i::GetAllCoordsByFace() {
+ MESSAGE("IDL: GetAllCoordsByFace()");
+ ASSERT(myBaseImpl);
- ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = enfVertexList.begin();
- for ( int j = 0 ; evlIt != enfVertexList.end(); ++evlIt, ++j ) {
- MESSAGE("Enforced Vertex #" << j);
- BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
- enfVertex->length(3);
- enfVertex[0] = (*evlIt)[0];
- enfVertex[1] = (*evlIt)[1];
- enfVertex[2] = (*evlIt)[2];
- vertexList[j] = enfVertex;
- MESSAGE("Enforced vertex: " << enfVertex[0] << ", " << enfVertex[1] << ", " << enfVertex[2]);
+ 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) {
+ BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
+ coords->length((*it_coords).size());
+ for (int 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;
- mapElement->entry = CORBA::string_dup(entry.c_str());
- mapElement->vertexList = vertexList;
+ resultMap[i] = mapElement;
+
+ }
+ return resultMap._retn();
+}
+
+/**
+ * Returns a map of enforced vertices coords / enforced vertex.
+ * 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();
+ 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();
+ coords->length(it_coords->first.size());
+ for (int 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
+ enfVertex->name = CORBA::string_dup(currentEnfVertex->name.c_str());
+ // Geom entry
+ enfVertex->geomEntry = CORBA::string_dup(currentEnfVertex->geomEntry.c_str());
+ // Coords
+ BLSURFPlugin::TEnfVertexCoords_var coords2 = new BLSURFPlugin::TEnfVertexCoords();
+ coords2->length(currentEnfVertex->coords.size());
+ for (int ind=0;ind<coords2->length();ind++)
+ coords2[ind] = currentEnfVertex->coords[ind];
+ enfVertex->coords = coords2;
+ // Group name
+ enfVertex->grpName = CORBA::string_dup(currentEnfVertex->grpName.c_str());
+ // Face entry list
+ BLSURFPlugin::TEntryList_var faceEntryList = new BLSURFPlugin::TEntryList();
+ faceEntryList->length(currentEnfVertex->faceEntries.size());
+ ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_entry = currentEnfVertex->faceEntries.begin();
+ for (int ind = 0; it_entry != currentEnfVertex->faceEntries.end();++it_entry, ++ind)
+ faceEntryList[ind] = CORBA::string_dup((*it_entry).c_str());
+ enfVertex->faceEntries = faceEntryList;
+
+ mapElement->enfVertex = enfVertex;
+ ostringstream msg;
+ msg << "Enforced vertex: \n"
+ << "Name: " << enfVertex->name << "\n";
+ if (coords->length())
+ 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;
+ }
+ return resultMap._retn();
+}
+
+/**
+ * Returns the list of enforced vertices entries for a given Face entry.
+ * They are the geom entries of the enforced vertices based on geom shape (vertex, compound, group).
+ * @return A map of Face entry / List of enforced vertices geom entries
+ *
+ */
+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();
+ 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();
+ 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;
resultMap[i] = mapElement;
return resultMap._retn();
}
-void BLSURFPlugin_Hypothesis_i::ClearAllEnforcedVertices()
-{
+/**
+ * Returns a map of enforced vertices geom entry / enforced vertex.
+ * 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();
+ 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
+ enfVertex->name = CORBA::string_dup(currentEnfVertex->name.c_str());
+ // Geom entry
+ enfVertex->geomEntry = CORBA::string_dup(currentEnfVertex->geomEntry.c_str());
+ // Coords
+ BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
+ coords->length(currentEnfVertex->coords.size());
+ for (int ind=0;ind<coords->length();ind++)
+ coords[ind] = currentEnfVertex->coords[ind];
+ enfVertex->coords = coords;
+ // Group name
+ enfVertex->grpName = CORBA::string_dup(currentEnfVertex->grpName.c_str());
+ // Face entry list
+ BLSURFPlugin::TEntryList_var faceEntryList = new BLSURFPlugin::TEntryList();
+ faceEntryList->length(currentEnfVertex->faceEntries.size());
+ ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_entry = currentEnfVertex->faceEntries.begin();
+ for (int ind = 0; it_entry != currentEnfVertex->faceEntries.end();++it_entry, ++ind)
+ faceEntryList[ind] = CORBA::string_dup((*it_entry).c_str());
+ enfVertex->faceEntries = faceEntryList;
+
+ ostringstream msg;
+ msg << "Enforced vertex: \n"
+ << "Name: " << enfVertex->name << "\n";
+ if (coords->length())
+ 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;
+ }
+ return resultMap._retn();
+}
+
+/**
+ * Erase all enforced vertices
+ */
+void BLSURFPlugin_Hypothesis_i::ClearAllEnforcedVertices() {
ASSERT(myBaseImpl);
this->GetImpl()->ClearAllEnforcedVertices();
SMESH::TPythonDump() << _this() << ".ClearAllEnforcedVertices()";
}
/*!
- * Set/get/unset an enforced vertex on geom object
- */
-void BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr GeomObj, CORBA::Double x, CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception)
-{
+ * Set/get/unset an enforced vertex on face
+ */
+bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
+ CORBA::Double z) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- // TODO check that GeomObj is a face => in engine ?
- // TODO Affecter un nom de groupe vide
- string entry = GeomObj->GetStudyEntry();
- MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : SetEnforcedVertex ( "<< entry << ", " << x << ", " << y << ", " << z << ")");
- try {
- SetEnforcedVertexEntry(entry.c_str(), x, y, z);
+
+ 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_ptr theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
+ if (!theSFace->_is_nil())
+ theFaceEntry = theSFace->GetID();
}
- catch (SALOME_Exception& ex) {
+ 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) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
}
/*!
- * Set/get/unset an enforced vertex on geom object with group name
- */
-/* TODO GROUPS
-void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr GeomObj,
- CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName)
- throw (SALOME::SALOME_Exception)
-{
+ * 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) {
ASSERT(myBaseImpl);
- // TODO check that GeomObj is a face => in engine ?
- string entry = GeomObj->GetStudyEntry();
- MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : SetEnforcedVertexWithGroup ( "<< entry << ", " << x << ", " << y << ", " << z << ", " << groupName <<")");
- try {
- SetEnforcedVertexEntryWithGroup(entry.c_str(), x, y, z, groupName);
+
+ 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_ptr theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
+ if (!theSFace->_is_nil())
+ theFaceEntry = theSFace->GetID();
}
- catch (SALOME_Exception& ex) {
+ 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) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
}
-*/
-BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEOM::GEOM_Object_ptr GeomObj)
- throw (SALOME::SALOME_Exception)
-{
+
+/*!
+ * 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) {
ASSERT(myBaseImpl);
- string entry = GeomObj->GetStudyEntry();
- MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : GetEnforcedVertexList ( "<< entry << ")");
- try {
- return GetEnforcedVerticesEntry(entry.c_str());
+
+ 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);
}
- catch (SALOME_Exception& ex) {
+
+ // GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
+ // GEOM::GEOM_IMeasureOperations_var measureOp = geomGen->GetIMeasureOperations(this->GetImpl()->GetStudyId());
+ // if (CORBA::is_nil(measureOp))
+ // return false;
+ //
+ // CORBA::Double x, y, z;
+ // x = y = z = 0.;
+ // measureOp->PointCoordinates(theVertex, x, y, z);
+
+ string theFaceEntry = theFace->GetStudyEntry();
+ string theVertexEntry = theVertex->GetStudyEntry();
+
+ GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
+ SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen();
+ string aName;
+
+ if (theFaceEntry.empty()) {
+ if (theFace->GetShapeType() == GEOM::FACE)
+ aName = "Face_";
+ if (theFace->GetShapeType() == GEOM::COMPOUND)
+ aName = "Compound_";
+ aName += theFace->GetEntry();
+ SALOMEDS::SObject_ptr 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 );
+
+ if (theVertexEntry.empty()) {
+ if (theVertex->GetShapeType() == GEOM::VERTEX)
+ aName = "Vertex_";
+ if (theVertex->GetShapeType() == GEOM::COMPOUND)
+ aName = "Compound_";
+ aName += theVertex->GetEntry();
+ SALOMEDS::SObject_ptr theSVertex = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theVertex, aName.c_str());
+ if (!theSVertex->_is_nil())
+ theVertexEntry = theSVertex->GetID();
+ }
+ if (theVertexEntry.empty())
+ 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) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
}
-
-void BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr GeomObj, CORBA::Double x, CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception)
+/*!
+ * 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)
{
ASSERT(myBaseImpl);
- string entry = GeomObj->GetStudyEntry();
- MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : UnsetEnforcedVertex ( "<< entry << ", " << x << ", " << y << ", " << z << ")");
- try {
- UnsetEnforcedVertexEntry(entry.c_str(), x, y, z);
+ 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_ptr theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
+ if (!theSFace->_is_nil())
+ theFaceEntry = theSFace->GetID();
}
- catch (SALOME_Exception& ex) {
+ 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) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
}
-
-void BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr GeomObj)
- throw (SALOME::SALOME_Exception)
+/*!
+ * Set an enforced vertex with name and group name on face
+ */
+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)
{
- ASSERT(myBaseImpl);;
- string entry = GeomObj->GetStudyEntry();
- MESSAGE("IDL : GetName : " << GeomObj->GetName());
- MESSAGE("IDL : UnsetEnforcedVertices ( "<< entry << ")");
+ ASSERT(myBaseImpl);
- try {
- UnsetEnforcedVerticesEntry(entry.c_str());
+ 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_ptr theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
+ if (!theSFace->_is_nil())
+ theFaceEntry = theSFace->GetID();
}
- catch (SALOME_Exception& ex) {
+ 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) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
}
-
/*!
- * Set/get/unset an enforced vertex on geom object given by entry
- */
-void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexEntry(const char* entry, double x, double y, double z)
- throw (SALOME::SALOME_Exception)
+ * 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)
{
ASSERT(myBaseImpl);
- MESSAGE("IDL : SETENFORCEDVERTEX START - ENTRY: " << entry << " VERTEX: " << x << " " << y << " " << z);
- bool newValue = false;
-
- try {
- ::BLSURFPlugin_Hypothesis::TEnfVertexList vertexList = this->GetImpl()->GetEnforcedVertices(entry);
- ::BLSURFPlugin_Hypothesis::TEnfVertex vertex;
- vertex.push_back(x);
- vertex.push_back(y);
- vertex.push_back(z);
- if (vertexList.find(vertex) == vertexList.end()) {
- MESSAGE("Vertex not found: add it in vertexList")
- newValue = true;
- }
- else
- MESSAGE("Vertex already found")
+
+ 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);
}
- catch (const std::invalid_argument& ex) {
- // no enforced vertex for entry
- MESSAGE("Entry not found : add it to the list")
- newValue = true;
+
+ 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);
}
- catch (SALOME_Exception& ex) {
- THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+
+ string theFaceEntry = theFace->GetStudyEntry();
+ string theVertexEntry = theVertex->GetStudyEntry();
+
+ GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
+ SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen();
+ string aName;
+
+ if (theFaceEntry.empty()) {
+ if (theFace->GetShapeType() == GEOM::FACE)
+ aName = "Face_";
+ if (theFace->GetShapeType() == GEOM::COMPOUND)
+ aName = "Compound_";
+ aName += theFace->GetEntry();
+ SALOMEDS::SObject_ptr 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 );
- if ( newValue ) {
- this->GetImpl()->SetEnforcedVertex(entry, x, y, z);
- SMESH::TPythonDump() << _this() << ".SetEnforcedVertex("
- << entry << ", "
- << x << ", "
- << y << ", "
- << z << ")";
+ if (theVertexEntry.empty()) {
+ if (theVertex->GetShapeType() == GEOM::VERTEX)
+ aName = "Vertex_";
+ if (theVertex->GetShapeType() == GEOM::COMPOUND)
+ aName = "Compound_";
+ aName += theVertex->GetEntry();
+ SALOMEDS::SObject_ptr theSVertex = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theVertex, aName.c_str());
+ if (!theSVertex->_is_nil())
+ theVertexEntry = theSVertex->GetID();
+ }
+ if (theVertexEntry.empty())
+ 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) {
+ THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- MESSAGE("IDL : SETENFORCEDVERTEX END - ENTRY: " << entry);
}
/*!
- * Set/get/unset an enforced vertex on geom object given by entry
- */
-/* TODO GROUPS
-void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexEntryWithGroup(const char* entry,
- double x, double y, double z, const char* groupName)
- throw (SALOME::SALOME_Exception)
-{
+ * Get the list of all enforced vertices
+ */
+BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEOM::GEOM_Object_ptr theFace)
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- MESSAGE("IDL : SETENFORCEDVERTEXWITHGROUP START - ENTRY: " << entry << " VERTEX: "
- << x << " " << y << " " << z << " group name: " << groupName);
- bool newValue = false;
- bool newGroupName = false;
- try {
- ::BLSURFPlugin_Hypothesis::TEnfVertexList vertexList = this->GetImpl()->GetEnforcedVertices(entry);
- ::BLSURFPlugin_Hypothesis::TEnfVertex vertex;
- vertex.push_back(x);
- vertex.push_back(y);
- vertex.push_back(z);
- if (vertexList.find(vertex) == vertexList.end()) {
- MESSAGE("Vertex not found: add it in vertexList");
- newValue = true;
- }
- else {
- MESSAGE("Vertex already found");
- std::string oldGroupName = this->GetImpl()->GetEnforcedVertexGroupName(x,y,z);
- if (strcmp(oldGroupName.c_str(),groupName)!=0)
- newGroupName = true;
- }
+
+ 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);
}
- catch (const std::invalid_argument& ex) {
- // no enforced vertex for entry
- MESSAGE("Entry not found : add it to the list");
- newValue = true;
+
+ 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_ptr theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
+ if (!theSFace->_is_nil())
+ theFaceEntry = theSFace->GetID();
}
- catch (SALOME_Exception& ex) {
+ if (theFaceEntry.empty())
+ THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
+
+ MESSAGE("IDL : GetName : " << theFace->GetName());
+ MESSAGE("IDL : GetEnforcedVertexList ( "<< theFaceEntry << ")");
+ try {
+ return GetEnforcedVerticesEntry(theFaceEntry.c_str());
+ } catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
+}
+
+bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
+ 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);
+ }
+
+ string theFaceEntry = theFace->GetStudyEntry();
- if ( newValue ) {
- this->GetImpl()->SetEnforcedVertex(entry, x, y, z, groupName);
- SMESH::TPythonDump() << _this() << ".SetEnforcedVertexWithGroup("
- << entry << ", "
- << x << ", "
- << y << ", "
- << z << ", '"
- << groupName << "')";
+ 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_ptr theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
+ if (!theSFace->_is_nil())
+ theFaceEntry = theSFace->GetID();
}
- else {
- if (newGroupName) {
- this->GetImpl()->SetEnforcedVertexGroupName(x, y, z, groupName);
- SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGroupName("
- << x << ", "
- << y << ", "
- << z << ", '"
- << groupName << "')";
- }
+ 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);
+ } catch (SALOME_Exception& ex) {
+ THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- MESSAGE("IDL : SETENFORCEDVERTEXWITHGROUP END - ENTRY: " << entry);
}
-*/
-/*
-void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexListEntry(const char* entry, BLSURFPlugin::TEnfVertexList& vertexList)
- throw (SALOME::SALOME_Exception)
-{
- ASSERT(myBaseImpl);
-}
-*/
-BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntry(const char* entry)
- throw (SALOME::SALOME_Exception)
-{
+bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : GETENFORCEDVERTICES START ENTRY : " << entry);
+
+ 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);
+ }
+
+ // GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
+ // GEOM::GEOM_IMeasureOperations_var measureOp = geomGen->GetIMeasureOperations(this->GetImpl()->GetStudyId());
+ // if (CORBA::is_nil(measureOp))
+ // return false;
+ //
+ // CORBA::Double x, y, z;
+ // x = y = z = 0.;
+ // measureOp->PointCoordinates(theVertex, x, y, z);
+
+ std::string theFaceEntry = theFace->GetStudyEntry();
+ std::string theVertexEntry = theVertex->GetStudyEntry();
- try {
- BLSURFPlugin::TEnfVertexList_var vertexList = new BLSURFPlugin::TEnfVertexList();
- ::BLSURFPlugin_Hypothesis::TEnfVertexList _vList = this->GetImpl()->GetEnforcedVertices(entry);
- vertexList->length(_vList.size());
- MESSAGE("Number of enforced vertices: " << _vList.size());
- ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = _vList.begin();
- for ( int i = 0; evlIt != _vList.end() ; ++evlIt, ++i ) {
- BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
- enfVertex->length(3);
- MESSAGE("Enforced vertex #" << i << ": "<< (*evlIt)[0] << ", " << (*evlIt)[1] << ", " << (*evlIt)[2]);
- enfVertex[0] = (*evlIt)[0];
- enfVertex[1] = (*evlIt)[1];
- enfVertex[2] = (*evlIt)[2];
- vertexList[i] = enfVertex;
- }
- return vertexList._retn();
+ GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
+ SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen();
+ string aName;
+
+ if (theFaceEntry.empty()) {
+ if (theFace->GetShapeType() == GEOM::FACE)
+ aName = "Face_";
+ if (theFace->GetShapeType() == GEOM::COMPOUND)
+ aName = "Compound_";
+ aName += theFace->GetEntry();
+ SALOMEDS::SObject_ptr theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
+ if (!theSFace->_is_nil())
+ theFaceEntry = theSFace->GetID();
}
- catch (const std::invalid_argument& ex) {
- SALOME::ExceptionStruct ExDescription;
- ExDescription.text = ex.what();
- ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntry(entry)";
- ExDescription.lineNumber = 1048;
- throw SALOME::SALOME_Exception(ExDescription);
+ if (theFaceEntry.empty())
+ THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
+
+ if (theVertexEntry.empty()) {
+ if (theVertex->GetShapeType() == GEOM::VERTEX)
+ aName = "Vertex_";
+ if (theVertex->GetShapeType() == GEOM::COMPOUND)
+ aName = "Compound_";
+ aName += theVertex->GetEntry();
+ SALOMEDS::SObject_ptr theSVertex = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theVertex, aName.c_str());
+ if (!theSVertex->_is_nil())
+ theVertexEntry = theSVertex->GetID();
}
- catch(const std::exception& ex) {
+ 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());
+ } catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
-
- MESSAGE("ENGINE : GETENFORCEDVERTICES END ENTRY : " << entry);
}
-
-void BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* entry, CORBA::Double x, CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception)
-{
+bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : UNSETENFORCEDVERTEX START ENTRY : " << entry);
-
- try {
- this->GetImpl()->ClearEnforcedVertex(entry, x, y, z);
- SMESH::TPythonDump() << _this() << ".UnsetEnforcedVertex("
- << entry << ", "
- << x << ", "
- << y << ", "
- << z << ")";
+
+ 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);
}
- catch (const std::invalid_argument& ex) {
- SALOME::ExceptionStruct ExDescription;
- ExDescription.text = ex.what();
- ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(entry,x,y,z)";
- ExDescription.lineNumber = 1086;
- throw SALOME::SALOME_Exception(ExDescription);
+
+ 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_ptr theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str());
+ if (!theSFace->_is_nil())
+ theFaceEntry = theSFace->GetID();
}
- catch(const std::exception& ex) {
+ 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());
+ } catch (SALOME_Exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
-
- MESSAGE("ENGINE : UNSETENFORCEDVERTEX END ENTRY : " << entry);
}
-/*
-void BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexListEntry(const char* entry, BLSURFPlugin::TEnfVertexList& vertexList)
- throw (SALOME::SALOME_Exception)
-{
+
+/*!
+ * Set/get/unset an enforced vertex on geom object given by entry
+ */
+bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x, CORBA::Double y,
+ CORBA::Double z, const char* theVertexName, const char* theVertexEntry, const char* theGroupName)
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
+ MESSAGE("IDL : SetEnforcedVertexEntry(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ", \"" << theVertexName << "\", \"" << theVertexEntry << "\", \"" << theGroupName << "\")");
+ bool newValue = false;
+
+ if (string(theVertexEntry).empty()) {
+ try {
+ ::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList coordsList =
+ this->GetImpl()->GetEnfVertexCoordsList(theFaceEntry);
+ ::BLSURFPlugin_Hypothesis::TEnfVertexCoords coords;
+ coords.push_back(x);
+ coords.push_back(y);
+ coords.push_back(z);
+ if (coordsList.find(coords) == coordsList.end()) {
+ MESSAGE("Coords not found: add it in coordsList");
+ newValue = true;
+ } else {
+ MESSAGE("Coords already found, compare names");
+ ::BLSURFPlugin_Hypothesis::TEnfVertex *enfVertex = this->GetImpl()->GetEnfVertex(coords);
+ if ((enfVertex->name != theVertexName) || (enfVertex->grpName != theGroupName)) {
+ MESSAGE("The names are different: update");
+// this->GetImpl()->ClearEnforcedVertex(theFaceEntry, x, y, z);
+ newValue = true;
+ }
+ else {
+ MESSAGE("The names are identical");
+ }
+ }
+ } catch (const std::invalid_argument& ex) {
+ // no enforced vertex for entry
+ MESSAGE("Face entry not found : add it to the list");
+ newValue = true;
+ }
+ if (newValue)
+ if (string(theVertexName).empty())
+ if (string(theGroupName).empty())
+ SMESH::TPythonDump() << _this() << ".SetEnforcedVertex(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ")";
+ else
+ SMESH::TPythonDump() << _this() << ".SetEnforcedVertexWithGroup(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ", \"" << theGroupName << "\")";
+ else
+ if (string(theGroupName).empty())
+ SMESH::TPythonDump() << _this() << ".SetEnforcedVertexNamed(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ", \"" << theVertexName << "\")";
+ else
+ SMESH::TPythonDump() << _this() << ".SetEnforcedVertexNamedWithGroup(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ", \""
+ << theVertexName << "\", \"" << theGroupName << "\")";
+ } else {
+ try {
+ ::BLSURFPlugin_Hypothesis::TEntryList enfVertexEntryList = this->GetImpl()->GetEnfVertexEntryList(theFaceEntry);
+ ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it = enfVertexEntryList.find(theVertexEntry);
+ if ( it == enfVertexEntryList.end()) {
+ MESSAGE("Geom entry not found: add it in enfVertexEntryList");
+ newValue = true;
+ }
+ else {
+ MESSAGE("Geom entry already found, compare names");
+ ::BLSURFPlugin_Hypothesis::TEnfVertex *enfVertex = this->GetImpl()->GetEnfVertex((*it));
+ if ((enfVertex->name != theVertexName) || (enfVertex->grpName != theGroupName)) {
+ MESSAGE("The names are different: update");
+// this->GetImpl()->ClearEnforcedVertex(theFaceEntry, x, y, z);
+ newValue = true;
+ }
+ else {
+ MESSAGE("The names are identical");
+ }
+ }
+ } catch (const std::invalid_argument& ex) {
+ // no enforced vertex for entry
+ MESSAGE("Face entry not found : add it to the list");
+ newValue = true;
+ }
+ if (newValue)
+ if (string(theGroupName).empty())
+ SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGeom(" << theFaceEntry << ", " << theVertexEntry << ")";
+ else
+ SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGeomWithGroup(" << theFaceEntry << ", " << theVertexEntry << ", \"" << theGroupName << "\")";
+ }
+
+ if (newValue)
+ this->GetImpl()->SetEnforcedVertex(theFaceEntry, theVertexName, theVertexEntry, theGroupName, x, y, z);
+
+ MESSAGE("IDL : SetEnforcedVertexEntry END");
+ return newValue;
}
-*/
-void BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(const char* entry)
- throw (SALOME::SALOME_Exception)
-{
+
+BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntry(const char* entry)
+ throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : UNSETENFORCEDVERTICES START ENTRY : " << entry);
-
+ MESSAGE("ENGINE : GetEnforcedVerticesEntry START ENTRY : " << entry);
+
try {
- this->GetImpl()->ClearEnforcedVertices(entry);
- SMESH::TPythonDump() << _this() << ".UnsetEnforcedVertices(" << entry << ")";
- }
- catch (const std::invalid_argument& ex) {
+ 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);
+
+ BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex();
+
+ // Name
+ enfVertex->name = CORBA::string_dup(_enfVertex->name.c_str());
+ // Geom Vertex Entry
+ enfVertex->geomEntry = CORBA::string_dup(_enfVertex->geomEntry.c_str());
+ // Coords
+ BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords();
+ coords->length(_enfVertex->coords.size());
+ for (int ind=0;ind<coords->length();ind++)
+ coords[ind] = _enfVertex->coords[ind];
+ enfVertex->coords = coords;
+ // Group Name
+ enfVertex->grpName = CORBA::string_dup(_enfVertex->grpName.c_str());
+ // Face entry list
+ BLSURFPlugin::TEntryList_var faceEntryList = new BLSURFPlugin::TEntryList();
+ faceEntryList->length(_enfVertex->faceEntries.size());
+ ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_entry = _enfVertex->faceEntries.begin();
+ for (int ind = 0; it_entry != _enfVertex->faceEntries.end();++it_entry, ++ind)
+ faceEntryList[ind] = CORBA::string_dup((*it_entry).c_str());
+ enfVertex->faceEntries = faceEntryList;
+
+ vertexList[i] = enfVertex;
+ }
+ MESSAGE("ENGINE : GetEnforcedVerticesEntry END ENTRY : " << entry);
+ return vertexList._retn();
+ } catch (const std::invalid_argument& ex) {
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(entry)";
- ExDescription.lineNumber = 1121;
+ ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntry(entry)";
+ ExDescription.lineNumber = 1385;
throw SALOME::SALOME_Exception(ExDescription);
- }
- catch(const std::exception& ex) {
+ } catch (const std::exception& ex) {
+ std::cout << "Exception: " << ex.what() << std::endl;
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
-
- MESSAGE("ENGINE : UNSETENFORCEDVERTICES END ENTRY : " << entry);
}
-/* TODO GROUPS
-char* BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception)
-{
+bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x, CORBA::Double y,
+ CORBA::Double z, const char* theVertexEntry) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : GetEnforcedVertexGroupName START ");
+ MESSAGE("IDL : UnsetEnforcedVertexEntry(" << theFaceEntry << "," << x << "," << y << "," << z << ", " << theVertexEntry << ")");
+
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) {
+ this->GetImpl()->ClearEnforcedVertex(theFaceEntry, x, y, z, theVertexEntry);
+
+ if (string(theVertexEntry).empty())
+ SMESH::TPythonDump() << _this() << ".UnsetEnforcedVertex(" << theFaceEntry << ", " << x << ", " << y << ", " << z
+ << ")";
+ else
+ SMESH::TPythonDump() << _this() << ".UnsetEnforcedVertexGeom(" << theFaceEntry << ", " << theVertexEntry << ")";
+
+ } catch (const std::invalid_argument& ex) {
+ return false;
+ } catch (const std::exception& ex) {
+ std::cout << "Exception: " << ex.what() << std::endl;
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- MESSAGE("ENGINE : GetEnforcedVertexGroupName END ");
- return 0;
+
+ MESSAGE("ENGINE : UnsetEnforcedVertexEntry END ENTRY : " << theFaceEntry);
+ return true;
}
+//bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntryWithPoint(const char* theFaceEntry, const char* theVertexEntry,
+// CORBA::Double x, CORBA::Double y, CORBA::Double z) throw (SALOME::SALOME_Exception) {
+// MESSAGE("IDL : UnsetEnforcedVertexEntryWithPoint START theFaceEntry=" << theFaceEntry << ", theVertexEntry=" << theVertexEntry);
+//
+// bool ret = false;
+//
+// try {
+// ret = _unsetEnfVertex(theFaceEntry, x, y, z);
+// } catch (SALOME_Exception& ex) {
+// THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+// }
+//
+// if (ret)
+// SMESH::TPythonDump() << _this() << ".UnsetEnforcedVertexWithPoint(" << theFaceEntry << ", " << theVertexEntry
+// << ")";
+//
+// MESSAGE("IDL : UnsetEnforcedVertexEntryWithPoint END ENTRY : " << theFaceEntry);
+// return ret;
+//}
-void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName)
- throw (SALOME::SALOME_Exception)
-{
+bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
- MESSAGE("ENGINE : SetEnforcedVertexGroupName START ");
+ MESSAGE("IDL : UnsetEnforcedVerticesEntry(" << theFaceEntry << ")");
+
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()->ClearEnforcedVertices(theFaceEntry);
+ SMESH::TPythonDump() << _this() << ".UnsetEnforcedVertices(" << theFaceEntry << ")";
+ } catch (const std::invalid_argument& ex) {
+ return false;
+ } catch (const std::exception& ex) {
THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
}
- SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGroupName("
- << x << ", " << y << ", " << z << ", '" << groupName << "' )";
-
- MESSAGE("ENGINE : SetEnforcedVertexGroupName END ");
+ MESSAGE("IDL : UnsetEnforcedVerticesEntry END ENTRY : " << theFaceEntry);
+ return true;
}
-*/
-///////////////////////
-
-
+/* 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) {
+ 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)
+ 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) {
+ THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
+ }
+
+ SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGroupName("
+ << x << ", " << y << ", " << z << ", '" << groupName << "' )";
+
+ MESSAGE("ENGINE : SetEnforcedVertexGroupName END ");
+ }
+ */
+///////////////////////
//=============================================================================
* Get implementation
*/
//=============================================================================
-::BLSURFPlugin_Hypothesis* BLSURFPlugin_Hypothesis_i::GetImpl()
-{
+::BLSURFPlugin_Hypothesis* BLSURFPlugin_Hypothesis_i::GetImpl() {
// MESSAGE("BLSURFPlugin_Hypothesis_i::GetImpl");
- return (::BLSURFPlugin_Hypothesis*)myBaseImpl;
+ return (::BLSURFPlugin_Hypothesis*) myBaseImpl;
}
//================================================================================
/*!
* \brief Verify whether hypothesis supports given entity type
- * \param type - dimension (see SMESH::Dimension enumeration)
- * \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
+ * \param type - dimension (see SMESH::Dimension enumeration)
+ * \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
*
* Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
*/
//================================================================================
-CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsDimSupported( SMESH::Dimension type )
-{
+CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsDimSupported(SMESH::Dimension type) {
return type == SMESH::DIM_2D;
}
// BLSURFPlugin parameters hypothesis
-class BLSURFPlugin_Hypothesis_i:
- public virtual POA_BLSURFPlugin::BLSURFPlugin_Hypothesis,
- public virtual SMESH_Hypothesis_i
-{
- public:
+class BLSURFPlugin_Hypothesis_i: public virtual POA_BLSURFPlugin::BLSURFPlugin_Hypothesis,
+ public virtual SMESH_Hypothesis_i {
+public:
// Constructor
- BLSURFPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
- int theStudyId,
- ::SMESH_Gen* theGenImpl);
+ BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr thePOA, int theStudyId, ::SMESH_Gen* theGenImpl);
// Destructor
virtual ~BLSURFPlugin_Hypothesis_i();
void SetVerbosity(CORBA::Short theVal) throw (SALOME::SALOME_Exception);
CORBA::Short GetVerbosity();
- void SetOptionValue(const char* optionName,
- const char* optionValue) throw (SALOME::SALOME_Exception);
+ void SetOptionValue(const char* optionName, const char* optionValue) throw (SALOME::SALOME_Exception);
char* GetOptionValue(const char* optionName) throw (SALOME::SALOME_Exception);
void UnsetOption(const char* optionName);
void SetOptionValues(const BLSURFPlugin::string_array& options) throw (SALOME::SALOME_Exception);
- void SetSizeMapEntry(const char* entry,const char* sizeMap ) throw (SALOME::SALOME_Exception);
-
- char* GetSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception);
+ void SetSizeMapEntry(const char* entry, const char* sizeMap) throw (SALOME::SALOME_Exception);
+
+ char* GetSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception);
void UnsetEntry(const char* entry);
void ClearSizeMaps();
-
void SetAttractor(GEOM::GEOM_Object_ptr GeomObj, const char* attractor);
void UnsetAttractor(GEOM::GEOM_Object_ptr GeomObj);
- void SetAttractorEntry(const char* entry,const char* attractor ) throw (SALOME::SALOME_Exception);
+ void SetAttractorEntry(const char* entry, const char* attractor) throw (SALOME::SALOME_Exception);
- char* GetAttractorEntry(const char* entry) throw (SALOME::SALOME_Exception);
+ char* GetAttractorEntry(const char* entry) throw (SALOME::SALOME_Exception);
BLSURFPlugin::string_array* GetAttractorEntries();
+ /*
+ void SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap);
-/*
- void SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap);
-
- void UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj);
+ void UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj);
- void SetCustomSizeMapEntry(const char* entry,const char* sizeMap ) throw (SALOME::SALOME_Exception);
+ void SetCustomSizeMapEntry(const char* entry,const char* sizeMap ) throw (SALOME::SALOME_Exception);
- char* GetCustomSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception);
+ char* GetCustomSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception);
- BLSURFPlugin::string_array* GetCustomSizeMapEntries();
-*/
+ BLSURFPlugin::string_array* GetCustomSizeMapEntries();
+ */
///////////////////////
// ENFORCED VERTEXES //
///////////////////////
-
- BLSURFPlugin::TEntryEnfVertexListMap* GetAllEnforcedVertices();
- void ClearAllEnforcedVertices();
+
+ BLSURFPlugin::TFaceEntryEnfVertexListMap* GetAllEnforcedVerticesByFace();
+ BLSURFPlugin::TEnfVertexList* GetAllEnforcedVertices();
+
+ BLSURFPlugin::TFaceEntryCoordsListMap* GetAllCoordsByFace();
+ BLSURFPlugin::TCoordsEnfVertexMap* GetAllEnforcedVerticesByCoords();
+
+ BLSURFPlugin::TFaceEntryEnfVertexEntryListMap* GetAllEnfVertexEntriesByFace();
+ BLSURFPlugin::TEnfVertexEntryEnfVertexMap* GetAllEnforcedVerticesByEnfVertexEntry();
+
+ void ClearAllEnforcedVertices();
/*!
- * Set/get/unset an enforced vertex on geom object
- */
- void SetEnforcedVertex(GEOM::GEOM_Object_ptr GeomObj, CORBA::Double x, CORBA::Double y, CORBA::Double z)
+ * Set/get/unset an enforced vertex on geom object
+ */
+ bool SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z)
throw (SALOME::SALOME_Exception);
- /* TODO GROUPS
- void SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr GeomObj,
- CORBA::Double x, CORBA::Double y, CORBA::Double z,
- const char* groupName)
+ bool SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexName)
throw (SALOME::SALOME_Exception);
- */
-// void SetEnforcedVertexList(GEOM::GEOM_Object_ptr GeomObj, const BLSURFPlugin::TEnfVertexList& vertexList)
-// throw (SALOME::SALOME_Exception);
-
- BLSURFPlugin::TEnfVertexList* GetEnforcedVertices(GEOM::GEOM_Object_ptr GeomObj)
+ bool SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
throw (SALOME::SALOME_Exception);
-
- void UnsetEnforcedVertex(GEOM::GEOM_Object_ptr GeomObj, CORBA::Double x, CORBA::Double y, CORBA::Double z)
+ bool SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
throw (SALOME::SALOME_Exception);
-
-// void UnsetEnforcedVertexList(GEOM::GEOM_Object_ptr GeomObj, BLSURFPlugin::TEnfVertexList& vertexList)
-// throw (SALOME::SALOME_Exception);
-
- void UnsetEnforcedVertices(GEOM::GEOM_Object_ptr GeomObj)
+ bool 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);
-
- /*!
- * Set/get/unset an enforced vertex on geom object given by entry
- */
- void SetEnforcedVertexEntry(const char* entry, CORBA::Double x, CORBA::Double y, CORBA::Double z)
+ bool SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
throw (SALOME::SALOME_Exception);
- /* TODO GROUPS
- void SetEnforcedVertexEntryWithGroup(const char* entry, CORBA::Double x, CORBA::Double y, CORBA::Double z,
- const char* groupName)
- throw (SALOME::SALOME_Exception);
- */
-// void SetEnforcedVertexListEntry(const char* entry, BLSURFPlugin::TEnfVertexList& vertexList)
-// throw (SALOME::SALOME_Exception);
-
- BLSURFPlugin::TEnfVertexList* GetEnforcedVerticesEntry(const char* entry)
+
+ BLSURFPlugin::TEnfVertexList* GetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) throw (SALOME::SALOME_Exception);
+
+ bool UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z)
throw (SALOME::SALOME_Exception);
-
- void UnsetEnforcedVertexEntry(const char* entry, CORBA::Double x, CORBA::Double y, CORBA::Double z)
+ bool UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
throw (SALOME::SALOME_Exception);
-// void UnsetEnforcedVertexListEntry(const char* entry, BLSURFPlugin::TEnfVertexList& vertexList)
-// throw (SALOME::SALOME_Exception);
- void UnsetEnforcedVerticesEntry(const char* entry)
+ bool UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) throw (SALOME::SALOME_Exception);
+
+ /*!
+ * Set/get/unset an enforced vertex on geom object given by entry
+ */
+ bool SetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x = 0, CORBA::Double y = 0, CORBA::Double z = 0,
+ const char* theVertexName = "", const char* theVertexEntry = "", const char* theGroupName = "")
throw (SALOME::SALOME_Exception);
-
+
+ BLSURFPlugin::TEnfVertexList* GetEnforcedVerticesEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception);
+
+ bool UnsetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x, CORBA::Double y, CORBA::Double z,
+ const char* theVertexEntry = "") throw (SALOME::SALOME_Exception);
+ bool UnsetEnforcedVerticesEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception);
+
/*!
- * Set/get node group to an enforced vertex
- */
+ * Set/get node group to an enforced vertex
+ */
/* TODO GROUPS
- void SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z,
- const char* groupName)
- throw (SALOME::SALOME_Exception);
- char* GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception);
- */
+ void SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName) throw (SALOME::SALOME_Exception);
+ char* GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z) throw (SALOME::SALOME_Exception);
+ */
///////////////////////
// Get implementation
::BLSURFPlugin_Hypothesis* GetImpl();
// Verify whether hypothesis supports given entity type
- CORBA::Boolean IsDimSupported( SMESH::Dimension type );
+ CORBA::Boolean IsDimSupported(SMESH::Dimension type);
};
#endif
#include "BLSURFPluginGUI_HypothesisCreator.h"
// #include <DlgBlSurfHyp_Enforced.h>
+#include "GeometryGUI.h"
+
#include <SMESHGUI_Utils.h>
#include <SMESHGUI_HypothesesUtils.h>
#include <SMESHGUI_Dialog.h>
#include "SMESHGUI_SpinBox.h"
+#include "SMESH_NumberFilter.hxx"
#include <SUIT_Session.h>
#include <SUIT_MessageBox.h>
#include <SalomeApp_Application.h>
#include <SALOME_ListIO.hxx>
#include <SALOME_ListIteratorOfListIO.hxx>
+#include "SALOME_LifeCycleCORBA.hxx"
-#include <GEOM_Client.hxx>
#include <TopoDS_Shape.hxx>
#include <SMESH_Gen_i.hxx>
#include <boost/shared_ptr.hpp>
#include <boost/algorithm/string.hpp>
#include <structmember.h>
+#include <stdexcept>
#define WITH_SIZE_BOUNDARIES
SMP_NB_COLUMNS,
// Enforced vertices array columns
ENF_VER_NAME_COLUMN = 0,
- ENF_VER_ENTRY_COLUMN,
+ ENF_VER_FACE_ENTRY_COLUMN,
ENF_VER_X_COLUMN,
ENF_VER_Y_COLUMN,
ENF_VER_Z_COLUMN,
-// ENF_VER_GROUP_COLUMN,
+ ENF_VER_ENTRY_COLUMN,
+ ENF_VER_GROUP_COLUMN,
ENF_VER_NB_COLUMNS
};
// Enforced vertices inputs
enum {
-// ENF_VER_FACE = 0,
-// ENF_VER_VERTEX,
- ENF_VER_X_COORD = 0,
+ ENF_VER_FACE = 0,
+ ENF_VER_VERTEX,
+ ENF_VER_X_COORD,
ENF_VER_Y_COORD,
ENF_VER_Z_COORD,
-// ENF_VER_GROUP,
+ ENF_VER_GROUP,
ENF_VER_VERTEX_BTN,
ENF_VER_REMOVE_BTN,
// ENF_VER_SEPARATOR,
-// ENF_VER_GROUP_CHECK,
+ ENF_VER_GROUP_CHECK,
ENF_VER_NB_LINES
};
return Py_None;
}
-static PyMethodDef PyStdOut_methods[] = {
+static PyMethodDef PyStdOut_methods[] = {
{"write", (PyCFunction)PyStdOut_write, METH_VARARGS,
- PyDoc_STR("write(string) -> None")},
+ PyDoc_STR("write(string) -> None")},
{NULL, NULL} /* sentinel */
};
**************************************************/
-class QDoubleValidator;
-
//
// BEGIN EnforcedTreeWidgetDelegate
//
const QStyleOptionViewItem & option ,
const QModelIndex & index ) const
{
-// QLineEdit *editor = new QLineEdit(parent);
+ QModelIndex father = index.parent();
+ QString entry = father.child(index.row(), ENF_VER_ENTRY_COLUMN).data(Qt::EditRole).toString();
+
if (index.column() == ENF_VER_X_COLUMN || \
- index.column() == ENF_VER_Y_COLUMN || \
- index.column() == ENF_VER_Z_COLUMN)
+ index.column() == ENF_VER_Y_COLUMN || \
+ index.column() == ENF_VER_Z_COLUMN)
{
SMESHGUI_SpinBox *editor = new SMESHGUI_SpinBox(parent);
editor->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
+ editor->setReadOnly(!entry.isEmpty());
+ editor->setDisabled(!entry.isEmpty());
return editor;
}
-// editor->setValidator(new QDoubleValidator(parent));
else
{
QLineEdit *editor = new QLineEdit(parent);
+ if (index.column() != ENF_VER_GROUP_COLUMN) {
+ editor->setReadOnly(!entry.isEmpty());
+ editor->setDisabled(!entry.isEmpty());
+ }
return editor;
}
-// return editor;
}
void EnforcedTreeWidgetDelegate::setEditorData(QWidget *editor,
const QModelIndex &index) const
{
QString value = index.model()->data(index, Qt::EditRole).toString();
- if (index.column() == ENF_VER_X_COLUMN || \
- index.column() == ENF_VER_Y_COLUMN || \
- index.column() == ENF_VER_Z_COLUMN) {
+
+ if (index.column() == ENF_VER_X_COLUMN ||
+ index.column() == ENF_VER_Y_COLUMN ||
+ index.column() == ENF_VER_Z_COLUMN)
+ {
SMESHGUI_SpinBox *lineEdit = static_cast<SMESHGUI_SpinBox*>(editor);
lineEdit->setText(value);
-// lineEdit->editor()->setText(value);
}
else {
QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
void EnforcedTreeWidgetDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
const QModelIndex &index) const
{
-// QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
-
- if (index.column() == ENF_VER_X_COLUMN || \
- index.column() == ENF_VER_Y_COLUMN || \
- index.column() == ENF_VER_Z_COLUMN)
- {
+ QModelIndex parent = index.parent();
+ QString entry = parent.child(index.row(), ENF_VER_ENTRY_COLUMN).data(Qt::EditRole).toString();
+ if (index.column() == ENF_VER_X_COLUMN || index.column() == ENF_VER_Y_COLUMN || index.column() == ENF_VER_Z_COLUMN) {
SMESHGUI_SpinBox *lineEdit = static_cast<SMESHGUI_SpinBox*>(editor);
- if (! vertexExists(model, index, lineEdit->GetString())) {
+ if (entry.isEmpty() && !vertexExists(model, index, lineEdit->GetString()))
model->setData(index, lineEdit->GetValue(), Qt::EditRole);
- }
- }
- else if (index.column() == ENF_VER_NAME_COLUMN) {
+ } else if (index.column() == ENF_VER_NAME_COLUMN) {
QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
QString value = lineEdit->text();
- if (! vertexExists(model, index, value)) {
+ if (entry.isEmpty() && !vertexExists(model, index, value))
model->setData(index, value, Qt::EditRole);
- }
-// MESSAGE("Value " << value.toString().toStdString() << " was set at index(" << index.row() << "," << index.column() << ")");
- }
- /* TODO GROUPS
- else if (index.column() == ENF_VER_GROUP_COLUMN) {
+ } else if (index.column() == ENF_VER_ENTRY_COLUMN) {
+ QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
+ QString value = lineEdit->text();
+ if (! vertexExists(model, index, value))
+ model->setData(index, value, Qt::EditRole);
+ } else if (index.column() == ENF_VER_GROUP_COLUMN) {
QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
model->setData(index, lineEdit->text(), Qt::EditRole);
-// MESSAGE("Value " << value.toString().toStdString() << " was set at index(" << index.row() << "," << index.column() << ")");
}
- */
}
void EnforcedTreeWidgetDelegate::updateEditorGeometry(QWidget *editor,
QModelIndex parent = index.parent();
int row = index.row();
int col = index.column();
-
- if (parent.isValid()) {
+
+ if (parent.isValid() && !value.isEmpty()) {
if (col == ENF_VER_X_COLUMN || col == ENF_VER_Y_COLUMN || col == ENF_VER_Z_COLUMN) {
double x, y, z;
if (col == ENF_VER_X_COLUMN) {
x = parent.child(row, ENF_VER_X_COLUMN).data(Qt::EditRole).toDouble();
y = parent.child(row, ENF_VER_Y_COLUMN).data(Qt::EditRole).toDouble();
}
- // MESSAGE("Checking for existing vertex " << x << ", " << y << "," << z);
int nbChildren = model->rowCount(parent);
for (int i = 0 ; i < nbChildren ; i++) {
if (i != row) {
double childX = parent.child(i, ENF_VER_X_COLUMN).data(Qt::EditRole).toDouble();
double childY = parent.child(i, ENF_VER_Y_COLUMN).data(Qt::EditRole).toDouble();
double childZ = parent.child(i, ENF_VER_Z_COLUMN).data(Qt::EditRole).toDouble();
-// MESSAGE("Vertex: " << childX << ", " << childY << "," << childZ);
if ((childX == x) && (childY == y) && (childZ == z)) {
-// MESSAGE("Found !");
exists = true;
break;
}
}
}
}
- else if (index.column() == ENF_VER_NAME_COLUMN) {
+// else if (col == ENF_VER_ENTRY_COLUMN) {
+// // Compare entries if no coords (= selected geom)
+// xString = parent.child(row, ENF_VER_X_COLUMN).data(Qt::EditRole).toString();
+// if (xString.isEmpty) {
+// int nbChildren = model->rowCount(parent);
+// for (int i = 0 ; i < nbChildren ; i++) {
+// if (i != row) {
+// QString childName = parent.child(i, ENF_VER_ENTRY_COLUMN).data(Qt::EditRole).toString();
+// if (childName == value) {
+// exists = true;
+// break;
+// }
+// }
+// }
+// }
+// }
+ else if (col == ENF_VER_NAME_COLUMN) {
int nbChildren = model->rowCount(parent);
for (int i = 0 ; i < nbChildren ; i++) {
if (i != row) {
// END EnforcedTreeWidgetDelegate
//
+//
+// BEGIN BLSURFPluginGUI_ObjectReferenceParamWdg
+//
+//================================================================================
+
+// BLSURFPluginGUI_ObjectReferenceParamWdg::BLSURFPluginGUI_ObjectReferenceParamWdg
+// ( SUIT_SelectionFilter* f, QWidget* parent, bool multiSelection)
+// : StdMeshersGUI_ObjectReferenceParamWdg(f, parent, multiSelection)
+// {
+// init();
+// }
+//
+//
+// BLSURFPluginGUI_ObjectReferenceParamWdg::BLSURFPluginGUI_ObjectReferenceParamWdg
+// ( MeshObjectType objType, QWidget* parent, bool multiSelection )
+// : StdMeshersGUI_ObjectReferenceParamWdg( objType, parent, multiSelection )
+// {
+// init();
+// }
+//
+// BLSURFPluginGUI_ObjectReferenceParamWdg::~BLSURFPluginGUI_ObjectReferenceParamWdg()
+// {
+// if ( myFilter )
+// {
+// mySelectionMgr->removeFilter( myFilter );
+// delete myFilter;
+// }
+// }
+//
+// void BLSURFPluginGUI_ObjectReferenceParamWdg::init()
+// {
+// StdMeshersGUI_ObjectReferenceParamWdg::init();
+// disconnect( mySelButton, SIGNAL(clicked()), SLOT(activateSelection()));
+// connect( mySelButton, SIGNAL(toggled(bool)), SLOT(setActivationStatus(bool)));
+// }
+//
+// void BLSURFPluginGUI_ObjectReferenceParamWdg::setActivationStatus(bool status)
+// {
+// if (status)
+// activateSelection();
+// else
+// deactivateSelection();
+// }
+//
+// void BLSURFPluginGUI_ObjectReferenceParamWdg::activateSelectionOnly()
+// {
+// if ( !mySelectionActivated && mySelectionMgr )
+// {
+// mySelectionActivated = true;
+// mySelectionMgr->clearFilters();
+// if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+// aViewWindow->SetSelectionMode(ActorSelection);
+// if ( myFilter )
+// mySelectionMgr->installFilter( myFilter );
+// connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), SLOT(onSelectionDone()));
+// }
+// emit selectionActivated();
+// }
+//
+// void BLSURFPluginGUI_ObjectReferenceParamWdg::deactivateSelectionOnly()
+// {
+// mySelectionActivated = false;
+// disconnect(mySelectionMgr, 0, this, 0 );
+// mySelectionMgr->removeFilter( myFilter );
+// }
+//
+//
+// END BLSURFPluginGUI_ObjectReferenceParamWdg
+//
/**
* \brief {BLSURFPluginGUI_HypothesisCreator constructor}
PyRun_SimpleString("from math import *");
PyGILState_Release(gstate);
-
+
}
BLSURFPluginGUI_HypothesisCreator::~BLSURFPluginGUI_HypothesisCreator()
* */
GeomSelectionTools* BLSURFPluginGUI_HypothesisCreator::getGeomSelectionTool()
{
-// MESSAGE("BLSURFPluginGUI_HypothesisCreator::getGeomSelectionTool");
BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
_PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
-// MESSAGE("aStudy->StudyId(): " << aStudy->StudyId());
if (that->GeomToolSelected == NULL || that->GeomToolSelected->getMyStudy() != aStudy) {
-// MESSAGE("GeomToolSelected is created");
that->GeomToolSelected = new GeomSelectionTools(aStudy);
}
-// else
-// MESSAGE("GeomToolSelected already exists");
-// MESSAGE("that->GeomToolSelected->getMyStudy()->StudyId(): " << that->GeomToolSelected->getMyStudy()->StudyId());
return that->GeomToolSelected;
}
-namespace {
- inline bool isDouble( const QString& theText, const bool emptyOK=false ) {
- QString str = theText.trimmed();
- bool isOk = true;
- if ( !str.isEmpty() )
- str.toDouble(&isOk);
- else
- isOk = emptyOK;
- return isOk;
- }
+GEOM::GEOM_Gen_var BLSURFPluginGUI_HypothesisCreator::getGeomEngine()
+{
+ return GeometryGUI::GetGeomGen();
}
{
MESSAGE("BLSURFPluginGUI_HypothesisCreator::checkParams");
bool ok = true;
-// if ( !isDouble( myPhySize->text(), false )) {
-// if ( myPhySize->text().isEmpty() )
-// myPhySize->setText(tr("OBLIGATORY_VALUE"));
-// myPhySize->selectAll();
-// ok = false;
-// }
-// if ( !isDouble( myPhyMin->text(), true )) {
-// myPhyMin->selectAll();
-// ok = false;
-// }
-// if ( !isDouble( myPhyMax->text(), true )) {
-// myPhyMax->selectAll();
-// ok = false;
-// }
-// if ( !isDouble( myGeoMin->text(), true )) {
-// myGeoMin->selectAll();
-// ok = false;
-// }
-// if ( !isDouble( myGeoMin->text(), true )) {
-// myGeoMin->selectAll();
-// ok = false;
-// }
+
if ( ok )
{
myOptionTable->setFocus();
// Enforced vertices
// TODO
-
+
return ok;
}
QFrame* BLSURFPluginGUI_HypothesisCreator::buildFrame()
{
MESSAGE("BLSURFPluginGUI_HypothesisCreator::buildFrame");
-
+
QFrame* fr = new QFrame( 0 );
QVBoxLayout* lay = new QVBoxLayout( fr );
lay->setMargin( 5 );
#endif
myAllowQuadrangles = new QCheckBox( tr( "BLSURF_ALLOW_QUADRANGLES" ), myStdGroup );
myDecimesh = new QCheckBox( tr( "BLSURF_DECIMESH" ), myStdGroup );
-
+
// ADD WIDGETS (STANDARD TAB)
int row = 0;
if( isCreation() ) {
QPushButton* addBtn = new QPushButton( tr( "ADD_OPTION"), myAdvGroup );
addBtn->setMenu( new QMenu() );
QPushButton* rmBtn = new QPushButton( tr( "REMOVE_OPTION"), myAdvGroup );
-
-
+
+
// ADD WIDGETS (ADVANCED TAB)
anAdvLayout->addWidget( new QLabel( tr( "BLSURF_TOPOLOGY" ), myAdvGroup ), 0, 0, 1, 1 );
anAdvLayout->addWidget( myTopology, 0, 1, 1, 1 );
line2->setFrameShape(QFrame::HLine);
line2->setFrameShadow(QFrame::Sunken);
removeButton = new QPushButton(tr("BLSURF_SM_REMOVE"),mySmpGroup);
-
-
+
+
// ADD WIDGETS (SIZEMAP TAB)
anSmpLayout->addWidget(mySizeMapTable, SMP_POINT_BTN, 0, SMP_NB_LINES+1, 1);
// anSmpLayout->addWidget(addAttractorButton, SMP_ATTRACTOR_BTN, 1, 1, 1);
// Enforced vertices parameters
myEnfGroup = new QWidget();
QGridLayout* anEnfLayout = new QGridLayout(myEnfGroup);
-//
+//
// myEnforcedVertexWidget = new DlgBlSurfHyp_Enforced(myEnfGroup);
// anEnfLayout->addWidget(myEnforcedVertexWidget);
// MESSAGE("Creating DlgBlSurfHyp_Enforced widget instance");
// myEnforcedVertexWidget = new DlgBlSurfHyp_Enforced();
-
+
myEnforcedTreeWidget = new QTreeWidget(myEnfGroup);
myEnforcedTreeWidget->setColumnCount( ENF_VER_NB_COLUMNS );
myEnforcedTreeWidget->setSortingEnabled(true);
QStringList enforcedHeaders;
- enforcedHeaders << tr("BLSURF_ENF_VER_NAME_COLUMN") << tr("BLSURF_ENF_VER_ENTRY_COLUMN") << tr( "BLSURF_ENF_VER_X_COLUMN" )<< tr( "BLSURF_ENF_VER_Y_COLUMN" ) << tr( "BLSURF_ENF_VER_Z_COLUMN" );
- /* TODO GROUPS
- enforcedHeaders << tr("BLSURF_ENF_VER_NAME_COLUMN") << tr("BLSURF_ENF_VER_ENTRY_COLUMN") << tr( "BLSURF_ENF_VER_X_COLUMN" )<< tr( "BLSURF_ENF_VER_Y_COLUMN" ) << tr( "BLSURF_ENF_VER_Z_COLUMN" ) << tr( "BLSURF_ENF_VER_GROUP_COLUMN" );
- */
+ enforcedHeaders << tr("BLSURF_ENF_VER_NAME_COLUMN") << tr("BLSURF_ENF_VER_FACE_ENTRY_COLUMN")
+ << tr("BLSURF_ENF_VER_X_COLUMN")<< tr("BLSURF_ENF_VER_Y_COLUMN") << tr("BLSURF_ENF_VER_Z_COLUMN")
+ << tr("BLSURF_ENF_VER_ENTRY_COLUMN") << tr( "BLSURF_ENF_VER_GROUP_COLUMN" );
+
myEnforcedTreeWidget->setHeaderLabels(enforcedHeaders);
myEnforcedTreeWidget->setAlternatingRowColors(true);
myEnforcedTreeWidget->setUniformRowHeights(true);
myEnforcedTreeWidget->header()->setResizeMode(column,QHeaderView::Interactive);
myEnforcedTreeWidget->resizeColumnToContents(column);
}
+ myEnforcedTreeWidget->hideColumn(ENF_VER_FACE_ENTRY_COLUMN);
myEnforcedTreeWidget->hideColumn(ENF_VER_ENTRY_COLUMN);
myEnforcedTreeWidget->setItemDelegate(new EnforcedTreeWidgetDelegate());
-
- /* TODO FACE AND VERTEX SELECTION
- selectFaceButton = new QPushButton(myEnfGroup);
- QPixmap imageSel1(SUIT_Session::session()->resourceMgr()->loadPixmap( "BLSURFPlugin", tr( "BLSURF_ICON_SELECT")));
- selectFaceButton->setIcon(imageSel1);
- mySelectedFace = new QLineEdit(myEnfGroup);
- mySelectedFace->setReadOnly(true);
- mySelectedFace->setText(tr( "BLSURF_ENF_SELECT_FACE"));
- mySelectedFace->setStyleSheet("QLineEdit { color: grey }");
-
- selectVertexButton = new QPushButton(myEnfGroup);
- QPixmap imageSel2(SUIT_Session::session()->resourceMgr()->loadPixmap( "BLSURFPlugin", tr( "BLSURF_ICON_SELECT")));
- selectVertexButton->setIcon(imageSel2);
-
- mySelectedEnforcedVertex = new QLineEdit(myEnfGroup);
- mySelectedEnforcedVertex->setReadOnly(true);
- mySelectedEnforcedVertex->setText(tr( "BLSURF_ENF_SELECT_VERTEX"));
- mySelectedEnforcedVertex->setStyleSheet("QLineEdit { color: grey }");
- */
+// FACE AND VERTEX SELECTION
+ TColStd_MapOfInteger shapeTypes1, shapeTypes2;
+ shapeTypes1.Add( TopAbs_FACE );
+ shapeTypes1.Add( TopAbs_COMPOUND );
+ shapeTypes2.Add( TopAbs_VERTEX );
+ shapeTypes2.Add( TopAbs_COMPOUND );
+
+ SMESH_NumberFilter* faceFilter = new SMESH_NumberFilter("GEOM", TopAbs_FACE, 0, shapeTypes1);
+ myEnfFaceWdg = new StdMeshersGUI_ObjectReferenceParamWdg( faceFilter, 0, /*multiSel=*/true);
+ myEnfFaceWdg->SetDefaultText("Select Faces", "QLineEdit { color: grey }");
+
+ SMESH_NumberFilter* vertexFilter = new SMESH_NumberFilter("GEOM", TopAbs_SHAPE, 1, shapeTypes2);
+ myEnfVertexWdg = new StdMeshersGUI_ObjectReferenceParamWdg( vertexFilter, 0, /*multiSel=*/true);
+ myEnfVertexWdg->SetDefaultText("Select Vertices", "QLineEdit { color: grey }");
+
+ myEnfVertexWdg->AvoidSimultaneousSelection(myEnfFaceWdg);
+
QLabel* myXCoordLabel = new QLabel( tr( "BLSURF_ENF_VER_X_LABEL" ), myEnfGroup );
myXCoord = new SMESHGUI_SpinBox(myEnfGroup);
myXCoord->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
-
+
QLabel* myYCoordLabel = new QLabel( tr( "BLSURF_ENF_VER_Y_LABEL" ), myEnfGroup );
myYCoord = new SMESHGUI_SpinBox(myEnfGroup);
myYCoord->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
-
+
QLabel* myZCoordLabel = new QLabel( tr( "BLSURF_ENF_VER_Z_LABEL" ), myEnfGroup );
myZCoord = new SMESHGUI_SpinBox(myEnfGroup);
myZCoord->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
- /* TODO GROUPS
QLabel* myGroupNameLabel = new QLabel( tr( "BLSURF_ENF_VER_GROUP_LABEL" ), myEnfGroup );
myGroupName = new QLineEdit(myEnfGroup);
- */
-
+
addVertexButton = new QPushButton(tr("BLSURF_ENF_VER_VERTEX"),myEnfGroup);
// QFrame *line = new QFrame(myEnfGroup);
// line->setFrameShape(QFrame::HLine);
// line->setFrameShadow(QFrame::Sunken);
removeVertexButton = new QPushButton(tr("BLSURF_ENF_VER_REMOVE"),myEnfGroup);
- /* TODO GROUPS
// CheckBox for groups generation
makeGroupsCheck = new QGroupBox(tr("BLSURF_ENF_VER_GROUPS"), myEnfGroup);
makeGroupsCheck->setCheckable(true);
QGridLayout* aGroupLayout = new QGridLayout(makeGroupsCheck);
myGlobalGroupName = new QLineEdit(makeGroupsCheck);
aGroupLayout->addWidget(myGlobalGroupName);
- */
-
-
+
anEnfLayout->addWidget(myEnforcedTreeWidget, 0, 0, ENF_VER_NB_LINES+1, 1);
- /* TODO FACE AND VERTEX SELECTION
- anEnfLayout->addWidget(selectFaceButton, ENF_VER_FACE, 1, 1, 1);
- anEnfLayout->addWidget(mySelectedFace, ENF_VER_FACE, 2, 1, 1);
- anEnfLayout->addWidget(selectVertexButton, ENF_VER_VERTEX, 1, 1, 1);
- anEnfLayout->addWidget(mySelectedEnforcedVertex, ENF_VER_VERTEX, 2, 1, 1);
- */
- anEnfLayout->addWidget(myXCoordLabel, ENF_VER_X_COORD, 1, 1, 1);
- anEnfLayout->addWidget(myXCoord, ENF_VER_X_COORD, 2, 1, 1);
- anEnfLayout->addWidget(myYCoordLabel, ENF_VER_Y_COORD, 1, 1, 1);
- anEnfLayout->addWidget(myYCoord, ENF_VER_Y_COORD, 2, 1, 1);
- anEnfLayout->addWidget(myZCoordLabel, ENF_VER_Z_COORD, 1, 1, 1);
- anEnfLayout->addWidget(myZCoord, ENF_VER_Z_COORD, 2, 1, 1);
- /* TODO GROUPS
- anEnfLayout->addWidget(myGroupNameLabel, ENF_VER_GROUP, 1, 1, 1);
- anEnfLayout->addWidget(myGroupName, ENF_VER_GROUP, 2, 1, 1);
- */
- anEnfLayout->addWidget(addVertexButton, ENF_VER_VERTEX_BTN, 1, 1, 2);
- anEnfLayout->addWidget(removeVertexButton, ENF_VER_REMOVE_BTN, 1, 1, 2);
-// anEnfLayout->addWidget(line, ENF_VER_SEPARATOR, 1, 1, 2);
- /* TODO GROUPS
- anEnfLayout->addWidget(makeGroupsCheck, ENF_VER_GROUP_CHECK, 1, 1, 2);
- */
-
+ QGridLayout* anEnfLayout2 = new QGridLayout(myEnfGroup);
+// FACE AND VERTEX SELECTION
+ anEnfLayout2->addWidget(myEnfFaceWdg, ENF_VER_FACE, 0, 1, 2);
+ anEnfLayout2->addWidget(myEnfVertexWdg, ENF_VER_VERTEX, 0, 1, 2);
+
+ anEnfLayout2->addWidget(myXCoordLabel, ENF_VER_X_COORD, 0, 1, 1);
+ anEnfLayout2->addWidget(myXCoord, ENF_VER_X_COORD, 1, 1, 1);
+ anEnfLayout2->addWidget(myYCoordLabel, ENF_VER_Y_COORD, 0, 1, 1);
+ anEnfLayout2->addWidget(myYCoord, ENF_VER_Y_COORD, 1, 1, 1);
+ anEnfLayout2->addWidget(myZCoordLabel, ENF_VER_Z_COORD, 0, 1, 1);
+ anEnfLayout2->addWidget(myZCoord, ENF_VER_Z_COORD, 1, 1, 1);
+ anEnfLayout2->addWidget(myGroupNameLabel, ENF_VER_GROUP, 0, 1, 1);
+ anEnfLayout2->addWidget(myGroupName, ENF_VER_GROUP, 1, 1, 1);
+ anEnfLayout2->addWidget(addVertexButton, ENF_VER_VERTEX_BTN, 0, 1, 2);
+ anEnfLayout2->addWidget(removeVertexButton, ENF_VER_REMOVE_BTN, 0, 1, 2);
+// anEnfLayout->addWidget(line, ENF_VER_SEPARATOR, 0, 1, 2);
+ anEnfLayout2->addWidget(makeGroupsCheck, ENF_VER_GROUP_CHECK, 0, 1, 2);
+ anEnfLayout->addLayout(anEnfLayout2, 0,1,ENF_VER_NB_LINES+1,2);
+
// ---
tab->insertTab( STD_TAB, myStdGroup, tr( "SMESH_ARGUMENTS" ) );
tab->insertTab( ADV_TAB, myAdvGroup, tr( "BLSURF_ADV_ARGS" ) );
tab->insertTab( SMP_TAB, mySmpGroup, tr( "BLSURF_SIZE_MAP" ) );
tab->insertTab( ENF_TAB, myEnfGroup, tr( "BLSURF_ENF_VER" ) );
-// tab->insertTab( ENF_TAB, myEnforcedVertexWidget, tr( "BLSURF_ENF_VER" ) );
tab->setCurrentIndex( STD_TAB );
connect( mySizeMapTable, SIGNAL( cellChanged ( int, int )), this, SLOT( onSetSizeMap(int,int ) ) );
connect( myEnforcedTreeWidget,SIGNAL( itemClicked(QTreeWidgetItem *, int)), this, SLOT( synchronizeCoords() ) );
- connect( myEnforcedTreeWidget,SIGNAL( itemChanged(QTreeWidgetItem *, int)), this, SLOT( update(QTreeWidgetItem *, int) ) );
+ connect( myEnforcedTreeWidget,SIGNAL( itemChanged(QTreeWidgetItem *, int)), this, SLOT( updateEnforcedVertexValues(QTreeWidgetItem *, int) ) );
connect( myEnforcedTreeWidget,SIGNAL( itemSelectionChanged() ), this, SLOT( synchronizeCoords() ) );
connect( addVertexButton, SIGNAL( clicked()), this, SLOT( onAddEnforcedVertices() ) );
connect( removeVertexButton, SIGNAL( clicked()), this, SLOT( onRemoveEnforcedVertex() ) );
+ connect( myEnfVertexWdg, SIGNAL( contentModified()), this, SLOT( onSelectEnforcedVertex() ) );
+// connect( myEnfVertexWdg, SIGNAL( selectionActivated()), this, SLOT( onVertexSelectionActivated() ) );
+// connect( myEnfFaceWdg, SIGNAL( selectionActivated()), this, SLOT( onFaceSelectionActivated() ) );
+// connect(QApplication::instance(), SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(deactivateSelection(QWidget*, QWidget*)));
return fr;
}
-/** BLSURFPluginGUI_HypothesisCreator::update(item, column)
+/** BLSURFPluginGUI_HypothesisCreator::deactivateSelection(QWidget*, QWidget*)
+This method stop the selection of the widgets StdMeshersGUI_ObjectReferenceParamWdg
+*/
+void BLSURFPluginGUI_HypothesisCreator::deactivateSelection(QWidget* old, QWidget* now)
+{
+ if ((now == myXCoord) || (now == myYCoord) || (now == myZCoord)
+ || (now = myGroupName) || (now = makeGroupsCheck) || (now = myEnforcedTreeWidget)) {
+ BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
+ that->getGeomSelectionTool()->selectionMgr()->clearFilters();
+ myEnfFaceWdg->deactivateSelection();
+ myEnfVertexWdg->deactivateSelection();
+ }
+}
+
+/**
+ * This method resets the content of the X, Y, Z and GroupNAme widgets;
+**/
+void BLSURFPluginGUI_HypothesisCreator::clearEnforcedVertexWidgets()
+{
+ myXCoord->setCleared(true);
+ myYCoord->setCleared(true);
+ myZCoord->setCleared(true);
+ myXCoord->setText("");
+ myYCoord->setText("");
+ myZCoord->setText("");
+ myGroupName->setText("");
+}
+
+/** BLSURFPluginGUI_HypothesisCreator::updateEnforcedVertexValues(item, column)
This method updates the tooltip of a modified item. The QLineEdit widgets content
is synchronized with the coordinates of the enforced vertex clicked in the tree widget.
*/
-void BLSURFPluginGUI_HypothesisCreator::update(QTreeWidgetItem* item, int column) {
-// MESSAGE("BLSURFPluginGUI_HypothesisCreator::updateVertexList");
+void BLSURFPluginGUI_HypothesisCreator::updateEnforcedVertexValues(QTreeWidgetItem* item, int column) {
+// MESSAGE("BLSURFPluginGUI_HypothesisCreator::updateEnforcedVertexValues");
+ QVariant vertexName = item->data(ENF_VER_NAME_COLUMN, Qt::EditRole);
QVariant x = item->data(ENF_VER_X_COLUMN, Qt::EditRole);
- if (! x.isNull()) {
- QVariant y = item->data(ENF_VER_Y_COLUMN, Qt::EditRole);
- QVariant z = item->data(ENF_VER_Z_COLUMN, Qt::EditRole);
- QVariant vertexName = item->data(ENF_VER_NAME_COLUMN, Qt::EditRole);
- /* TODO GROUPS
- QString groupName = item->data(ENF_VER_GROUP_COLUMN, Qt::EditRole).toString();
- */
-
- QTreeWidgetItem* parent = item->parent();
- if (parent) {
+ QVariant y = item->data(ENF_VER_X_COLUMN, Qt::EditRole);
+ QVariant z = item->data(ENF_VER_X_COLUMN, Qt::EditRole);
+ QVariant entry = item->data(ENF_VER_ENTRY_COLUMN, Qt::EditRole);
+ QString groupName = item->data(ENF_VER_GROUP_COLUMN, Qt::EditRole).toString();
+ QTreeWidgetItem* parent = item->parent();
+
+ clearEnforcedVertexWidgets();
+
+ if (parent && (!x.isNull() || !entry.isNull())) {
QString shapeName = parent->data(ENF_VER_NAME_COLUMN, Qt::EditRole).toString();
QString toolTip = shapeName + QString(": ") + vertexName.toString();
- toolTip += QString("(") + x.toString();
- toolTip += QString(", ") + y.toString();
- toolTip += QString(", ") + z.toString();
- toolTip += QString(")");
+ if (entry.isNull()) {
+ toolTip += QString("(") + x.toString();
+ toolTip += QString(", ") + y.toString();
+ toolTip += QString(", ") + z.toString();
+ toolTip += QString(")");
+ }
+
+ if (!groupName.isEmpty())
+ toolTip += QString(" [") + groupName + QString("]");
+
item->setToolTip(ENF_VER_NAME_COLUMN,toolTip);
+
+ if (!x.isNull()) {
+ myXCoord->SetValue(x.toDouble());
+ myYCoord->SetValue(y.toDouble());
+ myZCoord->SetValue(z.toDouble());
+ }
+
+ if (!groupName.isEmpty())
+ myGroupName->setText(groupName);
+ }
+}
+
+void BLSURFPluginGUI_HypothesisCreator::onSelectEnforcedVertex() {
+ int nbSelEnfVertex = myEnfVertexWdg->NbObjects();
+ clearEnforcedVertexWidgets();
+ if (nbSelEnfVertex == 1)
+ {
+ if ( CORBA::is_nil( getGeomEngine() ) && !GeometryGUI::InitGeomGen() )
+ return ;
+
+ myEnfVertex = myEnfVertexWdg->GetObject< GEOM::GEOM_Object >(nbSelEnfVertex-1);
+ if (myEnfVertex->GetShapeType() == GEOM::VERTEX) {
+ BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
+ GEOM::GEOM_IMeasureOperations_var measureOp = getGeomEngine()->GetIMeasureOperations( that->getGeomSelectionTool()->getMyStudy()->StudyId() );
+ if (CORBA::is_nil(measureOp))
+ return;
+
+ CORBA::Double x,y,z;
+ measureOp->PointCoordinates (myEnfVertex, x, y, z);
+ if ( measureOp->IsDone() )
+ {
+ myXCoord->SetValue(x);
+ myYCoord->SetValue(y);
+ myZCoord->SetValue(z);
+ }
}
- myXCoord->SetValue(x.toDouble());
- myYCoord->SetValue(y.toDouble());
- myZCoord->SetValue(z.toDouble());
- /* TODO GROUPS
- myGroupName->setText(groupName);
- */
}
}
of the enforced vertex clicked in the tree widget.
*/
void BLSURFPluginGUI_HypothesisCreator::synchronizeCoords() {
-// MESSAGE("BLSURFPluginGUI_HypothesisCreator::synchronizeCoords");
+ clearEnforcedVertexWidgets();
QList<QTreeWidgetItem *> items = myEnforcedTreeWidget->selectedItems();
- if (! items.isEmpty()) {
- QTreeWidgetItem *item;
- for (int i=0 ; i < items.size() ; i++) {
- item = items[i];
+ if (! items.isEmpty() && items.size() == 1) {
+ QTreeWidgetItem *item = items[0];
+// for (int i=0 ; i < items.size() ; i++) {
+// item = items[i];
QVariant x = item->data(ENF_VER_X_COLUMN, Qt::EditRole);
- if (! x.isNull()) {
- QVariant y = item->data(ENF_VER_Y_COLUMN, Qt::EditRole);
- QVariant z = item->data(ENF_VER_Z_COLUMN, Qt::EditRole);
+ QVariant y = item->data(ENF_VER_Y_COLUMN, Qt::EditRole);
+ QVariant z = item->data(ENF_VER_Z_COLUMN, Qt::EditRole);
+ QVariant entry = item->data(ENF_VER_ENTRY_COLUMN, Qt::EditRole);
+ QVariant group = item->data(ENF_VER_GROUP_COLUMN, Qt::EditRole);
+ if (!x.isNull()/* && entry.isNull()*/) {
myXCoord->SetValue(x.toDouble());
myYCoord->SetValue(y.toDouble());
myZCoord->SetValue(z.toDouble());
- /* TODO GROUPS
- myGroupName->setText(item->data(ENF_VER_GROUP_COLUMN, Qt::EditRole).toString());
- */
- break;
+// break;
}
- }
+ if (!group.isNull() && (!x.isNull() || !entry.isNull()))
+ myGroupName->setText(group.toString());
+// }
}
}
/** BLSURFPluginGUI_HypothesisCreator::addEnforcedVertex(entry, shapeName, x, y, z)
This method adds an enforced vertex (x,y,z) to shapeName in the tree widget.
*/
-/* TODO GROUPS
-void BLSURFPluginGUI_HypothesisCreator::addEnforcedVertex(std::string entry, std::string shapeName,
- double x, double y, double z, std::string groupName) {
-*/
-void BLSURFPluginGUI_HypothesisCreator::addEnforcedVertex(std::string entry, std::string shapeName,
- double x, double y, double z) {
- // Find entry item
- QList<QTreeWidgetItem* > theItemList = myEnforcedTreeWidget->findItems(QString(entry.c_str()),Qt::MatchExactly,ENF_VER_ENTRY_COLUMN);
+void BLSURFPluginGUI_HypothesisCreator::addEnforcedVertex(std::string theFaceEntry, std::string theFaceName,
+ double x, double y, double z, std::string vertexName, std::string geomEntry, std::string groupName) {
+ // Find theFaceEntry item
+ QList<QTreeWidgetItem* > theItemList = myEnforcedTreeWidget->findItems(QString(theFaceEntry.c_str()),Qt::MatchExactly,ENF_VER_FACE_ENTRY_COLUMN);
QTreeWidgetItem* theItem;
if (theItemList.empty()) {
theItem = new QTreeWidgetItem();
- theItem->setData(ENF_VER_ENTRY_COLUMN, Qt::EditRole, QVariant(entry.c_str()));
- theItem->setData(ENF_VER_NAME_COLUMN, Qt::EditRole, QVariant(shapeName.c_str()));
- theItem->setToolTip(ENF_VER_NAME_COLUMN,QString(entry.c_str()));
+ theItem->setData(ENF_VER_FACE_ENTRY_COLUMN, Qt::EditRole, QVariant(theFaceEntry.c_str()));
+ theItem->setData(ENF_VER_NAME_COLUMN, Qt::EditRole, QVariant(theFaceName.c_str()));
+ theItem->setToolTip(ENF_VER_NAME_COLUMN,QString(theFaceEntry.c_str()));
myEnforcedTreeWidget->addTopLevelItem(theItem);
}
else {
// MESSAGE("Number of child rows: " << nbVert);
if (nbVert >0) {
double childValueX,childValueY,childValueZ;
-// QString childGrouName;
+ QString childEntry, childGroupName;
QTreeWidgetItem* child;
for (int row = 0;row<nbVert;row++) {
child = theItem->child(row);
+ childGroupName = child->data(ENF_VER_GROUP_COLUMN,Qt::EditRole).toString();
+ childEntry = child->data(ENF_VER_ENTRY_COLUMN,Qt::EditRole).toString();
childValueX = child->data(ENF_VER_X_COLUMN,Qt::EditRole).toDouble();
childValueY = child->data(ENF_VER_Y_COLUMN,Qt::EditRole).toDouble();
childValueZ = child->data(ENF_VER_Z_COLUMN,Qt::EditRole).toDouble();
- if ((childValueX == x) && (childValueY == y) && (childValueZ == z)) {
- /* TODO GROUPS
+ if (((childValueX == x) && (childValueY == y) && (childValueZ == z)) || ( (childEntry.toStdString() != "") && (childEntry.toStdString() == geomEntry))) {
// update group name
- child->setData(ENF_VER_GROUP_COLUMN, Qt::EditRole, QVariant(groupName.c_str()));
- */
+ if (childGroupName.toStdString() != groupName) {
+ MESSAGE("Group is updated from \"" << childGroupName.toStdString() << "\" to \"" << groupName << "\"");
+ child->setData(ENF_VER_GROUP_COLUMN, Qt::EditRole, QVariant(groupName.c_str()));
+ }
okToCreate = false;
break;
- }
+ } // if
+ } // for
+ } // if
+ if (!okToCreate) {
+ if (geomEntry.empty()) {
+ MESSAGE("In " << theFaceName << " vertex with coords " << x << ", " << y << ", " << z << " already exist: dont create again");
+ }
+ else {
+ MESSAGE("In " << theFaceName << " vertex with entry " << geomEntry << " already exist: dont create again");
}
+ return;
}
- if (okToCreate) {
- MESSAGE("In " << shapeName << " vertex with coords " << x << ", " << y << ", " << z<< " is created");
- QTreeWidgetItem *vertexItem = new QTreeWidgetItem( theItem);
- vertexItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled);
- int vertexIndex=1;
- QString vertexName;
- int indexRef = 0;
- while(indexRef != vertexIndex) {
- indexRef = vertexIndex;
- vertexName = QString("Vertex #%1").arg(vertexIndex);
- for (int row = 0;row<nbVert;row++) {
- QString name = theItem->child(row)->data(ENF_VER_NAME_COLUMN,Qt::EditRole).toString();
- if (vertexName == name) {
- vertexIndex++;
- break;
- }
+ if (geomEntry.empty()) {
+ MESSAGE("In " << theFaceName << " vertex with coords " << x << ", " << y << ", " << z<< " is created");
+ }
+ else {
+ MESSAGE("In " << theFaceName << " vertex with geom entry " << geomEntry << " is created");
+ }
+
+ QTreeWidgetItem *vertexItem = new QTreeWidgetItem( theItem);
+ vertexItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled);
+ QPixmap iconSelect (SUIT_Session::session()->resourceMgr()->loadPixmap("SMESH", tr("ICON_SELECT")));
+ QSize iconSize = iconSelect.size()*0.7;
+
+ int vertexIndex=myEnforcedTreeWidget->indexOfTopLevelItem(theItem);
+ QString myVertexName;
+ int indexRef = -1;
+ while(indexRef != vertexIndex) {
+ indexRef = vertexIndex;
+ if (vertexName.empty())
+ myVertexName = QString("Vertex #%1").arg(vertexIndex);
+ else
+ myVertexName = QString(vertexName.c_str());
+
+ for (int row = 0;row<nbVert;row++) {
+ QString name = theItem->child(row)->data(ENF_VER_NAME_COLUMN,Qt::EditRole).toString();
+ if (myVertexName == name) {
+ vertexIndex++;
+ break;
}
}
- vertexItem->setData( ENF_VER_NAME_COLUMN, Qt::EditRole, vertexName );
+ }
+ vertexItem->setData( ENF_VER_NAME_COLUMN, Qt::EditRole, myVertexName );
+ if (geomEntry.empty()) {
vertexItem->setData( ENF_VER_X_COLUMN, Qt::EditRole, QVariant(x) );
vertexItem->setData( ENF_VER_Y_COLUMN, Qt::EditRole, QVariant(y) );
vertexItem->setData( ENF_VER_Z_COLUMN, Qt::EditRole, QVariant(z) );
- /* TODO GROUPS
+ }
+ else {
+ vertexItem->setIcon(ENF_VER_NAME_COLUMN, QIcon(iconSelect.scaled(iconSize,Qt::KeepAspectRatio,Qt::SmoothTransformation)));
+ vertexItem->setData( ENF_VER_ENTRY_COLUMN, Qt::EditRole, QString(geomEntry.c_str()) );
+ }
+ if (groupName != "")
vertexItem->setData( ENF_VER_GROUP_COLUMN, Qt::EditRole, QVariant(groupName.c_str()));
- */
- QString toolTip = QString(shapeName.c_str())+QString(": ")+vertexName;
+
+ QString toolTip = QString(theFaceName.c_str())+QString(": ")+myVertexName;
+ if (geomEntry.empty()) {
toolTip += QString(" (%1, ").arg(x);
toolTip += QString("%1, ").arg(y);
toolTip += QString("%1)").arg(z);
- vertexItem->setToolTip(ENF_VER_NAME_COLUMN,toolTip);
- theItem->setExpanded(true);
- myEnforcedTreeWidget->setCurrentItem(vertexItem,ENF_VER_NAME_COLUMN);
}
- else
- /* TODO GROUPS
- MESSAGE("In " << shapeName << " vertex with coords " << x << ", " << y << ", " << z <<
- " already exist: dont create again, only group name is updated with " << groupName);
- */
- MESSAGE("In " << shapeName << " vertex with coords " << x << ", " << y << ", " << z << " already exist: dont create again");
+ if (groupName != "")
+ toolTip += QString(" [%1]").arg(groupName.c_str());
+
+ vertexItem->setToolTip(ENF_VER_NAME_COLUMN,toolTip);
+ theItem->setExpanded(true);
+ myEnforcedTreeWidget->setCurrentItem(vertexItem,ENF_VER_NAME_COLUMN);
}
/** BLSURFPluginGUI_HypothesisCreator::onAddEnforcedVertices()
void BLSURFPluginGUI_HypothesisCreator::onAddEnforcedVertices() {
// MESSAGE("BLSURFPluginGUI_HypothesisCreator::onAddEnforcedVertices");
+ BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
+
+ that->getGeomSelectionTool()->selectionMgr()->clearFilters();
+ myEnfFaceWdg->deactivateSelection();
+ myEnfVertexWdg->deactivateSelection();
+
for (int column = 0; column < myEnforcedTreeWidget->columnCount(); ++column)
myEnforcedTreeWidget->resizeColumnToContents(column);
-
- BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
-
- if ((myXCoord->text().isEmpty()) ||
- (myYCoord->text().isEmpty()) ||
- (myZCoord->text().isEmpty())) return;
- double x = myXCoord->GetValue();
- double y = myYCoord->GetValue();
- double z = myZCoord->GetValue();
+ // Vertex selection
+ int selEnfFace = myEnfFaceWdg->NbObjects();
+ int selEnfVertex = myEnfVertexWdg->NbObjects();
+ bool coordsEmpty = (myXCoord->text().isEmpty()) || (myYCoord->text().isEmpty()) || (myZCoord->text().isEmpty());
- /* TODO GROUPS
- std::string groupName = myGroupName->text().toStdString();
- if (makeGroupsCheck->isChecked())
- groupName = myGlobalGroupName->text().toStdString();
+ if (selEnfFace == 0)
+ return;
+
+ if ((selEnfVertex == 0) && coordsEmpty)
+ return;
- if (boost::trim_copy(groupName) == "")
- groupName = "";
- */
-
- TopAbs_ShapeEnum shapeType;
string entry, shapeName;
- GeomSelectionTools* myGeomToolSelected = that->getGeomSelectionTool();
- LightApp_SelectionMgr* mySel = myGeomToolSelected->selectionMgr();
- SALOME_ListIO ListSelectedObjects;
- mySel->selectedObjects(ListSelectedObjects, NULL, false );
- if (!ListSelectedObjects.IsEmpty()) {
- SALOME_ListIteratorOfListIO Object_It(ListSelectedObjects);
- for (; Object_It.More(); Object_It.Next()) {
- Handle(SALOME_InteractiveObject) anObject = Object_It.Value();
- entry = myGeomToolSelected->getEntryOfObject(anObject);
- shapeName = anObject->getName();
- shapeType = myGeomToolSelected->entryToShapeType(entry);
-// MESSAGE("Object Name = " << shapeName << "& Type is " << anObject->getComponentDataType() << " & ShapeType is " << shapeType);
- if (shapeType == TopAbs_FACE) {
- /* TODO GROUPS
- addEnforcedVertex(entry, shapeName, x, y, z, groupName);
- */
- addEnforcedVertex(entry, shapeName, x, y, z);
+
+ for (int i = 0 ; i < selEnfFace ; i++) {
+ myEnfFace = myEnfFaceWdg->GetObject< GEOM::GEOM_Object >(i);
+ entry = myEnfFace->GetStudyEntry();
+ shapeName = myEnfFace->GetName();
+
+ std::string groupName = myGroupName->text().toStdString();
+ if (makeGroupsCheck->isChecked())
+ groupName = myGlobalGroupName->text().toStdString();
+
+ if (boost::trim_copy(groupName).empty())
+ groupName = "";
+
+ if (selEnfVertex <= 1)
+ {
+ double x,y,z;
+ x = myXCoord->GetValue();
+ y = myYCoord->GetValue();
+ z = myZCoord->GetValue();
+ if (selEnfVertex == 1) {
+ myEnfVertex = myEnfVertexWdg->GetObject< GEOM::GEOM_Object >();
+ addEnforcedVertex(entry, shapeName, x, y, z, myEnfVertex->GetName(),myEnfVertex->GetStudyEntry(), groupName);
+ }
+ else
+ addEnforcedVertex(entry, shapeName, x, y, z, "", "", groupName);
+ }
+ else
+ {
+ if ( CORBA::is_nil(getGeomEngine()))
+ return;
+
+ GEOM::GEOM_IMeasureOperations_var measureOp = getGeomEngine()->GetIMeasureOperations( that->getGeomSelectionTool()->getMyStudy()->StudyId() );
+ if (CORBA::is_nil(measureOp))
+ return;
+
+ CORBA::Double x,y,z;
+ x = y = z = 0.;
+ for (int j = 0 ; j < selEnfVertex ; j++)
+ {
+ myEnfVertex = myEnfVertexWdg->GetObject< GEOM::GEOM_Object >(j);
+ if (myEnfVertex->GetShapeType() == GEOM::VERTEX) {
+ measureOp->PointCoordinates (myEnfVertex, x, y, z);
+ if ( measureOp->IsDone() )
+ addEnforcedVertex(entry, shapeName, x, y, z, myEnfVertex->GetName(),myEnfVertex->GetStudyEntry(), groupName);
+ } else if (myEnfVertex->GetShapeType() == GEOM::COMPOUND) {
+ addEnforcedVertex(entry, shapeName, 0, 0, 0, myEnfVertex->GetName(),myEnfVertex->GetStudyEntry(), groupName);
+ }
}
}
}
+
+ myEnfFaceWdg->SetObject(GEOM::GEOM_Object::_nil());
+ myEnfVertexWdg->SetObject(GEOM::GEOM_Object::_nil());
+
for (int column = 0; column < myEnforcedTreeWidget->columnCount(); ++column)
myEnforcedTreeWidget->resizeColumnToContents(column);
-
+
if ( myPhysicalMesh->currentIndex() != SizeMap ) {
myPhysicalMesh->setCurrentIndex( SizeMap );
onPhysicalMeshChanged();
QVariant value = item->data(ENF_VER_X_COLUMN, Qt::EditRole);
if (! value.isNull())
selectedVertices.append(item);
- else
- selectedEntries.insert(item);
+ else {
+ value = item->data(ENF_VER_ENTRY_COLUMN, Qt::EditRole);
+ if (! value.isNull())
+ selectedVertices.append(item);
+ else
+ selectedEntries.insert(item);
+ }
}
foreach(item,selectedVertices) {
mySizeMapTable->resizeColumnToContents(SMP_SIZEMAP_COLUMN);
// Enforced vertices
-// MESSAGE("retrieveParams(): data.entryEnfVertexListMap.size() = " << data.entryEnfVertexListMap.size());
- std::map<std::string, std::set<std::vector<double> > >::const_iterator evmIt = data.entryEnfVertexListMap.begin();
- for ( ; evmIt != data.entryEnfVertexListMap.end() ; ++evmIt) {
- std::string entry = (*evmIt).first;
+ MESSAGE("retrieveParams(): data.entryCoordsListMap.size() = " << data.faceEntryEnfVertexListMap.size());
+ TFaceEntryEnfVertexListMap::const_iterator evmIt = data.faceEntryEnfVertexListMap.begin();
+ for ( ; evmIt != data.faceEntryEnfVertexListMap.end() ; ++evmIt) {
+ TEntry entry = (*evmIt).first;
std::string shapeName = myGeomToolSelected->getNameFromEntry(entry);
-
- std::set<std::vector<double> > evs;
- std::set<std::vector<double> >::const_iterator evsIt;
- try {
- evs = (*evmIt).second;
- }
- catch(...) {
-// MESSAGE("evs = (*evmIt)[entry]: FAIL");
- break;
- }
-
- evsIt = evs.begin();
+ MESSAGE("Face entry: " << entry);
+ MESSAGE("Face name: " << shapeName);
+
+ TEnfVertexList evs = (*evmIt).second;
+// try {
+// evs = (*evmIt).second;
+// }
+// catch(...) {
+// MESSAGE("evs = (*evmIt).second: FAIL");
+// break;
+// }
+
+ TEnfVertexList::const_iterator evsIt = evs.begin();
+ TEnfVertex *enfVertex;
for ( ; evsIt != evs.end() ; ++evsIt) {
- double x, y, z;
- x = (*evsIt)[0];
- y = (*evsIt)[1];
- z = (*evsIt)[2];
- /* TODO GROUPS
- std::string groupName = data.enfVertexGroupNameMap[(*evsIt)];
- MESSAGE("Vertex "<<x<<" "<<y<<" "<<z<<" has group name "<<groupName);
- that->addEnforcedVertex(entry, shapeName, x, y, z, groupName);
- */
- that->addEnforcedVertex(entry, shapeName, x, y, z);
+ enfVertex = (*evsIt);
+ MESSAGE("Name: " << enfVertex->name);
+ double x, y, z = 0;
+ if (enfVertex->coords.size()) {
+ x = enfVertex->coords[0];
+ y = enfVertex->coords[1];
+ z = enfVertex->coords[2];
+ }
+ that->addEnforcedVertex(entry, shapeName, x, y, z, enfVertex->name, enfVertex->geomEntry, enfVertex->grpName);
}
}
+
for (int column = 0; column < myEnforcedTreeWidget->columnCount(); ++column)
myEnforcedTreeWidget->resizeColumnToContents(column);
-
+
// update widgets
that->onPhysicalMeshChanged();
that->onGeometricMeshChanged();
// MESSAGE("mySMPShapeTypeMap[" << myAttractorList[0].toStdString() << "] = " << that->mySMPShapeTypeMap[myAttractorList[0]]);
}
}
-
+
// Enforced vertices
h_data.enfVertexList.clear();
- h_data.entryEnfVertexListMap.clear();
+ h_data.faceEntryEnfVertexListMap.clear();
/* TODO GROUPS
h_data.groupNameEnfVertexListMap.clear();
-// h_data.enfVertexGroupNameMap.clear();
*/
-
- BLSURFPlugin::TEntryEnfVertexListMap_var entryEnfVertexListMap = h->GetAllEnforcedVertices();
-// MESSAGE("entryEnfVertexListMap->length() = " << entryEnfVertexListMap->length());
- for ( int i = 0;i<entryEnfVertexListMap->length(); ++i ) {
- std::string entry = entryEnfVertexListMap[i].entry.in();
- BLSURFPlugin::TEnfVertexList_var vertexList = h->GetEnforcedVerticesEntry(entry.c_str());
- std::set<std::vector<double> > evs;
- /* TODO GROUPS
- std::string groupName = "";
- */
- for (int j=0 ; j<vertexList->length(); ++j) {
- double x = vertexList[j][0];
- double y = vertexList[j][1];
- double z = vertexList[j][2];
- std::vector<double> ev;
- ev.push_back(x);
- ev.push_back(y);
- ev.push_back(z);
- evs.insert(ev);
- h_data.enfVertexList.insert(ev);
+ BLSURFPlugin::TFaceEntryEnfVertexListMap_var faceEntryEnfVertexListMap = h->GetAllEnforcedVerticesByFace();
+ MESSAGE("faceEntryEnfVertexListMap->length() = " << faceEntryEnfVertexListMap->length());
+
+ for ( int i = 0;i<faceEntryEnfVertexListMap->length(); ++i ) {
+ std::string entry = faceEntryEnfVertexListMap[i].faceEntry.in();
+// BLSURFPlugin::TEnfVertexList vertexList = faceEntryEnfVertexListMap[i].enfVertexList.in();
+ BLSURFPlugin::TEnfVertexList vertexList = faceEntryEnfVertexListMap[i].enfVertexList;
+// BLSURFPlugin::TEnfVertexList_var vertexList = h->GetEnforcedVerticesEntry(entry.c_str());
+
+// TEnfVertexList& enfVertexList = h_data.faceEntryEnfVertexListMap[entry];
+
+ for (int j=0 ; j<vertexList.length(); ++j) {
+ TEnfVertex *enfVertex = new TEnfVertex();
+
+ enfVertex->name = CORBA::string_dup(vertexList[j].name.in());
+ enfVertex->geomEntry = CORBA::string_dup(vertexList[j].geomEntry.in());
+ enfVertex->grpName = CORBA::string_dup(vertexList[j].grpName.in());
+ for (int k=0 ; k< vertexList[j].coords.length();k++)
+ enfVertex->coords.push_back(vertexList[j].coords[k]);
+
+ h_data.faceEntryEnfVertexListMap[entry].insert(enfVertex);
+
/* TODO GROUPS
- groupName.assign(h->GetEnforcedVertexGroupName(x, y, z));
- MESSAGE("readParamsFromHypo, groupName = "<<groupName)
- h_data.enfVertexGroupNameMap[ev] = groupName;
if (groupName != "") {
h_data.groupNameEnfVertexListMap[groupName].insert(ev);
}
*/
-// MESSAGE("New enf vertex for entry " << entry << ": " << x << ", " << y << ", " << z);
}
// h_data.enfVertMap[entry] = evs;
- h_data.entryEnfVertexListMap[entry] = evs;
- if (evs.size() == 0) {
-// MESSAGE("No enf vertex for entry " << entry << ": key is erased");
-// h_data.enfVertMap.erase(entry);
- h_data.entryEnfVertexListMap.erase(entry);
+// h_data.entryCoordsListMap[entry] = coordsList;
+
+ if (h_data.faceEntryEnfVertexListMap[entry].size() == 0) {
+ h_data.faceEntryEnfVertexListMap.erase(entry);
}
}
-
+
return true;
}
h->SetAngleMeshC( h_data.myAngleMeshC );
}
#ifdef WITH_SIZE_BOUNDARIES
-// if ( !isDouble( h_data.myPhyMin ))
-// h->SetPhyMin( -1 );
-// else if ( h->GetPhyMin() != h_data.myPhyMin.toDouble() )
-// h->SetPhyMin( h_data.myPhyMin.toDouble() );
-// if ( !isDouble( h_data.myPhyMax ))
-// h->SetPhyMax( -1 );
-// else if ( h->GetPhyMax() != h_data.myPhyMax.toDouble() )
-// h->SetPhyMax( h_data.myPhyMax.toDouble() );
-// if ( !isDouble( h_data.myGeoMin ))
-// h->SetGeoMin( -1 );
-// else if ( h->GetGeoMin() != h_data.myGeoMin.toDouble() )
-// h->SetGeoMin( h_data.myGeoMin.toDouble() );
-// if ( !isDouble( h_data.myGeoMax ))
-// h->SetGeoMax( -1 );
-// else if ( h->GetGeoMax() != h_data.myGeoMax.toDouble() )
-// h->SetGeoMax( h_data.myGeoMax.toDouble() );
if (h_data.myPhyMin > 0)
h->SetPhyMin( h_data.myPhyMin );
if (h_data.myPhyMax > 0)
h->SetGeoMax( h_data.myGeoMax );
#endif
- //printf("storeParamsToHypo():myOptions->length()=%d\n",myOptions->length());
h->SetOptionValues( myOptions ); // is set in checkParams()
BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
h->SetSizeMapEntry( entry.toLatin1().constData(), fullSizeMap.toLatin1().constData() );
}
}
-
+
// Enforced vertices
- std::map<std::string, std::set<std::vector<double> > >::const_iterator evmIt = h_data.entryEnfVertexListMap.begin();
- for ( ; evmIt != h_data.entryEnfVertexListMap.end() ; ++evmIt) {
- std::string entry = evmIt->first;
- std::set<std::vector<double> > evs;
- std::set<std::vector<double> >::const_iterator evsIt;
- double x, y, z;
- /* TODO GROUPS
- std::string groupName = "";
- */
- BLSURFPlugin::TEnfVertexList_var hypVertexList;
- int hypNbVertex = 0;
- try {
- hypVertexList = h->GetEnforcedVerticesEntry(entry.c_str());
- hypNbVertex = hypVertexList->length();
- }
- catch(...) {
- }
- evs = evmIt->second;
- evsIt = evs.begin();
- for ( ; evsIt != evs.end() ; ++evsIt) {
- x = (*evsIt)[0];
- y = (*evsIt)[1];
- z = (*evsIt)[2];
-
- /* TODO GROUPS
- std::map<std::vector<double> , std::string >::const_iterator grpIt = h_data.enfVertexGroupNameMap.find(*evsIt);
- if (grpIt != h_data.enfVertexGroupNameMap.end())
- groupName = grpIt->second;
-// MESSAGE("SetEnforcedVertexEntry("<<entry<<", "<<x<<", "<<y<<", "<<z<<")");
- h->SetEnforcedVertexEntryWithGroup( entry.c_str(), x, y, z, groupName.c_str() );
- */
- h->SetEnforcedVertexEntry( entry.c_str(), x, y, z );
+ bool ret;
+ int hypNbVertex;
+ double x, y, z = 0;
+ std::string enfName;
+ /* TODO GROUPS
+ std::string groupName = "";
+ */
+
+ TFaceEntryEnfVertexListMap::const_iterator evmIt = h_data.faceEntryEnfVertexListMap.begin();
+
+ BLSURFPlugin::TFaceEntryEnfVertexListMap_var allEnforcedVerticesByFace = h->GetAllEnforcedVerticesByFace();
+ hypNbVertex = allEnforcedVerticesByFace->length();
+
+
+ // All enforced vertices were deleted
+ if (evmIt == h_data.faceEntryEnfVertexListMap.end() && hypNbVertex!=0) {
+ h->ClearAllEnforcedVertices();
+ ok = true;
+ }
+ else {
+ // All enforced vertices for a specific entry were deleted
+ for (int i=0 ; i<hypNbVertex; i++) {
+ BLSURFPlugin::TFaceEntryEnfVertexListMapElement el = allEnforcedVerticesByFace[i];
+ TEnfName entry = el.faceEntry.in();
+ if (h_data.faceEntryEnfVertexListMap.find(entry) == h_data.faceEntryEnfVertexListMap.end()) {
+ MESSAGE("Remove all enforced vertices for entry " << entry);
+ h->UnsetEnforcedVerticesEntry(entry.c_str());
+ }
}
- // Remove old vertices
- if (hypNbVertex >0) {
+
+ // One or several enforced vertices are added or removed for a specific entry
+ TEnfVertexList enfVertexFromHyp;
+ BLSURFPlugin::TEnfVertexList_var hypEnfVertexList;
+ TEnfName faceEntry;
+ TEnfVertexList evs;
+ TEnfVertexList::const_iterator evsIt, enfVertexToRemove;
+ for ( ; evmIt != h_data.faceEntryEnfVertexListMap.end() ; ++evmIt) {
+ faceEntry = evmIt->first;
+ evs = evmIt->second;
+ MESSAGE("Number of enforced vertices for face entry " << faceEntry << ": " << evs.size());
+ evsIt = evs.begin();
+
+ hypEnfVertexList = h->GetEnforcedVerticesEntry(faceEntry.c_str());
+ hypNbVertex = hypEnfVertexList->length();
+ MESSAGE("Number of enforced vertices from hypothesis: " << hypNbVertex);
+ enfVertexFromHyp.clear();
for (int i =0 ; i<hypNbVertex ; i++) {
- x = hypVertexList[i][0];
- y = hypVertexList[i][1];
- z = hypVertexList[i][2];
- std::vector<double> vertex;
- vertex.push_back(x);
- vertex.push_back(y);
- vertex.push_back(z);
- if (evs.find(vertex) == evs.end()) {
-// MESSAGE("UnsetEnforcedVertexEntry("<<entry<<", "<<x<<", "<<y<<", "<<z<<")");
- h->UnsetEnforcedVertexEntry( entry.c_str(), x, y, z );
+ TEnfVertex *_enfVertex = new TEnfVertex();
+ _enfVertex->name = string("");
+ _enfVertex->name = CORBA::string_dup(hypEnfVertexList[i].name.in());
+ _enfVertex->geomEntry = string("");
+ _enfVertex->geomEntry = CORBA::string_dup(hypEnfVertexList[i].geomEntry.in());
+ _enfVertex->grpName = string("");
+ _enfVertex->grpName = CORBA::string_dup(hypEnfVertexList[i].grpName.in());
+ for (int j=0 ; j< hypEnfVertexList[i].coords.length() ; j++)
+ _enfVertex->coords.push_back(hypEnfVertexList[i].coords[j]);
+ enfVertexFromHyp.insert(_enfVertex);
+ MESSAGE("From hyp: enf vertex " << _enfVertex->name);
+// MESSAGE("From hyp: enf. vertex at " << _coords[0]<<", "<<_coords[1]<<", "<<_coords[2]);
+ }
+
+// TEnfVertex *enfVertex;
+ for ( ; evsIt != evs.end() ; ++evsIt) {
+ x =y =z = 0;
+// enfVertex = (*evsIt);
+ if ((*evsIt)->coords.size()) {
+ x = (*evsIt)->coords[0];
+ y = (*evsIt)->coords[1];
+ z = (*evsIt)->coords[2];
}
+ ret = h->SetEnforcedVertexEntry( faceEntry.c_str(), x, y, z, (*evsIt)->name.c_str(), (*evsIt)->geomEntry.c_str(), (*evsIt)->grpName.c_str());
+ enfVertexFromHyp.erase((*evsIt));
+
+// for (enfVertexToRemove = enfVertexFromHyp.begin() ; enfVertexToRemove != enfVertexFromHyp.end() ; ++enfVertexToRemove) {
+// if (!TEnfVertexGUICmp(&enfVertex, &(*enfVertexToRemove))) {
+// MESSAGE("Enf vertex " << enfVertex.name << " must not be deleted")
+// enfVertexFromHyp.erase(enfVertexToRemove);
+// }
+// }
}
- }
- }
- }
- catch(const SALOME::SALOME_Exception& ex)
- {
- SalomeApp_Tools::QtCatchCorbaException(ex);
- ok = false;
+
+ // Remove old vertices
+ enfVertexToRemove = enfVertexFromHyp.begin();
+ for ( ; enfVertexToRemove!=enfVertexFromHyp.end() ; ++enfVertexToRemove) {
+// enfVertex = (*enfVertexToRemove);
+ if (h_data.enfVertexList.find((*enfVertexToRemove)) != h_data.enfVertexList.end()) {
+
+// for ( evsIt=h_data.enfVertexList.begin();evsIt!=h_data.enfVertexList.end();evsIt++) {
+// if (TEnfVertexGUICmp(&(*evsIt),&enfVertex)) {
+ MESSAGE("Remove enf vertex " << (*enfVertexToRemove)->name);
+ if ((*enfVertexToRemove)->coords.size()) {
+ x = (*enfVertexToRemove)->coords[0];
+ y = (*enfVertexToRemove)->coords[1];
+ z = (*enfVertexToRemove)->coords[2];
+ }
+ ret = h->UnsetEnforcedVertexEntry(faceEntry.c_str(), x, y, z, (*enfVertexToRemove)->geomEntry.c_str());
+ if (ret)
+ MESSAGE("SUCCESS");
+// } // if
+// } // for
+ } // if
+ } // for
+ } // for
+ } // else
+ } // try
+ catch(const std::exception& ex) {
+ std::cout << "Exception: " << ex.what() << std::endl;
+ throw ex;
}
+// catch(const SALOME::SALOME_Exception& ex)
+// {
+// throw ex;
+// // SalomeApp_Tools::QtCatchCorbaException(ex);
+// // ok = false;
+// }
return ok;
}
// Enforced vertices
h_data.enfVertexList.clear();
- h_data.entryEnfVertexListMap.clear();
- /* TODO GROUPS
- h_data.groupNameEnfVertexListMap.clear();
- h_data.enfVertexGroupNameMap.clear();
- */
-
+ h_data.faceEntryEnfVertexListMap.clear();
+
int nbEnforcedShapes = myEnforcedTreeWidget->topLevelItemCount();
int nbEnforcedVertices = 0;
std::string groupName = "";
for (int i=0 ; i<nbEnforcedShapes ; i++) {
QTreeWidgetItem* shapeItem = myEnforcedTreeWidget->topLevelItem(i);
if (shapeItem) {
- std::string entry = shapeItem->data(ENF_VER_ENTRY_COLUMN,Qt::EditRole).toString().toStdString();
+ std::string faceEntry = shapeItem->data(ENF_VER_FACE_ENTRY_COLUMN,Qt::EditRole).toString().toStdString();
nbEnforcedVertices = shapeItem->childCount();
if (nbEnforcedVertices >0) {
double childValueX,childValueY,childValueZ;
+ std::string childName, vertexEntry;
QTreeWidgetItem* child;
- std::set<std::vector<double> > evs;
+ TEnfVertexList evs;
+ evs.clear();
for (row = 0;row<nbEnforcedVertices;row++) {
child = shapeItem->child(row);
+ childName = child->data(ENF_VER_NAME_COLUMN,Qt::EditRole).toString().toStdString();
childValueX = child->data(ENF_VER_X_COLUMN,Qt::EditRole).toDouble();
childValueY = child->data(ENF_VER_Y_COLUMN,Qt::EditRole).toDouble();
childValueZ = child->data(ENF_VER_Z_COLUMN,Qt::EditRole).toDouble();
- std::vector<double> vertex;
- vertex.push_back(childValueX);
- vertex.push_back(childValueY);
- vertex.push_back(childValueZ);
- evs.insert(vertex);
- h_data.enfVertexList.insert(vertex);
- /* TODO GROUPS
- groupName = child->data(ENF_VER_GROUP_COLUMN,Qt::EditRole).toString().toStdString();
- // Group
+ vertexEntry = child->data(ENF_VER_ENTRY_COLUMN,Qt::EditRole).toString().toStdString();
if (makeGroupsCheck->isChecked())
groupName = myGlobalGroupName->text().toStdString();
- h_data.enfVertexGroupNameMap[vertex] = groupName;
+ else
+ groupName = child->data(ENF_VER_GROUP_COLUMN,Qt::EditRole).toString().toStdString();
+
+ TEnfVertex *enfVertex = new TEnfVertex();
+ enfVertex->name = childName;
+ if (vertexEntry.empty()) {
+ enfVertex->coords.push_back(childValueX);
+ enfVertex->coords.push_back(childValueY);
+ enfVertex->coords.push_back(childValueZ);
+ }
+ else
+ enfVertex->geomEntry = vertexEntry;
+ enfVertex->grpName = groupName;
+// TEnfVertexList::iterator it = h_data.enfVertexList.find(enfVertex);
+// if (it == h_data.enfVertexList.end())
+ h_data.enfVertexList.insert(enfVertex);
+ evs.insert(enfVertex);
+ /* TODO GROUPS
if (groupName != "")
h_data.groupNameEnfVertexListMap[groupName].insert(vertex);
*/
}
- h_data.entryEnfVertexListMap[entry] = evs;
+ h_data.faceEntryEnfVertexListMap[faceEntry] = evs;
}
}
}
bool isSizeMap = (myPhysicalMesh->currentIndex() == SizeMap);
bool isCustom = (isPhysicalUserDefined || isSizeMap) ;
bool geomIsCustom = (myGeometricMesh->currentIndex() == UserDefined);
-
+
myGradation->setEnabled(!isPhysicalUserDefined || geomIsCustom);
myPhySize->setEnabled(isCustom);
myPhyMax->setEnabled(isCustom);
myPhyMin->setEnabled(isCustom);
if ( !myGradation->isEnabled())
-// myGradation->setValue( 1.1 );
myGradation->SetValue( 1.1 );
if ( !isCustom ) {
-// QString aPhySize = "";
-// switch( myPhysicalMesh->currentIndex() ) {
-// case DefaultSize:
-// default:
-// aPhySize = "10";
-// break;
-// }
-// myPhySize->setText( aPhySize );
-// if ( !isDouble( myPhyMin->text(), true ))
-// myPhyMin->setText("");
-// if ( !isDouble( myPhyMax->text(), true ))
-// myPhyMax->setText("");
if ( myGeometricMesh->currentIndex() == DefaultGeom ) {
myGeometricMesh->setCurrentIndex( UserDefined );
onGeometricMeshChanged();
MESSAGE("BLSURFPluginGUI_HypothesisCreator::onGeometricMeshChanged");
bool isCustom = (myGeometricMesh->currentIndex() == UserDefined);
bool phyIsSizemap = (myPhysicalMesh->currentIndex() == SizeMap);
-
+
myAngleMeshS->setEnabled(isCustom);
myAngleMeshC->setEnabled(isCustom);
myGradation->setEnabled(isCustom || phyIsSizemap);
myGradation->SetValue( 1.1 );
if ( ! isCustom ) {
-// double aAngleMeshS;
-// switch( myGeometricMesh->currentIndex() ) {
-// case DefaultGeom:
-// default:
-// aAngleMeshS = 8;
-// break;
-// }
-// myAngleMeshS->SetValue( aAngleMeshS );
-// myAngleMeshC->SetValue( aAngleMeshS );
-// if ( !isDouble( myGeoMin->text(), true ))
-// myGeoMin->setText("");
-// if ( !isDouble( myGeoMax->text(), true ))
-// myGeoMax->setText("");
// hphy_flag = 0 and hgeo_flag = 0 is not allowed (spec)
if ( myPhysicalMesh->currentIndex() == DefaultSize ) {
myPhysicalMesh->setCurrentIndex( PhysicalUserDefined );
BLSURFPlugin::BLSURFPlugin_Hypothesis::_narrow( initParamsHypothesis());
BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this;
-
- TopAbs_ShapeEnum shapeType;
- string entry, shapeName;
GeomSelectionTools* myGeomToolSelected = that->getGeomSelectionTool();
LightApp_SelectionMgr* mySel = myGeomToolSelected->selectionMgr();
+ TopAbs_ShapeEnum shapeType;
+ string entry, shapeName;
SALOME_ListIO ListSelectedObjects;
mySel->selectedObjects(ListSelectedObjects, NULL, false );
if (!ListSelectedObjects.IsEmpty())
}
else if (that->mySMPMap[myEntry].startsWith("ATTRACTOR")) {
// MESSAGE("Attractor" );
-// if ((that->mySMPMap[myEntry].count(QRegExp("^ATTRACTOR\\((?:(-?0(\\.\\d*)*|-?[1-9]+\\d*(\\.\\d*)*|-?\\.(\\d)+);){5}(True|False)\\)$")) != 1)) {
- if ((that->mySMPMap[myEntry].count(QRegExp("^ATTRACTOR\\((?:(-?0(\\.\\d*)*|-?[1-9]+\\d*(\\.\\d*)*|-?\\.(\\d)+);){5}(True|False)(?:;(-?0(\\.\\d*)*|-?[1-9]+\\d*(\\.\\d*)*|-?\\.(\\d)+))?\\)$")) != 1)) {
-// if ((that->mySMPMap[myEntry].count('(') != 1) or
-// (that->mySMPMap[myEntry].count(')') != 1) or
-// (that->mySMPMap[myEntry].count(';') != 4) or
-// (that->mySMPMap[myEntry].size() == 15)){
+ if ((that->mySMPMap[myEntry].count(QRegExp("^ATTRACTOR\\((?:(-?0(\\.\\d*)*|-?[1-9]+\\d*(\\.\\d*)*|-?\\.(\\d)+);){5}(True|False)\\)$")) != 1)) {
if (displayError)
SUIT_MessageBox::warning( dlg(),"Definition of attractor : Error" ,"An attractor is defined with the following pattern: ATTRACTOR(xa;ya;za;a;b;True|False[;d])" );
return false;
#include <QItemDelegate>
#include <SMESHGUI_Hypotheses.h>
+#include "StdMeshersGUI_ObjectReferenceParamWdg.h"
#include <SALOMEconfig.h>
#include <cstring>
#include <map>
#include <vector>
#include <TopAbs_ShapeEnum.hxx>
#include <GeomSelectionTools.h>
+#include <GEOM_Client.hxx>
#include CORBA_SERVER_HEADER(BLSURFPlugin_Algorithm)
class QGroupBox;
class LightApp_SelectionMgr;
// class DlgBlSurfHyp_Enforced;
+// Name
+typedef std::string TEnfName;
+// Entry
+typedef std::string TEntry;
+// List of entries
+typedef std::set<TEntry> TEntryList;
+// Enforced vertex = 3 coordinates
+typedef std::vector<double> TEnfVertexCoords;
+// List of enforced vertices
+typedef std::set< TEnfVertexCoords > TEnfVertexCoordsList;
+// Enforced vertex
+struct TEnfVertex{
+ TEnfName name;
+ TEntry geomEntry;
+ TEnfVertexCoords coords;
+ TEnfName grpName;
+};
+
+// TODO remove all TEnfVertexGUICmp
+
+struct CompareEnfVertices
+{
+ bool operator () (const TEnfVertex* e1, const TEnfVertex* e2) const {
+ if (e1 && e2) {
+ if (e1->coords.size() && e2->coords.size())
+ return (e1->coords < e2->coords);
+ else
+ return (e1->geomEntry < e2->geomEntry);
+ }
+ return false;
+ }
+};
+
+// List of enforced vertices
+typedef std::set< TEnfVertex*, CompareEnfVertices > TEnfVertexList;
+
+// Map Face Entry / List of enforced vertices
+typedef std::map< TEntry, TEnfVertexList > TFaceEntryEnfVertexListMap;
+
typedef struct
{
int myTopology, myVerbosity;
double myAngleMeshS, myAngleMeshC, myGradation;
double myPhySize, myGeoMin, myGeoMax, myPhyMin,myPhyMax;
bool myAllowQuadrangles, myDecimesh,mySmpsurface,mySmpedge,mySmppoint,myEnforcedVertex;
- std::set<std::vector<double> > enfVertexList;
- std::map<std::string, std::set<std::vector<double> > > entryEnfVertexListMap;
+ TEnfVertexList enfVertexList;
+ TFaceEntryEnfVertexListMap faceEntryEnfVertexListMap;
/* TODO GROUPS
- std::map<std::string, std::set<std::vector<double> > > groupNameEnfVertexListMap;
- std::map<std::vector<double> , std::string > enfVertexGroupNameMap;
+ TGroupNameEnfVertexListMap groupNameEnfVertexListMap;
*/
QString myName;
} BlsurfHypothesisData;
+
+// class BLSURFPluginGUI_ObjectReferenceParamWdg: public StdMeshersGUI_ObjectReferenceParamWdg
+// {
+// Q_OBJECT
+// public:
+// BLSURFPluginGUI_ObjectReferenceParamWdg( SUIT_SelectionFilter* filter,
+// QWidget* parent,
+// bool multiSelection=false);
+// BLSURFPluginGUI_ObjectReferenceParamWdg( MeshObjectType objType,
+// QWidget* parent,
+// bool multiSelection=false);
+// ~BLSURFPluginGUI_ObjectReferenceParamWdg();
+//
+// private:
+// void init();
+//
+// public slots:
+// void activateSelectionOnly();
+// void deactivateSelectionOnly();
+// void setActivationStatus(bool status);
+// };
+
/*!
* \brief Class for creation of BLSURF hypotheses
*/
virtual QFrame* buildFrame ();
virtual void retrieveParams() const;
virtual QString storeParams () const;
-
+
virtual QString caption() const;
virtual QPixmap icon() const;
virtual QString type() const;
void onRemoveMap();
void onSetSizeMap(int,int);
- /* TODO GROUPS
- void addEnforcedVertex(std::string, std::string, double, double, double, std::string);
- */
- void addEnforcedVertex(std::string, std::string, double, double, double);
+ void addEnforcedVertex(std::string theFaceEntry, std::string theFaceName, double x=0, double y=0, double z=0,
+ std::string vertexName = "", std::string geomEntry = "", std::string groupName = "");
void onAddEnforcedVertices();
void onRemoveEnforcedVertex();
void synchronizeCoords();
- void update(QTreeWidgetItem* , int );
+ void updateEnforcedVertexValues(QTreeWidgetItem* , int );
+ void onSelectEnforcedVertex();
+ void deactivateSelection(QWidget*, QWidget*);
+ void clearEnforcedVertexWidgets();
private:
bool readParamsFromHypo( BlsurfHypothesisData& ) const;
bool sizeMapValidationFromRow(int,bool displayError = true);
bool sizeMapValidationFromEntry(QString,bool displayError = true);
GeomSelectionTools* getGeomSelectionTool();
+ GEOM::GEOM_Gen_var getGeomEngine();
private:
QWidget* myStdGroup;
QPushButton *removeButton;
QWidget* myEnfGroup;
- /* TODO FACE AND VERTEX SELECTION
- QPushButton* selectFaceButton;
- QLineEdit* mySelectedFace;
-// GEOM::GEOM_Object_var myEnfFace;
- QPushButton* selectVertexButton;
- QLineEdit* mySelectedEnforcedVertex;
-// GEOM::GEOM_Object_var myEnfVertex;
- */
+// TODO FACE AND VERTEX SELECTION
+ StdMeshersGUI_ObjectReferenceParamWdg *myEnfFaceWdg;
+ GEOM::GEOM_Object_var myEnfFace;
+ StdMeshersGUI_ObjectReferenceParamWdg *myEnfVertexWdg;
+ GEOM::GEOM_Object_var myEnfVertex;
+
// DlgBlSurfHyp_Enforced* myEnforcedVertexWidget;
QTreeWidget* myEnforcedTreeWidget;
SMESHGUI_SpinBox* myXCoord;
SMESHGUI_SpinBox* myYCoord;
SMESHGUI_SpinBox* myZCoord;
- /* TODO GROUPS
+
QLineEdit* myGroupName;
QGroupBox* makeGroupsCheck;
QLineEdit* myGlobalGroupName;
- */
+
QPushButton* addVertexButton;
QPushButton* removeVertexButton;
void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option,
const QModelIndex &index) const;
-
+
bool vertexExists(QAbstractItemModel *model, const QModelIndex &index, QString value) const;
};
<translation>Enforced vertices</translation>
</message>
<message>
- <source>BLSURF_ENF_VER_ENTRY_COLUMN</source>
- <translation>Entry</translation>
+ <source>BLSURF_ENF_VER_FACE_ENTRY_COLUMN</source>
+ <translation>Face Entry</translation>
</message>
<message>
<source>BLSURF_ENF_VER_NAME_COLUMN</source>
<source>BLSURF_ENF_VER_Z_COLUMN</source>
<translation>Z</translation>
</message>
+ <message>
+ <source>BLSURF_ENF_VER_ENTRY_COLUMN</source>
+ <translation>Vertex Entry</translation>
+ </message>
<message>
<source>BLSURF_ENF_VER_GROUP_COLUMN</source>
<translation>Group</translation>
<translation>Points de passage</translation>
</message>
<message>
- <source>BLSURF_ENF_VER_ENTRY_COLUMN</source>
- <translation>Entrée</translation>
+ <source>BLSURF_ENF_VER_FACE_ENTRY_COLUMN</source>
+ <translation>ID de face</translation>
</message>
<message>
<source>BLSURF_ENF_VER_NAME_COLUMN</source>
<source>BLSURF_ENF_VER_Z_COLUMN</source>
<translation>Z</translation>
</message>
+ <message>
+ <source>BLSURF_ENF_VER_ENTRY_COLUMN</source>
+ <translation>ID de point</translation>
+ </message>
<message>
<source>BLSURF_ENF_VER_GROUP_COLUMN</source>
<translation>Groupe</translation>
$(QT_LIBS) \
../BLSURFPlugin/libBLSURFEngine.la \
$(GUI_LDFLAGS) -lqtx -lSalomeApp -lsuit -lSalomeObject -lLightApp \
- ${SMESH_LDFLAGS} -lSMESH -lGeomSelectionTools \
+ ${SMESH_LDFLAGS} -lSMESH -lGeomSelectionTools -lStdMeshersGUI \
$(CAS_KERNEL) $(BLSURF_LIBS)
# resources files
