FILE(GLOB MEDCALC_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
INSTALL(FILES ${MEDCALC_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+FILE(GLOB MEDCALC_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.txx")
+INSTALL(FILES ${MEDCALC_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
IF(SALOME_ENABLE_PYTHON)
INSTALL(FILES test_medcalc_components.py PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ DESTINATION ${SALOME_INSTALL_BINS}/xmed)
#include "MEDFactoryClient.hxx"
#include "MEDPresentation.hxx"
+#include "MEDPresentationException.hxx"
#include "MEDCouplingRefCountObject.hxx"
#include <iostream>
-MEDPresentation::MEDPresentation(MEDCALC::FieldHandler* fieldHdl, std::string name)
- : _fieldHandler(fieldHdl), _pipeline(0), _display(0), _properties()
+MEDPresentation::MEDPresentation(MEDPresentation::TypeID fieldHandlerId, std::string name)
+ : _fieldHandlerId(fieldHandlerId), _pipeline(0), _display(0), _properties()
{
+ MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
+ MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(fieldHandlerId);
+ MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(fieldHandler->meshid);
+ MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
+
+ _fileName = dataSHandler->uri;
+ _fieldName = fieldHandler->fieldname;
+ _fieldType = getFieldTypeString((ParaMEDMEM::TypeOfField) fieldHandler->type);
+
+ if (_fileName.substr(0, 7) != std::string("file://")) {
+ const char* msg = "Data source is not a file! Can not proceed.";
+ throw MEDPresentationException(msg);
+ }
+ _fileName = _fileName.substr(7, _fileName.size());
+
setProperty("name", name);
}
return PyDict_GetItemString(global_dict, python_var);
}
-std::string MEDPresentation::getFieldTypeString()
+std::string MEDPresentation::getFieldTypeString(ParaMEDMEM::TypeOfField fieldType)
{
- ParaMEDMEM::TypeOfField typ = (ParaMEDMEM::TypeOfField)_fieldHandler->type;
- switch(typ)
+ switch(fieldType)
{
case ParaMEDMEM::ON_CELLS:
return "CELLS";
case ParaMEDMEM::ON_NODES:
- return "NODES";
+ return "POINTS";
default:
std::cerr << "MEDPresentation::getFieldTypeString() -- Not implemented ! Gauss points?";
return "";
#ifndef SRC_MEDCALC_CMP_MEDPRESENTATION_HXX_
#define SRC_MEDCALC_CMP_MEDPRESENTATION_HXX_
+#include "MEDCouplingRefCountObject.hxx"
#include <Python.h>
#include "MEDCALC.hxx"
public:
+ typedef ::CORBA::Long TypeID;
+
virtual ~MEDPresentation() {}
void setProperty(const std::string& propName, const std::string& propValue);
const std::string getProperty(const std::string& propName);
- std::string getFieldTypeString();
protected:
- MEDPresentation(MEDCALC::FieldHandler* fieldHdl, std::string name);
+ MEDPresentation(MEDPresentation::TypeID fieldHandlerId, std::string name);
- void generatePipeline();
virtual void internalGeneratePipeline() = 0;
PyObject * getPythonObjectFromMain(const char * var);
void pushInternal(PyObject * obj, PyObject * disp = NULL);
+private:
+
+ void generatePipeline(); // reserved to friend class MEDPresentationManager
+ std::string getFieldTypeString(ParaMEDMEM::TypeOfField fieldType);
+
protected:
- ///! field reference - borrowed.
- MEDCALC::FieldHandler* _fieldHandler;
+ std::string _fileName;
+ std::string _fieldName;
+ std::string _fieldType;
+
+private:
+
+ MEDPresentation::TypeID _fieldHandlerId;
///! Pipeline elements
std::vector< PyObject * > _pipeline;
class MEDCALC_EXPORT MEDPresentationContour : public MEDPresentation
{
public:
- MEDPresentationContour(MEDCALC::FieldHandler* fieldHdl, bool wireframe) :
- MEDPresentation(fieldHdl, "MEDPresentationContour"),
- _isWireframe(wireframe)
+ MEDPresentationContour(const MEDCALC::ContourParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationContour")
{}
virtual ~MEDPresentationContour() {}
virtual void internalGeneratePipeline();
private:
- bool _isWireframe;
+ MEDCALC::ContourParameters _params;
};
#endif
#include "MEDPresentationDeflectionShape.hxx"
-#include "MEDFactoryClient.hxx"
void
MEDPresentationDeflectionShape::internalGeneratePipeline()
{
+ PyGILState_STATE _gil_state = PyGILState_Ensure();
+
+ std::string cmd = std::string("import pvsimple as pvs;");
+ cmd += std::string("__obj1 = pvs.MEDReader(FileName='") + _fileName + std::string("');");
+ cmd += std::string("__warpByVector1 = pvs.WarpByVector(Input=__obj1);");
+ cmd += std::string("__disp1 = pvs.Show(__warpByVector1);");
+ cmd += std::string("pvs.ColorBy(__disp1, ('") + _fieldType + std::string("', '") + _fieldName + std::string("'));");
+ cmd += std::string("pvs.GetActiveViewOrCreate('RenderView').ResetCamera();");
+ cmd += std::string("__disp1.RescaleTransferFunctionToDataRangeOverTime();");
+
+ //std::cerr << "Python command:" << std::endl;
+ //std::cerr << cmd << std::endl;
+ PyRun_SimpleString(cmd.c_str());
+ // Retrieve Python object for internal storage:
+ PyObject * obj = getPythonObjectFromMain("__warpByVector1");
+ PyObject * disp = getPythonObjectFromMain("__disp1");
+ pushInternal(obj, disp);
+
+ PyGILState_Release(_gil_state);
}
class MEDCALC_EXPORT MEDPresentationDeflectionShape : public MEDPresentation
{
public:
- MEDPresentationDeflectionShape(MEDCALC::FieldHandler* fieldHdl, bool wireframe) :
- MEDPresentation(fieldHdl, "MEDPresentationDeflectionShape"),
- _isWireframe(wireframe)
+ MEDPresentationDeflectionShape(const MEDCALC::DeflectionShapeParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationDeflectionShape")
{}
virtual ~MEDPresentationDeflectionShape() {}
virtual void internalGeneratePipeline();
private:
- bool _isWireframe;
+ MEDCALC::DeflectionShapeParameters _params;
};
#endif
--- /dev/null
+// Copyright (C) 2011-2016 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+#ifndef SRC_MEDCALC_CMP_MEDPRESENTATION_EXCEPTION_HXX_
+#define SRC_MEDCALC_CMP_MEDPRESENTATION_EXCEPTION_HXX_
+
+#include "MEDCALC.hxx"
+#include <iostream>
+#include <sstream>
+#include <exception>
+
+class MEDCALC_EXPORT MEDPresentationException
+ : public std::exception
+{
+public:
+
+ MEDPresentationException(const char* msg) {
+ std::ostringstream oss;
+ oss << "Error: " << msg;
+ this->_msg = oss.str();
+ }
+
+ virtual ~MEDPresentationException() throw() {}
+
+ virtual const char* what() const throw() {
+ return this->_msg.c_str();
+ }
+
+private:
+
+ std::string _msg;
+
+};
+
+#endif /* SRC_MEDCALC_CMP_MEDPRESENTATION_EXCEPTION_HXX_ */
#include "MEDPresentationManager_i.hxx"
#include "MEDFactoryClient.hxx"
-#include "MEDPresentation.hxx"
+
+// presentations
#include "MEDPresentationScalarMap.hxx"
#include "MEDPresentationContour.hxx"
#include "MEDPresentationVectorField.hxx"
#include "MEDPresentationDeflectionShape.hxx"
#include "MEDPresentationPointSprite.hxx"
+#include <iostream>
+
MEDPresentationManager_i* MEDPresentationManager_i::_instance = NULL;
MEDPresentationManager_i*
*/
}
-TypeID MEDPresentationManager_i::GenerateID()
+MEDPresentation::TypeID
+MEDPresentationManager_i::GenerateID()
{
- static TypeID START_ID = -1;
+ static MEDPresentation::TypeID START_ID = -1;
START_ID++;
return START_ID;
}
-#include <iostream>
-
void
-MEDPresentationManager_i::setPresentationProperty(TypeID presentationID, const char * propName, const char * propValue)
+MEDPresentationManager_i::setPresentationProperty(MEDPresentation::TypeID presentationID, const char * propName, const char * propValue)
{
if (_presentations.find(presentationID) != _presentations.end())
{
}
char*
-MEDPresentationManager_i::getPresentationProperty(TypeID presentationID, const char* propName)
+MEDPresentationManager_i::getPresentationProperty(MEDPresentation::TypeID presentationID, const char* propName)
{
if (_presentations.find(presentationID) != _presentations.end()) {
MEDPresentation* pres = _presentations[presentationID];
}
}
-TypeID
+MEDPresentation::TypeID
MEDPresentationManager_i::makeScalarMap(const MEDCALC::ScalarMapParameters& params)
{
- MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
-
- TypeID fieldHandlerId = params.fieldHandlerId;
- MEDCALC::MEDPresentationViewMode viewMode = params.viewMode;
-
- MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(fieldHandlerId);
- MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(fieldHandler->meshid);
- MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
-
- std::cout << "\tfieldHandlerId: " << fieldHandlerId << std::endl;
- std::cout << "\tviewMode: " << viewMode << std::endl;
- std::cout << "\tfileName: " << dataSHandler->uri << std::endl;
- std::cout << "\tfiedName: " << fieldHandler->fieldname << std::endl;
-
- // Create a new presentation instance
- TypeID newID = MEDPresentationManager_i::GenerateID();
- MEDPresentationScalarMap * presentation = new MEDPresentationScalarMap(fieldHandler, true); // on stack or on heap?? stack for now
- _presentations.insert( std::pair<TypeID, MEDPresentation *>(newID, presentation) );
-
- presentation->generatePipeline();
-
- return newID;
+ return _makePresentation<MEDPresentationScalarMap>(params);
}
-TypeID
+MEDPresentation::TypeID
MEDPresentationManager_i::makeContour(const MEDCALC::ContourParameters& params)
{
- MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
-
- TypeID fieldHandlerId = params.fieldHandlerId;
- MEDCALC::MEDPresentationViewMode viewMode = params.viewMode;
-
- MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(fieldHandlerId);
- MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(fieldHandler->meshid);
- MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
-
- std::cout << "\tfieldHandlerId: " << fieldHandlerId << std::endl;
- std::cout << "\tviewMode: " << viewMode << std::endl;
- std::cout << "\tfileName: " << dataSHandler->uri << std::endl;
- std::cout << "\tfiedName: " << fieldHandler->fieldname << std::endl;
-
- // Create a new presentation instance
- TypeID newID = MEDPresentationManager_i::GenerateID();
- MEDPresentationContour * presentation = new MEDPresentationContour(fieldHandler, true); // on stack or on heap?? stack for now
- _presentations.insert( std::pair<TypeID, MEDPresentation *>(newID, presentation) );
-
- presentation->generatePipeline();
-
- return newID;
+ return _makePresentation<MEDPresentationContour>(params);
}
-TypeID
+MEDPresentation::TypeID
MEDPresentationManager_i::makeVectorField(const MEDCALC::VectorFieldParameters& params)
{
- MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
-
- TypeID fieldHandlerId = params.fieldHandlerId;
- MEDCALC::MEDPresentationViewMode viewMode = params.viewMode;
-
- MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(fieldHandlerId);
- MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(fieldHandler->meshid);
- MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
-
- std::cout << "\tfieldHandlerId: " << fieldHandlerId << std::endl;
- std::cout << "\tviewMode: " << viewMode << std::endl;
- std::cout << "\tfileName: " << dataSHandler->uri << std::endl;
- std::cout << "\tfiedName: " << fieldHandler->fieldname << std::endl;
-
- // Create a new presentation instance
- TypeID newID = MEDPresentationManager_i::GenerateID();
- MEDPresentationVectorField * presentation = new MEDPresentationVectorField(fieldHandler, true); // on stack or on heap?? stack for now
- _presentations.insert( std::pair<TypeID, MEDPresentation *>(newID, presentation) );
-
- presentation->generatePipeline();
-
- return newID;
+ return _makePresentation<MEDPresentationVectorField>(params);
}
-TypeID
+MEDPresentation::TypeID
MEDPresentationManager_i::makeSlices(const MEDCALC::SlicesParameters& params)
{
- MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
-
- TypeID fieldHandlerId = params.fieldHandlerId;
- MEDCALC::MEDPresentationViewMode viewMode = params.viewMode;
-
- MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(fieldHandlerId);
- MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(fieldHandler->meshid);
- MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
-
- std::cout << "\tfieldHandlerId: " << fieldHandlerId << std::endl;
- std::cout << "\tviewMode: " << viewMode << std::endl;
- std::cout << "\tfileName: " << dataSHandler->uri << std::endl;
- std::cout << "\tfiedName: " << fieldHandler->fieldname << std::endl;
-
- // Create a new presentation instance
- TypeID newID = MEDPresentationManager_i::GenerateID();
- MEDPresentationSlices * presentation = new MEDPresentationSlices(fieldHandler, true); // on stack or on heap?? stack for now
- _presentations.insert( std::pair<TypeID, MEDPresentation *>(newID, presentation) );
-
- presentation->generatePipeline();
-
- return newID;
+ return _makePresentation<MEDPresentationSlices>(params);
}
-TypeID
+MEDPresentation::TypeID
MEDPresentationManager_i::makeDeflectionShape(const MEDCALC::DeflectionShapeParameters& params)
{
- MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
-
- TypeID fieldHandlerId = params.fieldHandlerId;
- MEDCALC::MEDPresentationViewMode viewMode = params.viewMode;
-
- MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(fieldHandlerId);
- MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(fieldHandler->meshid);
- MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
-
- std::cout << "\tfieldHandlerId: " << fieldHandlerId << std::endl;
- std::cout << "\tviewMode: " << viewMode << std::endl;
- std::cout << "\tfileName: " << dataSHandler->uri << std::endl;
- std::cout << "\tfiedName: " << fieldHandler->fieldname << std::endl;
-
- // Create a new presentation instance
- TypeID newID = MEDPresentationManager_i::GenerateID();
- MEDPresentationDeflectionShape * presentation = new MEDPresentationDeflectionShape(fieldHandler, true); // on stack or on heap?? stack for now
- _presentations.insert( std::pair<TypeID, MEDPresentation *>(newID, presentation) );
-
- presentation->generatePipeline();
-
- return newID;
+ return _makePresentation<MEDPresentationDeflectionShape>(params);
}
-TypeID
+MEDPresentation::TypeID
MEDPresentationManager_i::makePointSprite(const MEDCALC::PointSpriteParameters& params)
{
- MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
-
- TypeID fieldHandlerId = params.fieldHandlerId;
- MEDCALC::MEDPresentationViewMode viewMode = params.viewMode;
-
- MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(fieldHandlerId);
- MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(fieldHandler->meshid);
- MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
-
- std::cout << "\tfieldHandlerId: " << fieldHandlerId << std::endl;
- std::cout << "\tviewMode: " << viewMode << std::endl;
- std::cout << "\tfileName: " << dataSHandler->uri << std::endl;
- std::cout << "\tfiedName: " << fieldHandler->fieldname << std::endl;
-
- // Create a new presentation instance
- TypeID newID = MEDPresentationManager_i::GenerateID();
- MEDPresentationPointSprite * presentation = new MEDPresentationPointSprite(fieldHandler, true); // on stack or on heap?? stack for now
- _presentations.insert( std::pair<TypeID, MEDPresentation *>(newID, presentation) );
-
- presentation->generatePipeline();
-
- return newID;
+ return _makePresentation<MEDPresentationPointSprite>(params);
}
#include "SALOME_GenericObj_i.hh"
#include "MEDDataManager_i.hxx"
+#include "MEDPresentation.hxx"
#include "MEDCALC.hxx"
#include <vector>
#include <string>
-typedef ::CORBA::Long TypeID;
-
-class MEDPresentation;
-
class MEDPresentationManager_i: public POA_MEDCALC::MEDPresentationManager,
public SALOME::GenericObj_i
{
static MEDPresentationManager_i* getInstance();
- MEDCALC_EXPORT TypeID makeScalarMap(const MEDCALC::ScalarMapParameters&);
- MEDCALC_EXPORT TypeID makeContour(const MEDCALC::ContourParameters&);
- MEDCALC_EXPORT TypeID makeVectorField(const MEDCALC::VectorFieldParameters&);
- MEDCALC_EXPORT TypeID makeSlices(const MEDCALC::SlicesParameters&);
- MEDCALC_EXPORT TypeID makeDeflectionShape(const MEDCALC::DeflectionShapeParameters&);
- MEDCALC_EXPORT TypeID makePointSprite(const MEDCALC::PointSpriteParameters&);
+ MEDCALC_EXPORT MEDPresentation::TypeID makeScalarMap(const MEDCALC::ScalarMapParameters&);
+ MEDCALC_EXPORT MEDPresentation::TypeID makeContour(const MEDCALC::ContourParameters&);
+ MEDCALC_EXPORT MEDPresentation::TypeID makeVectorField(const MEDCALC::VectorFieldParameters&);
+ MEDCALC_EXPORT MEDPresentation::TypeID makeSlices(const MEDCALC::SlicesParameters&);
+ MEDCALC_EXPORT MEDPresentation::TypeID makeDeflectionShape(const MEDCALC::DeflectionShapeParameters&);
+ MEDCALC_EXPORT MEDPresentation::TypeID makePointSprite(const MEDCALC::PointSpriteParameters&);
- MEDCALC_EXPORT void setPresentationProperty(TypeID presentationID, const char * propName, const char * propValue);
- MEDCALC_EXPORT char* getPresentationProperty(TypeID presentationID, const char* propName);
+ MEDCALC_EXPORT void setPresentationProperty(MEDPresentation::TypeID presentationID, const char * propName, const char * propValue);
+ MEDCALC_EXPORT char* getPresentationProperty(MEDPresentation::TypeID presentationID, const char* propName);
private:
MEDPresentationManager_i();
virtual ~MEDPresentationManager_i();
+ static MEDPresentation::TypeID GenerateID();
+
+ // Create a new presentation instance and return its unique ID
+ template<typename PresentationType, typename PresentationParameters>
+ MEDPresentation::TypeID _makePresentation(PresentationParameters params);
+
private :
// The MEDPresentationManager is a singleton, whose instance can be obtained
// using the getInstance static method.
static MEDPresentationManager_i * _instance;
- static TypeID GenerateID();
// Owns a list of MEDPresentation objects
- std::map< TypeID, MEDPresentation * > _presentations;
+ std::map< MEDPresentation::TypeID, MEDPresentation * > _presentations;
};
+#include "MEDPresentationManager_i.txx"
+
#endif // _MED_PRESENTATION_MANAGER_I_HXX_
--- /dev/null
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef _MED_PRESENTATION_MANAGER_I_TPP_
+#define _MED_PRESENTATION_MANAGER_I_TPP_
+
+template<typename PresentationType, typename PresentationParameters>
+MEDPresentation::TypeID
+MEDPresentationManager_i::_makePresentation(PresentationParameters params)
+{
+ // Create a new presentation instance
+ PresentationType* presentation = NULL;
+ try {
+ presentation = new PresentationType(params); // on stack or on heap?? stack for now
+ }
+ catch (const std::exception& e) {
+ std::cerr << e.what() << std::endl;
+ return -1;
+ }
+
+ MEDPresentation::TypeID newID = MEDPresentationManager_i::GenerateID();
+ _presentations.insert( std::pair<MEDPresentation::TypeID, MEDPresentation *>(newID, presentation) );
+ presentation->generatePipeline();
+ return newID;
+}
+
+#endif // _MED_PRESENTATION_MANAGER_I_TPP_
#include "MEDPresentationPointSprite.hxx"
-#include "MEDFactoryClient.hxx"
void
MEDPresentationPointSprite::internalGeneratePipeline()
{
+ PyGILState_STATE _gil_state = PyGILState_Ensure();
+
+ std::string cmd = std::string("import pvsimple as pvs;");
+ cmd += std::string("__obj1 = pvs.MEDReader(FileName='") + _fileName + std::string("');");
+ cmd += std::string("__disp1 = pvs.Show(__obj1);");
+ cmd += std::string("pvs.ColorBy(__disp1, ('") + _fieldType + std::string("', '") + _fieldName + std::string("'));");
+ cmd += std::string("pvs.GetActiveViewOrCreate('RenderView').ResetCamera();");
+ cmd += std::string("__disp1.RescaleTransferFunctionToDataRangeOverTime();");
+ cmd += std::string("__disp1.SetRepresentationType('Point Sprite');");
+
+ //std::cerr << "Python command:" << std::endl;
+ //std::cerr << cmd << std::endl;
+ PyRun_SimpleString(cmd.c_str());
+ // Retrieve Python object for internal storage:
+ PyObject * obj = getPythonObjectFromMain("__obj1");
+ PyObject * disp = getPythonObjectFromMain("__disp1");
+ pushInternal(obj, disp);
+
+ PyGILState_Release(_gil_state);
}
class MEDCALC_EXPORT MEDPresentationPointSprite : public MEDPresentation
{
public:
- MEDPresentationPointSprite(MEDCALC::FieldHandler* fieldHdl, bool wireframe) :
- MEDPresentation(fieldHdl, "MEDPresentationPointSprite"),
- _isWireframe(wireframe)
+ MEDPresentationPointSprite(const MEDCALC::PointSpriteParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationPointSprite")
{}
virtual ~MEDPresentationPointSprite() {}
virtual void internalGeneratePipeline();
private:
- bool _isWireframe;
+ MEDCALC::PointSpriteParameters _params;
};
#endif
#include "MEDPresentationScalarMap.hxx"
-#include "MEDFactoryClient.hxx"
-
-#include <iostream>
void
MEDPresentationScalarMap::internalGeneratePipeline()
{
- MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
+ //MEDPresentation::TypeID fieldHandlerId = params.fieldHandlerId;
+ //MEDCALC::MEDPresentationViewMode viewMode = params.viewMode;
- MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(_fieldHandler->meshid);
- MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
+ // :TODO: consider viewMode
- std::string fileName(dataSHandler->uri);
- std::string fieldName(_fieldHandler->fieldname);
- std::string fieldType = getFieldTypeString();
+ /*
+ MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
+ MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(fieldHandlerId);
- std::cout << "Generating pipeline for SCALAR MAP:" <<std::endl;
- std::cout << "\tfileName: " << fileName << std::endl;
- std::cout << "\tfiedName: " << fieldName << std::endl;
- if (fileName.substr(0, 7) != std::string("file://"))
- {
- std::cerr << "\tData source is not a file! Can not proceed." << std::endl;
- return;
- }
+ std::cout << "\tfieldHandlerId: " << fieldHandlerId << std::endl;
+ std::cout << "\tviewMode: " << viewMode << std::endl;
- fileName = fileName.substr(7, fileName.size());
- std::cout << "\tfileName: " << fileName << std::endl;
+ MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(fieldHandler->meshid);
+ MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
+ std::cout << "\tfileName: " << dataSHandler->uri << std::endl;
+ std::cout << "\tfiedName: " << fieldHandler->fieldname << std::endl;
+ */
PyGILState_STATE _gil_state = PyGILState_Ensure();
std::string cmd = std::string("import pvsimple as pvs;");
- cmd += std::string("__obj1 = pvs.MEDReader(FileName='") + fileName + std::string("');");
+ cmd += std::string("__obj1 = pvs.MEDReader(FileName='") + _fileName + std::string("');");
cmd += std::string("__disp1 = pvs.Show(__obj1);");
- cmd += std::string("pvs.ColorBy(__disp1, ('") + fieldType + std::string("', '") + fieldName + std::string("'));");
+ cmd += std::string("pvs.ColorBy(__disp1, ('") + _fieldType + std::string("', '") + _fieldName + std::string("'));");
cmd += std::string("pvs.GetActiveViewOrCreate('RenderView').ResetCamera();");
cmd += std::string("__disp1.RescaleTransferFunctionToDataRangeOverTime();");
class MEDCALC_EXPORT MEDPresentationScalarMap : public MEDPresentation
{
public:
- MEDPresentationScalarMap(MEDCALC::FieldHandler* fieldHdl, bool wireframe) :
- MEDPresentation(fieldHdl, "MEDPresentationScalarMap"),
- _isWireframe(wireframe)
+ MEDPresentationScalarMap(const MEDCALC::ScalarMapParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationScalarMap")
{}
virtual ~MEDPresentationScalarMap() {}
virtual void internalGeneratePipeline();
private:
- bool _isWireframe;
+ MEDCALC::ScalarMapParameters _params;
};
#endif
class MEDCALC_EXPORT MEDPresentationSlices : public MEDPresentation
{
public:
- MEDPresentationSlices(MEDCALC::FieldHandler* fieldHdl, bool wireframe) :
- MEDPresentation(fieldHdl, "MEDPresentationSlices"),
- _isWireframe(wireframe)
+ MEDPresentationSlices(const MEDCALC::SlicesParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationSlices")
{}
virtual ~MEDPresentationSlices() {}
virtual void internalGeneratePipeline();
private:
- bool _isWireframe;
+ MEDCALC::SlicesParameters _params;
};
#endif
#include "MEDPresentationVectorField.hxx"
-#include "MEDFactoryClient.hxx"
void
MEDPresentationVectorField::internalGeneratePipeline()
{
+ PyGILState_STATE _gil_state = PyGILState_Ensure();
+
+ std::string cmd = std::string("import pvsimple as pvs;");
+ cmd += std::string("__obj1 = pvs.MEDReader(FileName='") + _fileName + std::string("');");
+ cmd += std::string("__disp1 = pvs.Show(__obj1);");
+ cmd += std::string("pvs.ColorBy(__disp1, ('") + _fieldType + std::string("', '") + _fieldName + std::string("'));");
+ cmd += std::string("pvs.GetActiveViewOrCreate('RenderView').ResetCamera();");
+ cmd += std::string("__disp1.RescaleTransferFunctionToDataRangeOverTime();");
+ cmd += std::string("__disp1.SetRepresentationType('3D Glyphs');");
+
+ //std::cerr << "Python command:" << std::endl;
+ //std::cerr << cmd << std::endl;
+ PyRun_SimpleString(cmd.c_str());
+ // Retrieve Python object for internal storage:
+ PyObject * obj = getPythonObjectFromMain("__obj1");
+ PyObject * disp = getPythonObjectFromMain("__disp1");
+ pushInternal(obj, disp);
+
+ PyGILState_Release(_gil_state);
}
class MEDCALC_EXPORT MEDPresentationVectorField : public MEDPresentation
{
public:
- MEDPresentationVectorField(MEDCALC::FieldHandler* fieldHdl, bool wireframe) :
- MEDPresentation(fieldHdl, "MEDPresentationVectorField"),
- _isWireframe(wireframe)
+ MEDPresentationVectorField(const MEDCALC::VectorFieldParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationVectorField")
{}
virtual ~MEDPresentationVectorField() {}
virtual void internalGeneratePipeline();
private:
- bool _isWireframe;
+ MEDCALC::VectorFieldParameters _params;
};
#endif
#
def MakeVectorField(proxy, viewMode=MEDCALC.VIEW_MODE_REPLACE):
- print "Not implemented yet"
- #params = MEDCALC.VectorFieldParameters(proxy.id, viewMode)
- #presentation_id = __manager.makeVectorField(params)
- #notifyGui_addPresentation(proxy.id, presentation_id)
+ params = MEDCALC.VectorFieldParameters(proxy.id, viewMode)
+ presentation_id = __manager.makeVectorField(params)
+ notifyGui_addPresentation(proxy.id, presentation_id)
#
def MakeSlices(proxy, viewMode=MEDCALC.VIEW_MODE_REPLACE):
#
def MakeDeflectionShape(proxy, viewMode=MEDCALC.VIEW_MODE_REPLACE):
- print "Not implemented yet"
- #params = MEDCALC.DeflectionShapeParameters(proxy.id, viewMode)
- #presentation_id = __manager.makeDeflectionShape(params)
- #notifyGui_addPresentation(proxy.id, presentation_id)
+ params = MEDCALC.DeflectionShapeParameters(proxy.id, viewMode)
+ presentation_id = __manager.makeDeflectionShape(params)
+ notifyGui_addPresentation(proxy.id, presentation_id)
#
def MakePointSprite(proxy, viewMode=MEDCALC.VIEW_MODE_REPLACE):
- print "Not implemented yet"
- #params = MEDCALC.PointSpriteParameters(proxy.id, viewMode)
- #presentation_id = __manager.makePointSprite(params)
- #notifyGui_addPresentation(proxy.id, presentation_id)
+ params = MEDCALC.PointSpriteParameters(proxy.id, viewMode)
+ presentation_id = __manager.makePointSprite(params)
+ notifyGui_addPresentation(proxy.id, presentation_id)
#
