-// Copyright (C) 2005-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2005-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
MEDPresentationViewMode viewMode;
};
+ // A contour is an isoline in 2D and an isosurface in 3D
+ struct ContourParameters {
+ long fieldHandlerId;
+ MEDPresentationViewMode viewMode;
+ };
+
+ struct VectorFieldParameters {
+ long fieldHandlerId;
+ MEDPresentationViewMode viewMode;
+ };
+
+ struct SlicesParameters {
+ long fieldHandlerId;
+ MEDPresentationViewMode viewMode;
+ };
+
+ struct DeflectionShapeParameters {
+ long fieldHandlerId;
+ MEDPresentationViewMode viewMode;
+ };
+
+ struct PointSpriteParameters {
+ long fieldHandlerId;
+ MEDPresentationViewMode viewMode;
+ };
+
interface MEDPresentationManager : SALOME::GenericObj
{
long makeScalarMap(in ScalarMapParameters params);
+ long makeContour(in ContourParameters params);
+ long makeVectorField(in VectorFieldParameters params);
+ long makeSlices(in SlicesParameters params);
+ long makeDeflectionShape(in DeflectionShapeParameters params);
+ long makePointSprite(in PointSpriteParameters params);
+
void setPresentationProperty(in long presId, in string propName, in string propValue);
string getPresentationProperty(in long presId, in string propName);
-# Copyright (C) 2012-2015 CEA/DEN, EDF R&D
+# Copyright (C) 2012-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
MEDCalculator_i.cxx
MEDPresentationManager_i.cxx
MEDPresentation.cxx
+ # presentations
+ MEDPresentationScalarMap.cxx
+ MEDPresentationContour.cxx
+ MEDPresentationVectorField.cxx
+ MEDPresentationSlices.cxx
+ MEDPresentationDeflectionShape.cxx
+ MEDPresentationPointSprite.cxx
)
SET(MEDFactoryEngine_SOURCES
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)
-// Copyright (C) 2011-2015 CEA/DEN, EDF R&D
+// 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
#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((MEDCoupling::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(MEDCoupling::TypeOfField fieldType)
{
- MEDCoupling::TypeOfField typ = (MEDCoupling::TypeOfField)_fieldHandler->type;
- switch(typ)
+ switch(fieldType)
{
case MEDCoupling::ON_CELLS:
return "CELLS";
case MEDCoupling::ON_NODES:
- return "NODES";
+ return "POINTS";
default:
std::cerr << "MEDPresentation::getFieldTypeString() -- Not implemented ! Gauss points?";
return "";
}
}
-
-
-void MEDPresentationScalarMap::internalGeneratePipeline()
-{
- MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
-
- MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(_fieldHandler->meshid);
- MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
-
- std::string fileName(dataSHandler->uri);
- std::string fieldName(_fieldHandler->fieldname);
- std::string fieldType = getFieldTypeString();
-
- 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;
- }
-
- fileName = fileName.substr(7, fileName.size());
- std::cout << "\tfileName: " << fileName << std::endl;
-
- PyGILState_STATE _gil_state = PyGILState_Ensure();
-
- PyRun_SimpleString("print 'hello world'");
- std::string cmd = std::string(
- "import pvsimple as pvs;"
- "__obj1 = pvs.MEDReader(FileName='") + fileName + std::string("');"
- "__disp1 = pvs.Show(__obj1);"
- "pvs.ColorBy(__disp1, ('") + fieldType + std::string("', '") + fieldName + std::string("'));"
- "pvs.GetActiveViewOrCreate('RenderView').ResetCamera()");
-
- 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);
-}
-// Copyright (C) 2011-2015 CEA/DEN, EDF R&D
+// 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
#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(MEDCoupling::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;
std::map<std::string, std::string> _properties;
};
-class MEDCALC_EXPORT MEDPresentationScalarMap : public MEDPresentation
-{
-public:
- MEDPresentationScalarMap(MEDCALC::FieldHandler* fieldHdl, bool wireframe) :
- MEDPresentation(fieldHdl, "MEDPresentationScalarMap"),
- _isWireframe(wireframe)
- {}
- virtual ~MEDPresentationScalarMap() {}
-
-protected:
- virtual void internalGeneratePipeline();
-
-private:
- bool _isWireframe;
-};
-
#endif /* SRC_MEDCALC_CMP_MEDPRESENTATION_HXX_ */
--- /dev/null
+#include "MEDPresentationContour.hxx"
+#include "MEDFactoryClient.hxx"
+
+void
+MEDPresentationContour::internalGeneratePipeline()
+{
+}
--- /dev/null
+// Copyright (C) 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_CONTOUR_HXX_
+#define SRC_MEDCALC_CMP_MEDPRESENTATION_CONTOUR_HXX_
+
+#include "MEDCALC.hxx"
+#include "MEDPresentation.hxx"
+
+class MEDCALC_EXPORT MEDPresentationContour : public MEDPresentation
+{
+public:
+ MEDPresentationContour(const MEDCALC::ContourParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationContour")
+ {}
+ virtual ~MEDPresentationContour() {}
+
+protected:
+ virtual void internalGeneratePipeline();
+
+private:
+ MEDCALC::ContourParameters _params;
+};
+
+#endif
--- /dev/null
+#include "MEDPresentationDeflectionShape.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);
+}
--- /dev/null
+// Copyright (C) 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_DEFLECTIONSHAPE_HXX_
+#define SRC_MEDCALC_CMP_MEDPRESENTATION_DEFLECTIONSHAPE_HXX_
+
+#include "MEDCALC.hxx"
+#include "MEDPresentation.hxx"
+
+class MEDCALC_EXPORT MEDPresentationDeflectionShape : public MEDPresentation
+{
+public:
+ MEDPresentationDeflectionShape(const MEDCALC::DeflectionShapeParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationDeflectionShape")
+ {}
+ virtual ~MEDPresentationDeflectionShape() {}
+
+protected:
+ virtual void internalGeneratePipeline();
+
+private:
+ 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_ */
-// Copyright (C) 2011-2015 CEA/DEN, EDF R&D
+// 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
#include "MEDPresentationManager_i.hxx"
#include "MEDFactoryClient.hxx"
-#include "MEDPresentation.hxx"
+
+// presentations
+#include "MEDPresentationScalarMap.hxx"
+#include "MEDPresentationContour.hxx"
+#include "MEDPresentationVectorField.hxx"
+#include "MEDPresentationSlices.hxx"
+#include "MEDPresentationDeflectionShape.hxx"
+#include "MEDPresentationPointSprite.hxx"
+
+#include <iostream>
MEDPresentationManager_i* MEDPresentationManager_i::_instance = NULL;
*/
}
-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;
+ return _makePresentation<MEDPresentationScalarMap>(params);
+}
- MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(fieldHandlerId);
- MEDCALC::MeshHandler* meshHandler = dataManager->getMesh(fieldHandler->meshid);
- MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
+MEDPresentation::TypeID
+MEDPresentationManager_i::makeContour(const MEDCALC::ContourParameters& params)
+{
+ return _makePresentation<MEDPresentationContour>(params);
+}
- 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;
+MEDPresentation::TypeID
+MEDPresentationManager_i::makeVectorField(const MEDCALC::VectorFieldParameters& params)
+{
+ return _makePresentation<MEDPresentationVectorField>(params);
+}
- // Create a new presentation instance
- TypeID newID = MEDPresentationManager_i::GenerateID();
- MEDPresentationScalarMap * scalarMap = new MEDPresentationScalarMap(fieldHandler, true); // on stack or on heap?? stack for now
- _presentations.insert( std::pair<TypeID, MEDPresentation *>(newID, scalarMap) );
+MEDPresentation::TypeID
+MEDPresentationManager_i::makeSlices(const MEDCALC::SlicesParameters& params)
+{
+ return _makePresentation<MEDPresentationSlices>(params);
+}
- scalarMap->generatePipeline();
+MEDPresentation::TypeID
+MEDPresentationManager_i::makeDeflectionShape(const MEDCALC::DeflectionShapeParameters& params)
+{
+ return _makePresentation<MEDPresentationDeflectionShape>(params);
+}
- return newID;
+MEDPresentation::TypeID
+MEDPresentationManager_i::makePointSprite(const MEDCALC::PointSpriteParameters& params)
+{
+ return _makePresentation<MEDPresentationPointSprite>(params);
}
-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D
+// 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
#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 void setPresentationProperty(TypeID presentationID, const char * propName, const char * propValue);
- MEDCALC_EXPORT char* getPresentationProperty(TypeID presentationID, const char* propName);
+ 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(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_
--- /dev/null
+#include "MEDPresentationPointSprite.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);
+}
--- /dev/null
+// Copyright (C) 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_POINTSPRITE_HXX_
+#define SRC_MEDCALC_CMP_MEDPRESENTATION_POINTSPRITE_HXX_
+
+#include "MEDCALC.hxx"
+#include "MEDPresentation.hxx"
+
+class MEDCALC_EXPORT MEDPresentationPointSprite : public MEDPresentation
+{
+public:
+ MEDPresentationPointSprite(const MEDCALC::PointSpriteParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationPointSprite")
+ {}
+ virtual ~MEDPresentationPointSprite() {}
+
+protected:
+ virtual void internalGeneratePipeline();
+
+private:
+ MEDCALC::PointSpriteParameters _params;
+};
+
+#endif
--- /dev/null
+#include "MEDPresentationScalarMap.hxx"
+
+void
+MEDPresentationScalarMap::internalGeneratePipeline()
+{
+ //MEDPresentation::TypeID fieldHandlerId = params.fieldHandlerId;
+ //MEDCALC::MEDPresentationViewMode viewMode = params.viewMode;
+
+ // :TODO: consider viewMode
+
+ /*
+ MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
+ MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(fieldHandlerId);
+
+ std::cout << "\tfieldHandlerId: " << fieldHandlerId << std::endl;
+ std::cout << "\tviewMode: " << viewMode << 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("__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();");
+
+ //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);
+}
--- /dev/null
+// Copyright (C) 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_SCALARMAP_HXX_
+#define SRC_MEDCALC_CMP_MEDPRESENTATION_SCALARMAP_HXX_
+
+#include "MEDCALC.hxx"
+#include "MEDPresentation.hxx"
+
+class MEDCALC_EXPORT MEDPresentationScalarMap : public MEDPresentation
+{
+public:
+ MEDPresentationScalarMap(const MEDCALC::ScalarMapParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationScalarMap")
+ {}
+ virtual ~MEDPresentationScalarMap() {}
+
+protected:
+ virtual void internalGeneratePipeline();
+
+private:
+ MEDCALC::ScalarMapParameters _params;
+};
+
+#endif
--- /dev/null
+#include "MEDPresentationSlices.hxx"
+#include "MEDFactoryClient.hxx"
+
+void
+MEDPresentationSlices::internalGeneratePipeline()
+{
+}
--- /dev/null
+// Copyright (C) 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_SLICES_HXX_
+#define SRC_MEDCALC_CMP_MEDPRESENTATION_SLICES_HXX_
+
+#include "MEDCALC.hxx"
+#include "MEDPresentation.hxx"
+
+class MEDCALC_EXPORT MEDPresentationSlices : public MEDPresentation
+{
+public:
+ MEDPresentationSlices(const MEDCALC::SlicesParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationSlices")
+ {}
+ virtual ~MEDPresentationSlices() {}
+
+protected:
+ virtual void internalGeneratePipeline();
+
+private:
+ MEDCALC::SlicesParameters _params;
+};
+
+#endif
--- /dev/null
+#include "MEDPresentationVectorField.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);
+}
--- /dev/null
+// Copyright (C) 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_VECTORFIELD_HXX_
+#define SRC_MEDCALC_CMP_MEDPRESENTATION_VECTORFIELD_HXX_
+
+#include "MEDCALC.hxx"
+#include "MEDPresentation.hxx"
+
+class MEDCALC_EXPORT MEDPresentationVectorField : public MEDPresentation
+{
+public:
+ MEDPresentationVectorField(const MEDCALC::VectorFieldParameters& params) :
+ MEDPresentation(params.fieldHandlerId, "MEDPresentationVectorField")
+ {}
+ virtual ~MEDPresentationVectorField() {}
+
+protected:
+ virtual void internalGeneratePipeline();
+
+private:
+ MEDCALC::VectorFieldParameters _params;
+};
+
+#endif
-# Copyright (C) 2012-2015 CEA/DEN, EDF R&D
+# Copyright (C) 2012-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
${Boost_INCLUDE_DIRS}
${PTHREAD_INCLUDE_DIR}
${GUI_INCLUDE_DIRS}
+ ${MEDCOUPLING_INCLUDE_DIRS}
${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/dialogs
${CMAKE_CURRENT_BINARY_DIR}/dialogs
-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D
+// 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
actionId = _salomeModule->createStandardAction(label,this,SLOT(OnVisualizeScalarMap()),icon);
_salomeModule->addActionInPopupMenu(actionId, tr("LAB_VISUALIZE"));
+ label = tr("LAB_VISUALIZE_CONTOUR");
+ icon = tr("ICO_DATASOURCE_VIEW");
+ actionId = _salomeModule->createStandardAction(label,this,SLOT(OnVisualizeContour()),icon);
+ _salomeModule->addActionInPopupMenu(actionId, tr("LAB_VISUALIZE"));
+
+ label = tr("LAB_VISUALIZE_VECTORFIELD");
+ icon = tr("ICO_DATASOURCE_VIEW");
+ actionId = _salomeModule->createStandardAction(label,this,SLOT(OnVisualizeVectorField()),icon);
+ _salomeModule->addActionInPopupMenu(actionId, tr("LAB_VISUALIZE"));
+
+ label = tr("LAB_VISUALIZE_SLICES");
+ icon = tr("ICO_DATASOURCE_VIEW");
+ actionId = _salomeModule->createStandardAction(label,this,SLOT(OnVisualizeSlices()),icon);
+ _salomeModule->addActionInPopupMenu(actionId, tr("LAB_VISUALIZE"));
+
+ label = tr("LAB_VISUALIZE_DEFLECTIONSHAPE");
+ icon = tr("ICO_DATASOURCE_VIEW");
+ actionId = _salomeModule->createStandardAction(label,this,SLOT(OnVisualizeDeflectionShape()),icon);
+ _salomeModule->addActionInPopupMenu(actionId, tr("LAB_VISUALIZE"));
+
+ label = tr("LAB_VISUALIZE_POINTSPRITE");
+ icon = tr("ICO_DATASOURCE_VIEW");
+ actionId = _salomeModule->createStandardAction(label,this,SLOT(OnVisualizePointSprite()),icon);
+ _salomeModule->addActionInPopupMenu(actionId, tr("LAB_VISUALIZE"));
+
// Use in workspace
label = tr("LAB_USE_IN_WORKSPACE");
icon = tr("ICO_DATASOURCE_USE");
this->visualize(DatasourceEvent::EVENT_VIEW_OBJECT_SCALAR_MAP);
}
+void DatasourceController::OnVisualizeContour() {
+ this->visualize(DatasourceEvent::EVENT_VIEW_OBJECT_CONTOUR);
+}
+
+void DatasourceController::OnVisualizeVectorField() {
+ this->visualize(DatasourceEvent::EVENT_VIEW_OBJECT_VECTOR_FIELD);
+}
+
+void DatasourceController::OnVisualizeSlices() {
+ this->visualize(DatasourceEvent::EVENT_VIEW_OBJECT_SLICES);
+}
+
+void DatasourceController::OnVisualizeDeflectionShape() {
+ this->visualize(DatasourceEvent::EVENT_VIEW_OBJECT_DEFLECTION_SHAPE);
+}
+
+void DatasourceController::OnVisualizePointSprite() {
+ this->visualize(DatasourceEvent::EVENT_VIEW_OBJECT_POINT_SPRITE);
+}
+
void DatasourceController::OnUseInWorkspace() {
// We need a studyEditor updated on the active study
_studyEditor->updateActiveStudy();
-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D
+// 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
EVENT_IMPORT_OBJECT, // Simply import the object in the workspace
EVENT_USE_OBJECT, // Import in the workspace AND define a proxy
// variable in the tui console to use it
+ // presentations
+ EVENT_VIEW_OBJECT_CONTOUR,
+ EVENT_VIEW_OBJECT_DEFLECTION_SHAPE,
+ EVENT_VIEW_OBJECT_POINT_SPRITE,
EVENT_VIEW_OBJECT_SCALAR_MAP,
+ EVENT_VIEW_OBJECT_SLICES,
+ EVENT_VIEW_OBJECT_VECTOR_FIELD,
// these ones forward actions to workspace (and then to python console)
EVENT_ADD_DATASOURCE,
EVENT_ADD_IMAGE_AS_DATASOURCE,
void OnAddImagesource();
void OnExpandField();
void OnVisualizeScalarMap();
+ void OnVisualizeContour();
+ void OnVisualizeVectorField();
+ void OnVisualizeSlices();
+ void OnVisualizeDeflectionShape();
+ void OnVisualizePointSprite();
void OnUseInWorkspace();
void OnChangeUnderlyingMesh();
void OnInterpolateField();
<name>DatasourceController</name>
<message>
<source>MEDPresentationScalarMap</source>
- <translation>Scalar Map</translation>
+ <translation>Scalar map</translation>
+ </message>
+ <message>
+ <source>MEDPresentationContour</source>
+ <translation>Contour</translation>
+ </message>
+ <message>
+ <source>MEDPresentationVectorField</source>
+ <translation>Vector field</translation>
+ </message>
+ <message>
+ <source>MEDPresentationSlices</source>
+ <translation>Slices</translation>
+ </message>
+ <message>
+ <source>MEDPresentationDeflectionShape</source>
+ <translation>Deflection shape</translation>
+ </message>
+ <message>
+ <source>MEDPresentationPointSprite</source>
+ <translation>Point sprite</translation>
</message>
<message>
<location filename="MEDCALC/gui/DatasourceController.cxx" line="45"/>
<source>LAB_VISUALIZE_SCALARMAP</source>
<translation>Scalar map</translation>
</message>
+ <message>
+ <source>LAB_VISUALIZE_CONTOUR</source>
+ <translation>Contour</translation>
+ </message>
+ <message>
+ <source>LAB_VISUALIZE_VECTORFIELD</source>
+ <translation>Vector field</translation>
+ </message>
+ <message>
+ <source>LAB_VISUALIZE_SLICES</source>
+ <translation>Slices</translation>
+ </message>
+ <message>
+ <source>LAB_VISUALIZE_DEFLECTIONSHAPE</source>
+ <translation>Deflection shape</translation>
+ </message>
+ <message>
+ <source>LAB_VISUALIZE_POINTSPRITE</source>
+ <translation>Point sprite</translation>
+ </message>
<message>
<location filename="MEDCALC/gui/DatasourceController.cxx" line="69"/>
<source>LAB_VISUALIZE</source>
<source>MEDPresentationScalarMap</source>
<translation>Carte scalaire</translation>
</message>
+ <message>
+ <source>MEDPresentationContour</source>
+ <translation>Contour</translation>
+ </message>
+ <message>
+ <source>MEDPresentationVectorField</source>
+ <translation>Champ de vecteurs</translation>
+ </message>
+ <message>
+ <source>MEDPresentationSlices</source>
+ <translation>Coupes</translation>
+ </message>
+ <message>
+ <source>MEDPresentationDeflectionShape</source>
+ <translation>Déformée</translation>
+ </message>
+ <message>
+ <source>MEDPresentationPointSprite</source>
+ <translation>Point Sprite</translation>
+ </message>
<message>
<location filename="MEDCALC/gui/DatasourceController.cxx" line="45"/>
<source>LAB_ADD_DATA_SOURCE</source>
<source>LAB_VISUALIZE_SCALARMAP</source>
<translation>Carte scalaire</translation>
</message>
+ <message>
+ <source>LAB_VISUALIZE_CONTOUR</source>
+ <translation>Contour</translation>
+ </message>
+ <message>
+ <source>LAB_VISUALIZE_VECTORFIELD</source>
+ <translation>Champ de vecteurs</translation>
+ </message>
+ <message>
+ <source>LAB_VISUALIZE_SLICES</source>
+ <translation>Coupes</translation>
+ </message>
+ <message>
+ <source>LAB_VISUALIZE_DEFLECTIONSHAPE</source>
+ <translation>Déformée</translation>
+ </message>
+ <message>
+ <source>LAB_VISUALIZE_POINTSPRITE</source>
+ <translation>Point sprite</translation>
+ </message>
<message>
<location filename="MEDCALC/gui/DatasourceController.cxx" line="69"/>
<source>LAB_VISUALIZE</source>
-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D
+// 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
_consoleDriver->exec(commands);
}
+QString
+WorkspaceController::_getViewMode() {
+#define stringify( name ) # name
+
+ QString viewMode = stringify(MEDCALC::VIEW_MODE_NEW_LAYOUT); // :TODO: change this (get value from dedicated dialog)
+ viewMode.replace("::", ".");
+
+ return viewMode;
+}
+
/**
* This slot can process the event coming from the
* DatasourceController. The connection between the datasource signal
QCHARSTAR(event->objectalias));
}
else if ( event->eventtype == DatasourceEvent::EVENT_VIEW_OBJECT_SCALAR_MAP ) {
- QStringList commands;
-
-#define stringify( name ) # name
- QString viewMode = stringify(MEDCALC::VIEW_MODE_NEW_LAYOUT); // :TODO: change this (get value from dedicated dialog)
- viewMode.replace("::", ".");
-
+ QString viewMode = _getViewMode();
MEDCALC::FieldHandler* fieldHandler = dataObject->getFieldHandler();
+ QStringList commands;
commands += QString("medcalc.MakeScalarMap(accessField(%1), %2)").arg(fieldHandler->id).arg(viewMode);
_consoleDriver->exec(commands);
}
+ else if ( event->eventtype == DatasourceEvent::EVENT_VIEW_OBJECT_CONTOUR ) {
+ QString viewMode = _getViewMode();
+ MEDCALC::FieldHandler* fieldHandler = dataObject->getFieldHandler();
+ QStringList commands;
+ commands += QString("medcalc.MakeContour(accessField(%1), %2)").arg(fieldHandler->id).arg(viewMode);
+ _consoleDriver->exec(commands);
+ }
+ else if ( event->eventtype == DatasourceEvent::EVENT_VIEW_OBJECT_VECTOR_FIELD ) {
+ QString viewMode = _getViewMode();
+ MEDCALC::FieldHandler* fieldHandler = dataObject->getFieldHandler();
+ QStringList commands;
+ commands += QString("medcalc.MakeVectorField(accessField(%1), %2)").arg(fieldHandler->id).arg(viewMode);
+ _consoleDriver->exec(commands);
+ }
+ else if ( event->eventtype == DatasourceEvent::EVENT_VIEW_OBJECT_SLICES ) {
+ QString viewMode = _getViewMode();
+ MEDCALC::FieldHandler* fieldHandler = dataObject->getFieldHandler();
+ QStringList commands;
+ commands += QString("medcalc.MakeSlices(accessField(%1), %2)").arg(fieldHandler->id).arg(viewMode);
+ _consoleDriver->exec(commands);
+ }
+ else if ( event->eventtype == DatasourceEvent::EVENT_VIEW_OBJECT_DEFLECTION_SHAPE ) {
+ QString viewMode = _getViewMode();
+ MEDCALC::FieldHandler* fieldHandler = dataObject->getFieldHandler();
+ QStringList commands;
+ commands += QString("medcalc.MakeDeflectionShape(accessField(%1), %2)").arg(fieldHandler->id).arg(viewMode);
+ _consoleDriver->exec(commands);
+ }
+ else if ( event->eventtype == DatasourceEvent::EVENT_VIEW_OBJECT_POINT_SPRITE ) {
+ QString viewMode = _getViewMode();
+ MEDCALC::FieldHandler* fieldHandler = dataObject->getFieldHandler();
+ QStringList commands;
+ commands += QString("medcalc.MakePointSprite(accessField(%1), %2)").arg(fieldHandler->id).arg(viewMode);
+ _consoleDriver->exec(commands);
+ }
else if ( event->eventtype == DatasourceEvent::EVENT_ADD_DATASOURCE ) {
QStringList commands;
commands += QString("medcalc.LoadDataSource('%1')").arg(event->objectalias);
-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D
+// 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
void _saveItemList(QStringList itemNameIdList);
void _removeItemList(QStringList itemNameIdList);
void _viewItemList(QStringList itemNameIdList);
+ QString _getViewMode();
private:
XmedConsoleDriver * _consoleDriver;
-# Copyright (C) 2015 CEA/DEN, EDF R&D
+# Copyright (C) 2015, 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
# Presentations
from medpresentation import MakeScalarMap
-from medpresentation import MakeIsoSurface
+from medpresentation import MakeContour
from medpresentation import MakeVectorField
from medpresentation import MakeSlices
from medpresentation import MakeDeflectionShape
-# Copyright (C) 2011-2015 CEA/DEN, EDF R&D
+# 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
notifyGui_addPresentation(proxy.id, presentation_id)
#
-def MakeIsoSurface():
+def MakeContour(proxy, viewMode=MEDCALC.VIEW_MODE_REPLACE):
print "Not implemented yet"
+ #params = MEDCALC.ContourParameters(proxy.id, viewMode)
+ #presentation_id = __manager.makeContour(params)
+ #notifyGui_addPresentation(proxy.id, presentation_id)
#
-def MakeVectorField():
- print "Not implemented yet"
+def MakeVectorField(proxy, viewMode=MEDCALC.VIEW_MODE_REPLACE):
+ params = MEDCALC.VectorFieldParameters(proxy.id, viewMode)
+ presentation_id = __manager.makeVectorField(params)
+ notifyGui_addPresentation(proxy.id, presentation_id)
#
-def MakeSlices():
+def MakeSlices(proxy, viewMode=MEDCALC.VIEW_MODE_REPLACE):
print "Not implemented yet"
+ #params = MEDCALC.SlicesParameters(proxy.id, viewMode)
+ #presentation_id = __manager.makeSlices(params)
+ #notifyGui_addPresentation(proxy.id, presentation_id)
#
-def MakeDeflectionShape():
- print "Not implemented yet"
+def MakeDeflectionShape(proxy, viewMode=MEDCALC.VIEW_MODE_REPLACE):
+ params = MEDCALC.DeflectionShapeParameters(proxy.id, viewMode)
+ presentation_id = __manager.makeDeflectionShape(params)
+ notifyGui_addPresentation(proxy.id, presentation_id)
#
-def MakePointSprite():
- print "Not implemented yet"
+def MakePointSprite(proxy, viewMode=MEDCALC.VIEW_MODE_REPLACE):
+ params = MEDCALC.PointSpriteParameters(proxy.id, viewMode)
+ presentation_id = __manager.makePointSprite(params)
+ notifyGui_addPresentation(proxy.id, presentation_id)
#
