#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_Hypothesis)
#include CORBA_CLIENT_HEADER(GEOM_Gen)
-#include CORBA_CLIENT_HEADER(GEOM_Shape)
#include CORBA_CLIENT_HEADER(SALOMEDS)
#include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
#include "SALOME_NamingService.hxx"
#include "SMESH_Gen.hxx"
-#include "SMESH_topo.hxx"
#include "GEOM_Client.hxx"
+#include <TCollection_AsciiString.hxx>
+#include <Resource_DataMapOfAsciiStringAsciiString.hxx>
+#include <TColStd_HSequenceOfAsciiString.hxx>
+
#include <map>
+#include <sstream>
class SMESH_Mesh_i;
class SALOME_LifeCycleCORBA;
public virtual Engines_Component_i
{
public:
+ // Get last created instance of the class
+ static SMESH_Gen_i* GetSMESHGen() { return mySMESHGen;}
// Get ORB object
static CORBA::ORB_var GetORB() { return myOrb;}
// Get SMESH module's POA object
static PortableServer::ServantBase_var GetServant( CORBA::Object_ptr theObject );
// Get CORBA object corresponding to the SALOMEDS::SObject
static CORBA::Object_var SObjectToObject( SALOMEDS::SObject_ptr theSObject );
-
+ // Get the SALOMEDS::SObject corresponding to a CORBA object
+ static SALOMEDS::SObject_ptr ObjectToSObject(SALOMEDS::Study_ptr theStudy,
+ CORBA::Object_ptr theObject);
+ // Get GEOM Object correspoding to TopoDS_Shape
+ GEOM::GEOM_Object_ptr ShapeToGeomObject (const TopoDS_Shape& theShape );
+ // Get TopoDS_Shape correspoding to GEOM_Object
+ TopoDS_Shape GeomObjectToShape(GEOM::GEOM_Object_ptr theGeomObject);
+
// Default constructor
SMESH_Gen_i();
// Standard constructor
throw ( SALOME::SALOME_Exception );
// Create empty mesh on a shape
- SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Shape_ptr theShape )
+ SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
+ throw ( SALOME::SALOME_Exception );
+
+ // Create mesh(es) and import data from UNV file
+ SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName )
throw ( SALOME::SALOME_Exception );
// Create mesh(es) and import data from MED file
SMESH::DriverMED_ReadStatus& theStatus )
throw ( SALOME::SALOME_Exception );
+ // Create mesh(es) and import data from STL file
+ SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName )
+ throw ( SALOME::SALOME_Exception );
+
// Compute mesh on a shape
CORBA::Boolean Compute( SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Shape_ptr theShape )
+ GEOM::GEOM_Object_ptr theShapeObject )
throw ( SALOME::SALOME_Exception );
// Returns true if mesh contains enough data to be computed
CORBA::Boolean IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Shape_ptr theShape )
+ GEOM::GEOM_Object_ptr theShapeObject )
throw ( SALOME::SALOME_Exception );
// Get sub-shapes unique ID's list
- SMESH::long_array* GetSubShapesId( GEOM::GEOM_Shape_ptr theMainShape,
- const SMESH::shape_array& theListOfSubShape )
+ SMESH::long_array* GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
+ const SMESH::object_array& theListOfSubShape )
throw ( SALOME::SALOME_Exception );
// Save SMESH data
SALOMEDS::TMPFile* Save( SALOMEDS::SComponent_ptr theComponent,
- const char* theURL,
- bool isMultiFile );
+ const char* theURL,
+ bool isMultiFile );
// Load SMESH data
bool Load( SALOMEDS::SComponent_ptr theComponent,
const SALOMEDS::TMPFile& theStream,
// Create filter manager
SMESH::FilterManager_ptr CreateFilterManager();
+ // Return a pattern mesher
+ SMESH::SMESH_Pattern_ptr GetPattern();
+
// Clears study-connected data when it is closed
void Close( SALOMEDS::SComponent_ptr theComponent );
return aResultSO._retn();
}
+ // ============
+ // Dump python
+ // ============
+
+ virtual Engines::TMPFile* DumpPython(CORBA::Object_ptr theStudy,
+ CORBA::Boolean isPublished,
+ CORBA::Boolean& isValidScript);
+
+ void AddToPythonScript (int theStudyID, const TCollection_AsciiString& theString);
+
+ void RemoveLastFromPythonScript (int theStudyID);
+
+ static void AddToCurrentPyScript (const TCollection_AsciiString& theString);
+
+ void SavePython (SALOMEDS::Study_ptr theStudy);
+
+ TCollection_AsciiString DumpPython_impl (int theStudyID,
+ Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
+ Resource_DataMapOfAsciiStringAsciiString& theNames,
+ bool isPublished,
+ bool& aValidScript,
+ const TCollection_AsciiString& theSavedTrace);
+
+ TCollection_AsciiString GetNewPythonLines (int theStudyID);
+
+ void CleanPythonTrace (int theStudyID);
+
+ // Dump python comfort methods
+
+ static TCollection_AsciiString& AddObject(TCollection_AsciiString& theStr,
+ CORBA::Object_ptr theObject);
+ // add object to script string
+
+ template <class _array>
+ static TCollection_AsciiString& AddArray(TCollection_AsciiString& theStr,
+ const _array & array)
+ // put array contents into theStr like this: "[ 1, 2, 5 ]"
+ {
+ ostringstream sout; // can convert long int, and TCollection_AsciiString cant
+ sout << "[ ";
+ for (int i = 1; i <= array.length(); i++) {
+ sout << array[i-1];
+ if ( i < array.length() )
+ sout << ", ";
+ }
+ sout << " ]";
+ theStr += (char*) sout.str().c_str();
+ return theStr;
+ }
+
// *****************************************
// Internal methods
// *****************************************
static long GetSubMeshOnFaceTag();
static long GetSubMeshOnSolidTag();
static long GetSubMeshOnCompoundTag();
+ static long GetSubMeshOnWireTag();
+ static long GetSubMeshOnShellTag();
static long GetNodeGroupsTag();
static long GetEdgeGroupsTag();
static long GetFaceGroupsTag();
static long GetVolumeGroupsTag();
+ // publishing methods
+ SALOMEDS::SComponent_ptr PublishComponent(SALOMEDS::Study_ptr theStudy);
+ SALOMEDS::SObject_ptr PublishMesh (SALOMEDS::Study_ptr theStudy,
+ SMESH::SMESH_Mesh_ptr theMesh,
+ const char* theName = 0);
+ SALOMEDS::SObject_ptr PublishHypothesis (SALOMEDS::Study_ptr theStudy,
+ SMESH::SMESH_Hypothesis_ptr theHyp,
+ const char* theName = 0);
+ SALOMEDS::SObject_ptr PublishSubMesh (SALOMEDS::Study_ptr theStudy,
+ SMESH::SMESH_Mesh_ptr theMesh,
+ SMESH::SMESH_subMesh_ptr theSubMesh,
+ GEOM::GEOM_Object_ptr theShapeObject,
+ const char* theName = 0);
+ SALOMEDS::SObject_ptr PublishGroup (SALOMEDS::Study_ptr theStudy,
+ SMESH::SMESH_Mesh_ptr theMesh,
+ SMESH::SMESH_GroupBase_ptr theGroup,
+ GEOM::GEOM_Object_ptr theShapeObject,
+ const char* theName = 0);
+ bool AddHypothesisToShape(SALOMEDS::Study_ptr theStudy,
+ SMESH::SMESH_Mesh_ptr theMesh,
+ GEOM::GEOM_Object_ptr theShapeObject,
+ SMESH::SMESH_Hypothesis_ptr theHyp);
+ bool RemoveHypothesisFromShape(SALOMEDS::Study_ptr theStudy,
+ SMESH::SMESH_Mesh_ptr theMesh,
+ GEOM::GEOM_Object_ptr theShapeObject,
+ SMESH::SMESH_Hypothesis_ptr theHyp);
+ SALOMEDS::SObject_ptr GetMeshOrSubmeshByShape (SALOMEDS::Study_ptr theStudy,
+ SMESH::SMESH_Mesh_ptr theMesh,
+ GEOM::GEOM_Object_ptr theShape);
+ static void SetName(SALOMEDS::SObject_ptr theSObject,
+ const char* theName,
+ const char* theDefaultName = 0);
+
// Get study context
StudyContext* GetCurrentStudyContext();
-
+
+ // Register an object in a StudyContext; return object id
+ int RegisterObject(CORBA::Object_ptr theObject);
+
+ // Get current study ID
+ int GetCurrentStudyID()
+ { return myCurrentStudy->_is_nil() ? -1 : myCurrentStudy->StudyId(); }
+
private:
// Create hypothesis of given type
SMESH::SMESH_Hypothesis_ptr createHypothesis( const char* theHypName,
static PortableServer::POA_var myPoa; // POA reference
static SALOME_NamingService* myNS; // Naming Service
static SALOME_LifeCycleCORBA* myLCC; // Life Cycle CORBA
-
+ static SMESH_Gen_i* mySMESHGen; // Point to last created instance of the class
::SMESH_Gen myGen; // SMESH_Gen local implementation
// hypotheses managing
GEOM_Client* myShapeReader; // Shape reader
SALOMEDS::Study_var myCurrentStudy; // Current study
+
+ // Dump Python: trace of API methods calls
+ std::map < int, Handle(TColStd_HSequenceOfAsciiString) > myPythonScripts;
};
+
+namespace SMESH
+{
+ template<class T>
+ T
+ DownCast(CORBA::Object_ptr theArg)
+ {
+ return dynamic_cast<T>(SMESH_Gen_i::GetServant(theArg).in());
+ }
+}
+
+
#endif
