--- /dev/null
+# VISU OBJECT : interactive object for VISU entities implementation
+#
+# Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# 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.
+#
+# 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+#
+#
+#
+# File : Makefile.in
+# Module : VISU
+
+top_srcdir=@top_srcdir@
+top_builddir=../../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl
+
+
+@COMMENCE@
+
+EXPORT_HEADERS = VISU_Convertor.hxx VISU_Convertor_impl.hxx
+
+# Libraries targets
+
+LIB = libVisuConvertor.la
+LIB_SRC = VISU_Convertor.cxx VISU_Convertor_impl.cxx VISU_ConvertorUtils.cxx \
+ VISU_MedConvertor.cxx VISU_DatConvertor.cxx
+
+# Executables targets
+BIN = VISUConvertor
+BIN_SRC =
+
+CPPFLAGS+= -ftemplate-depth-32 $(VTK_INCLUDES) $(MED2_INCLUDES) $(QT_INCLUDES)
+LDFLAGS+= $(VTK_LIBS) $(MED2_LIBS) $(HDF5_LIBS) $(QT_LIBS)
+
+@CONCLUDE@
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISUConvertor.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#include "VISU_Convertor.hxx"
+
+#include <fstream>
+#include <strstream>
+#include <vtkCellType.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qstringlist.h>
+#include <memory>
+
+using namespace std;
+
+#ifdef DEBUG
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+void parseFile(const char* theFileName) throw(std::runtime_error&){
+ try{
+ cout<<"'"<<theFileName<<"'...";
+ auto_ptr<VISU_Convertor> aCon(CreateConvertor(theFileName));
+ const VISU::TMeshMap& aMeshMap = aCon->GetMeshMap();
+ //return;
+ VISU::TMeshMap::const_iterator aMeshMapIter = aMeshMap.begin();
+ for(; aMeshMapIter != aMeshMap.end(); aMeshMapIter++){
+ const string& aMeshName = aMeshMapIter->first;
+ const VISU::TMesh& aMesh = aMeshMapIter->second;
+ const VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh.myMeshOnEntityMap;
+ VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter;
+ //Import fields
+ aMeshOnEntityMapIter = aMeshOnEntityMap.begin();
+ for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){
+ const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first;
+ const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second;
+ const VISU::TFieldMap& aFieldMap = aMeshOnEntity.myFieldMap;
+ VISU::TFieldMap::const_iterator aFieldMapIter = aFieldMap.begin();
+ for(; aFieldMapIter != aFieldMap.end(); aFieldMapIter++){
+ const string& aFieldName = aFieldMapIter->first;
+ const VISU::TField& aField = aFieldMapIter->second;
+ const VISU::TField::TValField& aValField = aField.myValField;
+ VISU::TField::TValField::const_iterator aValFieldIter = aValField.begin();
+ for(; aValFieldIter != aValField.end(); aValFieldIter++){
+ int aTimeStamp = aValFieldIter->first;
+ aCon->GetTimeStampOnMesh(aMeshName,anEntity,aFieldName,aTimeStamp);
+ }
+ }
+ }
+ //Importing groups
+ const VISU::TGroupMap& aGroupMap = aMesh.myGroupMap;
+ VISU::TGroupMap::const_iterator aGroupMapIter = aGroupMap.begin();
+ for(; aGroupMapIter != aGroupMap.end(); aGroupMapIter++){
+ const string& aGroupName = aGroupMapIter->first;
+ aCon->GetMeshOnGroup(aMeshName,aGroupName);
+ }
+ //Import families
+ aMeshOnEntityMapIter = aMeshOnEntityMap.begin();
+ for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){
+ const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first;
+ const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second;
+ //aCon->GetMeshOnEntity(aMeshName,anEntity);
+ const VISU::TFamilyMap& aFamilyMap = aMeshOnEntity.myFamilyMap;
+ VISU::TFamilyMap::const_iterator aFamilyMapIter = aFamilyMap.begin();
+ for(; aFamilyMapIter != aFamilyMap.end(); aFamilyMapIter++){
+ const string& aFamilyName = aFamilyMapIter->first;
+ aCon->GetMeshOnEntity(aMeshName,anEntity,aFamilyName);
+ }
+ }
+ //Import mesh on entity
+ aMeshOnEntityMapIter = aMeshOnEntityMap.begin();
+ for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){
+ const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first;
+ aCon->GetMeshOnEntity(aMeshName,anEntity);
+ }
+ }
+ cout<<"OK"<<endl;
+ }catch(std::runtime_error& exc){
+ MESSAGE("Follow exception was accured in file:"<<theFileName<<"\n"<<exc.what());
+ }catch(...){
+ MESSAGE("Unknown exception was accured in VISU_Convertor_impl in file:"<<theFileName);
+ }
+}
+
+int main(int argc, char** argv){
+ try{
+ if(argc > 1){
+ QFileInfo fi(argv[1]);
+ for(int i = 0; i < 1; i++){
+ if(fi.exists()){
+ if(fi.isDir()){
+ QDir aDir(fi.absFilePath());
+ QStringList aStringList = aDir.entryList("*.med",QDir::Files);
+ int jEnd = aStringList.count();
+ for(int j = 0; j < jEnd; j++){
+ parseFile(aDir.filePath(aStringList[j]).latin1());
+ }
+ }else{
+ parseFile(argv[1]);
+ }
+ }
+ }
+ return 0;
+ }
+ }catch(std::runtime_error& exc){
+ cout<<"Follow exception was accured :\n"<<exc.what()<<endl;
+ }catch(...){
+ cout<<"Unknown exception was accured in VISU_Convertor_impl"<<endl;
+ }
+ return 1;
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_Convertor.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#include "VISU_Convertor.hxx"
+#include "VISU_ConvertorUtils.hxx"
+
+#include <vtkUnstructuredGridWriter.h>
+
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+extern "C" {
+ VISU_Convertor* CreateConvertor(const string& theFileName) throw(std::runtime_error&){
+ if(QFileInfo(theFileName.c_str()).extension(false) == "med")
+ return CreateMedConvertor(theFileName);
+ else
+ return CreateDatConvertor(theFileName);
+ }
+}
+
+void VISU::WriteToFile(vtkUnstructuredGrid* theDataSet, const string& theFileName){
+// vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
+// //aWriter->DebugOn();
+// //aWriter->SetFileType(VTK_BINARY);
+// aWriter->SetFileName(theFileName.c_str());
+// aWriter->SetInput(theDataSet);
+// //aWriter->Print(cout);
+// aWriter->Write();
+// aWriter->Delete();
+}
+
+namespace VISU{
+ TVtkCellInfoMap aVtkCellInfoMap;
+ static int INIT = (
+ aVtkCellInfoMap[VTK_VERTEX] = TVtkCellInfo("VTK_VERTEX",1),
+ aVtkCellInfoMap[VTK_LINE] = TVtkCellInfo("VTK_LINE",2),
+ aVtkCellInfoMap[VTK_TRIANGLE] = TVtkCellInfo("VTK_TRIANGLE",3),
+ aVtkCellInfoMap[VTK_QUAD] = TVtkCellInfo("VTK_QUAD",4),
+ aVtkCellInfoMap[VTK_TETRA] = TVtkCellInfo("VTK_TETRA",4),
+ aVtkCellInfoMap[VTK_HEXAHEDRON] = TVtkCellInfo("VTK_HEXAHEDRON",8),
+ aVtkCellInfoMap[VTK_WEDGE] = TVtkCellInfo("VTK_WEDGE",6),
+ aVtkCellInfoMap[VTK_PYRAMID] = TVtkCellInfo("VTK_PYRAMID",5),
+ 1);
+
+ pair<int,int> TMeshOnEntity::GetCellsDims(const string& theFamilyName) const
+ throw(std::runtime_error&)
+ {
+ bool isFamilyPresent = (theFamilyName != "");
+ int aNbCells = 0, aCellsSize = 0;
+ if(!isFamilyPresent){
+ TCellsConn::const_iterator aCellsConnIter = myCellsConn.begin();
+ for(; aCellsConnIter != myCellsConn.end(); aCellsConnIter++){
+ const TConnForCellType& aConnForCellType = aCellsConnIter->second;
+ if(!aConnForCellType.empty()){
+ aNbCells += aConnForCellType.size();
+ aCellsSize += aConnForCellType.size()*(aConnForCellType[0].size()+1);
+ }
+ }
+ }else{
+ TFamilyMap::const_iterator aFamilyMapIter = myFamilyMap.find(theFamilyName);
+ if(aFamilyMapIter == myFamilyMap.end())
+ throw std::runtime_error("GetCellsDims >> There is no family on the mesh with entity !!!");
+ const TFamily& aFamily = aFamilyMapIter->second;
+ const TFamily::TSubMesh& aSubMesh = aFamily.mySubMesh;
+ TFamily::TSubMesh::const_iterator aSubMeshIter = aSubMesh.begin();
+ for(; aSubMeshIter != aSubMesh.end(); aSubMeshIter++){
+ const TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aSubMeshIter->second;
+ if(!aSubMeshOnCellType.empty()){
+ int tmp = aSubMeshOnCellType.size();
+ aNbCells += tmp;
+ int aVtkType = aSubMeshIter->first;
+ int aVtkSize = aVtkCellInfoMap[aVtkType].mySize;
+ aCellsSize += tmp*(aVtkSize+1);
+ }
+ }
+ }
+ return make_pair(aNbCells,aCellsSize);
+ }
+
+ const TField* TMesh::GetField(const string& theFieldName) const {
+ TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter = myMeshOnEntityMap.begin();
+ for(; aMeshOnEntityMapIter != myMeshOnEntityMap.end(); aMeshOnEntityMapIter++){
+ const TFieldMap& aFieldMap = (aMeshOnEntityMapIter->second).myFieldMap;
+ TFieldMap::const_iterator aFieldMapIter = aFieldMap.begin();
+ for(; aFieldMapIter != aFieldMap.end(); aFieldMapIter++)
+ if(theFieldName == aFieldMapIter->first) return &(aFieldMapIter->second);
+ }
+ return NULL;
+ }
+
+ const TFamily* GetFamily(const VISU::TMeshOnEntity& theMeshOnEntity, const string& theFamilyName)
+ throw(std::runtime_error&)
+ {
+ if(theFamilyName == "") return NULL;
+ const VISU::TFamilyMap& aFamilyMap = theMeshOnEntity.myFamilyMap;
+ VISU::TFamilyMap::const_iterator aFamilyMapIter = aFamilyMap.find(theFamilyName);
+ if(aFamilyMapIter == aFamilyMap.end())
+ throw std::runtime_error("GetFamily >> There is no family on the mesh with entity !!!");
+ const VISU::TFamily& aFamily = aFamilyMapIter->second;
+ return &aFamily;
+ }
+
+ TFamily* GetFamily(VISU::TMeshOnEntity& theMeshOnEntity, const string& theFamilyName)
+ throw(std::runtime_error&)
+ {
+ if(theFamilyName == "") return NULL;
+ VISU::TFamilyMap& aFamilyMap = theMeshOnEntity.myFamilyMap;
+ VISU::TFamilyMap::iterator aFamilyMapIter = aFamilyMap.find(theFamilyName);
+ if(aFamilyMapIter == aFamilyMap.end())
+ throw std::runtime_error("GetFamily >> There is no family on the mesh with entity !!!");
+ VISU::TFamily& aFamily = aFamilyMapIter->second;
+ return &aFamily;
+ }
+
+ void TField::ShallowCopy(const TField& aField){
+ myEntity = aField.myEntity;
+ myMeshName = aField.myMeshName;
+ myNbComp = aField.myNbComp;
+ VISU::TField::TValField::const_iterator iter = aField.myValField.begin();
+ for(; iter != aField.myValField.end(); iter++)
+ myValField[iter->first];
+ }
+}
+
+
+const VISU::TMeshMap& VISU_Convertor::GetMeshMap() throw(std::runtime_error&){
+ if(!myIsDone) { myIsDone = true; Build();}
+ return myMeshMap;
+}
+
+
+string VISU_Convertor::GenerateName(const VISU::TField::TTime& aTime){
+ static QString aName;
+ const string aUnits = aTime.second, tmp(aUnits.size(),' ');
+ if(aUnits == "" || aUnits == tmp)
+ aName.sprintf("%g, -",aTime.first);
+ else
+ aName.sprintf("%g, %s",aTime.first,aTime.second.c_str());
+ aName = aName.simplifyWhiteSpace();
+ return aName.latin1();
+}
+
+string VISU_Convertor::GenerateName(const string& theName, unsigned int theTimeId) {
+ static QString aName;
+ aName = QString(theName.c_str()).simplifyWhiteSpace();
+ int iEnd = strlen(aName);
+ static int VtkHighLevelLength = 12; //25
+ if(iEnd > VtkHighLevelLength) iEnd = VtkHighLevelLength;
+ char aNewName[iEnd+1];
+ aNewName[iEnd] = '\0';
+ strncpy(aNewName,aName,iEnd);
+ replace(aNewName,aNewName+iEnd,' ','_');
+ if(true || theTimeId == 0)
+ aName = aNewName;
+ else
+ aName.sprintf("%s_%d",aNewName,theTimeId);
+ return aName.latin1();
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Convertor.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_Convertor_HeaderFile
+#define VISU_Convertor_HeaderFile
+
+#include <stdio.h>
+
+#include <algorithm>
+#include <iterator>
+#include <list>
+#include <map>
+#include <memory>
+#include <numeric>
+#include <set>
+#include <utility>
+#include <vector>
+#include <string>
+#include <stdexcept>
+
+#ifndef MESSAGE
+#define MESSAGE(msg) std::cout<<msg<<endl
+#endif
+
+#include <vtkUnstructuredGrid.h>
+#include <vtkSystemIncludes.h>
+#include <vtkPoints.h>
+
+namespace VISU{
+ class TVtkCellInfo{
+ public:
+ TVtkCellInfo() {}
+ TVtkCellInfo(const char* theName, vtkIdType theSize) :
+ myName(theName), mySize(theSize) {}
+ const char* myName;
+ vtkIdType mySize;
+ };
+ typedef std::map<vtkIdType,TVtkCellInfo> TVtkCellInfoMap;
+ extern TVtkCellInfoMap aVtkCellInfoMap;
+
+ enum TEntity {NODE_ENTITY, EDGE_ENTITY, FACE_ENTITY, CELL_ENTITY};
+ template <class _Tp> class vtk_ptr {
+ private:
+ _Tp* _M_ptr;
+ public:
+ typedef _Tp element_type;
+ explicit vtk_ptr(_Tp* __p = 0) : _M_ptr(__p) {}
+ vtk_ptr(const vtk_ptr& __a) : _M_ptr(0) {}
+ vtk_ptr(vtk_ptr& __a) : _M_ptr(__a.release()) {}
+ vtk_ptr& operator=(const vtk_ptr& __a) { return *this;}
+ vtk_ptr& operator=(vtk_ptr& __a) {
+ if (&__a != this) {
+ if(_M_ptr) _M_ptr->Delete();
+ _M_ptr = __a.release();
+ }
+ return *this;
+ }
+ ~vtk_ptr() {
+ if(_M_ptr) _M_ptr->Delete();
+ _M_ptr = 0;
+ }
+ _Tp& operator*() const { return *_M_ptr;}
+ _Tp* operator->() const { return _M_ptr;}
+ _Tp* get() const { return _M_ptr;}
+ _Tp* release() {
+ _Tp* __tmp = _M_ptr;
+ _M_ptr = 0;
+ return __tmp;
+ }
+ void reset(_Tp* __p = 0) {
+ if(_M_ptr) _M_ptr->Delete();
+ _M_ptr = __p;
+ }
+ };
+ typedef vtk_ptr<vtkUnstructuredGrid> TVTKSource;
+ typedef vtk_ptr<vtkPoints> TVTKPoints;
+
+ typedef std::set<std::string> TBindGroups;
+
+ struct TFamily{
+ TVTKSource myStorage;
+ vtkIdType myId;
+ std::string myName;
+ TEntity myEntity;
+ TBindGroups myGroups;
+ vtkIdType myNbCells, myCellsSize;
+ typedef std::set<vtkIdType> TSubMeshOnCellType;
+ typedef std::map<vtkIdType,TSubMeshOnCellType> TSubMesh;
+ TSubMesh mySubMesh;
+ TFamily() : myNbCells(0), myCellsSize(0) {}
+ };
+ typedef std::map<std::string,TFamily> TFamilyMap;
+
+ struct TField{
+ vtkIdType myId;
+ std::string myName;
+ TEntity myEntity;
+ std::string myMeshName;
+ vtkIdType myNbComp, myNbValField, myDataSize;
+ typedef std::vector<float> TValForCellsWithType;
+ typedef std::map<vtkIdType,TValForCellsWithType> TValForCells;
+ typedef std::pair<double,std::string> TTime;
+ typedef std::vector<std::string> TCompNames;
+ typedef std::vector<std::string> TUnitNames;
+ struct TValForTime{
+ TVTKSource myStorage;
+ vtkIdType myId;
+ std::string myMeshName;
+ TEntity myEntity;
+ std::string myFieldName;
+ vtkIdType myNbComp;
+ TTime myTime;
+ TValForCells myValForCells;
+ TValForTime() : myNbComp(0) {}
+ };
+ typedef std::map<vtkIdType,TValForTime> TValField;
+ TValField myValField;
+ TCompNames myCompNames;
+ TUnitNames myUnitNames;
+ TField() : myNbComp(0), myNbValField(0), myDataSize(0) {}
+ void ShallowCopy(const TField& aField);
+ };
+ typedef std::map<std::string,TField> TFieldMap;
+
+ struct TMeshOnEntity{
+ TVTKSource myStorage;
+ std::string myMeshName;
+ TEntity myEntity;
+ vtkIdType myNbCells, myCellsSize;
+ typedef std::vector<vtkIdType> TConnect;
+ typedef std::vector<TConnect> TConnForCellType;
+ typedef std::map<vtkIdType,TConnForCellType> TCellsConn;
+ TCellsConn myCellsConn;
+ TFamilyMap myFamilyMap;
+ TFieldMap myFieldMap;
+ TMeshOnEntity() : myNbCells(0), myCellsSize(0) {}
+ std::pair<vtkIdType,vtkIdType> GetCellsDims(const std::string& theFamilyName = "") const
+ throw(std::runtime_error&);
+ };
+ typedef std::map<TEntity,TMeshOnEntity> TMeshOnEntityMap;
+ const TFamily* GetFamily(const VISU::TMeshOnEntity& theMeshOnEntity,
+ const std::string& theFamilyName)
+ throw(std::runtime_error&);
+ TFamily* GetFamily(VISU::TMeshOnEntity& theMeshOnEntity,
+ const std::string& theFamilyName)
+ throw(std::runtime_error&);
+
+ typedef std::pair<std::string,TEntity> TFamilyAndEntity;
+ typedef std::set<TFamilyAndEntity> TFamilyAndEntitySet;
+ struct TGroup{
+ TVTKSource myStorage;
+ std::string myName;
+ std::string myMeshName;
+ vtkIdType myNbCells, myCellsSize;
+ TGroup() : myNbCells(0), myCellsSize(0) {}
+ TFamilyAndEntitySet myFamilyAndEntitySet;
+ };
+ typedef std::map<std::string,TGroup> TGroupMap;
+
+ struct TMesh{
+ TVTKPoints myPoints;
+ vtkIdType myDim, myNbPoints;
+ std::string myName;
+ typedef float TCoord;
+ typedef std::vector<TCoord> TPointsCoord;
+ TPointsCoord myPointsCoord;
+ TMeshOnEntityMap myMeshOnEntityMap;
+ TGroupMap myGroupMap;
+ TMesh() : myDim(0), myNbPoints(0) {}
+ const TField* GetField(const std::string& theFieldName) const;
+ };
+ typedef std::map<std::string,TMesh> TMeshMap;
+ void WriteToFile(vtkUnstructuredGrid* theDataSet, const std::string& theFileName);
+};
+
+class VISU_Convertor{
+protected:
+ std::string myName;
+ VISU::TMeshMap myMeshMap;
+ int myIsDone;
+public:
+ virtual ~VISU_Convertor(){};
+ virtual const std::string& GetName() { return myName;}
+ virtual int IsDone() const { return myIsDone;}
+ typedef vtkUnstructuredGrid TOutput;
+
+ virtual VISU_Convertor* Build() throw (std::runtime_error&) = 0;
+ virtual const VISU::TMeshMap& GetMeshMap() throw(std::runtime_error&);
+
+
+ virtual TOutput* GetMeshOnEntity(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFamilyName = "")
+ throw(std::runtime_error&) = 0;
+ virtual vtkIdType GetMeshOnEntitySize(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFamilyName = "")
+ throw (std::runtime_error&) = 0;
+
+
+ virtual TOutput* GetMeshOnGroup(const std::string& theMeshName,
+ const std::string& theGroupName)
+ throw(std::runtime_error&) = 0;
+ virtual vtkIdType GetMeshOnGroupSize(const std::string& theMeshName,
+ const std::string& theGroupName)
+ throw(std::runtime_error&) = 0;
+
+
+ virtual TOutput* GetTimeStampOnMesh(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName,
+ int theStampsNum)
+ throw(std::runtime_error&) = 0;
+ virtual vtkIdType GetTimeStampSize(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName,
+ int theStampsNum)
+ throw(std::runtime_error&) = 0;
+ virtual vtkIdType GetFieldOnMeshSize(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName)
+ throw(std::runtime_error&) = 0;
+ virtual const VISU::TField& GetField(const std::string& theMeshName,
+ VISU::TEntity theEntity,
+ const std::string& theFieldName)
+ throw(std::runtime_error&) = 0;
+ virtual const VISU::TField::TValForTime& GetTimeStamp(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName,
+ int theStampsNum)
+ throw(std::runtime_error&) = 0;
+
+ static std::string GenerateName(const VISU::TField::TTime& aTime);
+ static std::string GenerateName(const std::string& theName, unsigned int theTimeId);
+ static void WriteToFile(vtkUnstructuredGrid* theDataSet, const std::string& theFileName);
+};
+
+extern "C"{
+ VISU_Convertor* CreateMedConvertor(const std::string& theFileName) throw(std::runtime_error&);
+ VISU_Convertor* CreateDatConvertor(const std::string& theFileName) throw(std::runtime_error&);
+ VISU_Convertor* CreateConvertor(const std::string& theFileName) throw(std::runtime_error&);
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Convertor_impl.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_Convertor_impl.hxx"
+
+#include <vtkCellType.h>
+
+using namespace std;
+
+#define MED2VTK(MEDTYPE,VTKTYPE,VTKNBNODES) \
+ {MEDTYPE,#MEDTYPE,getNbMedNodes(MEDTYPE),VTKTYPE,#VTKTYPE,VTKNBNODES}
+Med2vtk med2vtk[MED_NBR_GEOMETRIE_MAILLE] = {
+ MED2VTK(MED_POINT1,VTK_VERTEX,1),
+ MED2VTK(MED_SEG2,VTK_LINE,2),
+ MED2VTK(MED_SEG3,VTK_LINE,2),
+ MED2VTK(MED_TRIA3,VTK_TRIANGLE,3),
+ MED2VTK(MED_TRIA6,VTK_TRIANGLE,3),
+ MED2VTK(MED_QUAD4,VTK_QUAD,4),
+ MED2VTK(MED_QUAD8,VTK_QUAD,4),
+ MED2VTK(MED_TETRA4,VTK_TETRA,4),
+ MED2VTK(MED_TETRA10,VTK_TETRA,4),
+ MED2VTK(MED_HEXA8,VTK_HEXAHEDRON,8),
+ MED2VTK(MED_HEXA20,VTK_HEXAHEDRON,8),
+ MED2VTK(MED_PENTA6,VTK_WEDGE,6),
+ MED2VTK(MED_PENTA15,VTK_WEDGE,6),
+ MED2VTK(MED_PYRA5,VTK_PYRAMID,5),
+ MED2VTK(MED_PYRA13,VTK_PYRAMID,5)
+};
+#undef MED2VTK
+
+extern "C" {
+ int getNbMedConnect(int theMedType, int theMedEntity, int theMeshDim){
+ int anElemDim = theMedType / 100, nsup = 0;
+ if(theMedEntity == VISU::CELL_ENTITY && anElemDim < theMeshDim) nsup = 1;
+ return nsup + theMedType % 100;
+ }
+
+ int getNbMedNodes(int geom){
+ return geom % 100;
+ }
+
+ int getIdMedType(int medType){
+ for(int i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++)
+ if(med2vtk[i].medType == medType) return i;
+ return -1;
+ }
+
+ int med2vtkCellType(int medType){
+ for(int i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++)
+ if(med2vtk[i].medType == medType) return med2vtk[i].vtkType;
+ return -1;
+ }
+
+ int vtk2medCellType(int vtkType){
+ for(int i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++)
+ if(med2vtk[i].vtkType == vtkType) return med2vtk[i].medType;
+ return -1;
+ }
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Convertor_impl.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_ConvertorUtils_HeaderFile
+#define VISU_ConvertorUtils_HeaderFile
+
+extern "C"{
+#include <med.h>
+}
+
+#include <fstream>
+#include <strstream>
+
+#include <vtkCellType.h>
+
+#include <qstring.h>
+#include <qfileinfo.h>
+
+template<class T> std::string dtos(const std::string& fmt, T val){
+ static QString aString;
+ aString.sprintf(fmt.c_str(),val);
+ return aString.latin1();
+}
+
+extern "C"{
+ int getNbMedConnect(int theMedType, int theMedEntity, int theMeshDim);
+ int getNbMedNodes(int theMedType);
+ int med2vtkCellType(int theMedType);
+ int vtk2medCellType(int theVtkType);
+ int getIdMedType(int medType);
+}
+
+struct Med2vtk {
+ med_geometrie_element medType;
+ const char *medName;
+ int medNbNodes;
+ int vtkType;
+ const char *vtkName;
+ int vtkNbNodes;
+};
+
+extern Med2vtk med2vtk[MED_NBR_GEOMETRIE_MAILLE];
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Convertor_impl.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_Convertor_impl.hxx"
+
+#include <vtkIdList.h>
+#include <vtkCellType.h>
+#include <vtkIntArray.h>
+#include <vtkCellArray.h>
+#include <vtkFloatArray.h>
+#include <vtkUnsignedCharArray.h>
+#include <vtkPointData.h>
+#include <vtkCellData.h>
+
+#include <qstring.h>
+#include <qfileinfo.h>
+
+#include <valarray>
+#include <memory>
+
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+
+VISU_Convertor_impl::VISU_Convertor_impl() {
+ myIsDone = false;
+}
+
+VISU_Convertor_impl::~VISU_Convertor_impl() {}
+
+VISU_Convertor::TOutput*
+VISU_Convertor_impl::GetMeshOnEntity(const string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const string& theFamilyName)
+ throw (std::runtime_error&)
+{
+ if(MYDEBUG)
+ MESSAGE("GetMeshOnEntity - theMeshName = '"<<theMeshName<<
+ "'; theEntity = "<<theEntity<<"; theFamilyName = '"<<theFamilyName<<"'");
+ //Cheching possibility do the query
+ VISU::TMesh* pMesh = NULL;
+ VISU::TFamily* pFamily = NULL;
+ VISU::TMeshOnEntity* pMeshOnEntity = NULL;
+ FindMeshOnEntity(theMeshName,pMesh,theEntity,pMeshOnEntity,theFamilyName,pFamily);
+ VISU::TMesh& aMesh = *pMesh;
+ VISU::TMeshOnEntity& aMeshOnEntity = *pMeshOnEntity;
+ VISU::TVTKSource* pSource;
+ if(pFamily != NULL)
+ pSource = &(pFamily->myStorage);
+ else
+ pSource = &(aMeshOnEntity.myStorage);
+ VISU::TVTKSource& aSource = *pSource;
+ //Main part of code
+ if(aSource.get() == NULL){
+ aSource.reset(TOutput::New());
+ LoadMeshOnEntity(aMeshOnEntity,theFamilyName);
+ GetPoints(aSource,aMesh);
+ GetCellsOnEntity(aSource,aMeshOnEntity,theFamilyName);
+ if(MYDEBUGWITHFILES){
+ string aMeshName = QString(theMeshName.c_str()).simplifyWhiteSpace().latin1();
+ string aFamilyName = QString(theFamilyName.c_str()).simplifyWhiteSpace().latin1();
+ string aFileName = string("/users/")+getenv("USER")+"/"+getenv("USER")+"-";
+ aFileName += aMeshName + dtos("-%d-",int(theEntity)) + aFamilyName + "-Conv.vtk";
+ VISU::WriteToFile(aSource.get(),aFileName);
+ }
+ }
+ return aSource.get();
+}
+
+VISU_Convertor::TOutput*
+VISU_Convertor_impl::GetMeshOnGroup(const string& theMeshName,
+ const string& theGroupName)
+ throw(std::runtime_error&)
+{
+ if(MYDEBUG) MESSAGE("GetMeshOnGroup - theMeshName = '"<<theMeshName<<
+ "'; theGroupName = '"<<theGroupName<<"'");
+ //Cheching possibility do the query
+ VISU::TMesh* pMesh = NULL;
+ VISU::TGroup* pGroup = NULL;
+ FindMeshOnGroup(theMeshName,pMesh,theGroupName,pGroup);
+ VISU::TMesh& aMesh = *pMesh;
+ VISU::TGroup& aGroup = *pGroup;
+ const VISU::TFamilyAndEntitySet& aFamilyAndEntitySet = aGroup.myFamilyAndEntitySet;
+ VISU::TVTKSource& aSource = aGroup.myStorage;
+ //Main part of code
+ if(aSource.get() == NULL){
+ aSource.reset(TOutput::New());
+ LoadMeshOnGroup(aMesh,aFamilyAndEntitySet);
+ GetPoints(aSource,aMesh);
+ GetCellsOnGroup(aSource,aMesh,aFamilyAndEntitySet);
+ if(MYDEBUGWITHFILES){
+ string aMeshName = QString(theMeshName.c_str()).simplifyWhiteSpace().latin1();
+ string aGroupName = QString(theGroupName.c_str()).simplifyWhiteSpace().latin1();
+ string aFileName = string("/users/")+getenv("USER")+"/"+getenv("USER")+"-";
+ aFileName += aMeshName + "-" + aGroupName + "-Conv.vtk";
+ VISU::WriteToFile(aSource.get(),aFileName);
+ }
+ }
+ return aSource.get();
+}
+
+VISU_Convertor::TOutput*
+VISU_Convertor_impl::GetTimeStampOnMesh(const string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const string& theFieldName,
+ int theStampsNum)
+ throw(std::runtime_error&)
+{
+ if(MYDEBUG){
+ MESSAGE("GetTimeStampOnMesh - theMeshName = '"<<theMeshName<<"; theEntity = "<<theEntity);
+ MESSAGE("GetTimeStampOnMesh - theFieldName = '"<<theFieldName<<"'; theStampsNum = "<<theStampsNum);
+ }
+ //Cheching possibility do the query
+ VISU::TMesh* pMesh = NULL;
+ VISU::TField* pField = NULL;
+ VISU::TMeshOnEntity *pMeshOnEntity = NULL, *pVTKMeshOnEntity = NULL;
+ VISU::TField::TValForTime* pValForTime = NULL;
+ FindTimeStamp(theMeshName,pMesh,theEntity,pMeshOnEntity,pVTKMeshOnEntity,
+ theFieldName,pField,theStampsNum,pValForTime);
+ VISU::TMesh& aMesh = *pMesh;
+ VISU::TMeshOnEntity& aMeshOnEntity = *pMeshOnEntity;
+ VISU::TMeshOnEntity& aVTKMeshOnEntity = *pVTKMeshOnEntity;
+ VISU::TField& aField = *pField;
+ VISU::TField::TValForTime& aValForTime = *pValForTime;
+ VISU::TVTKSource& aSource = aValForTime.myStorage;
+ //Main part of code
+ if(aSource.get() == NULL){
+ aSource.reset(TOutput::New());
+ LoadFieldOnMesh(aMesh,aMeshOnEntity,aField,aValForTime);
+ try{
+ LoadMeshOnEntity(aVTKMeshOnEntity);
+ }catch(std::runtime_error& exc){
+ aVTKMeshOnEntity = aMeshOnEntity;
+ MESSAGE("Follow exception was accured :\n"<<exc.what());
+ }catch(...){
+ aVTKMeshOnEntity = aMeshOnEntity;
+ MESSAGE("Unknown exception was accured!");
+ }
+ GetMeshOnEntity(aVTKMeshOnEntity.myMeshName,aVTKMeshOnEntity.myEntity);
+ aSource->ShallowCopy(aVTKMeshOnEntity.myStorage.get());
+ GetField(aSource,aMesh,aVTKMeshOnEntity,aField,aValForTime);
+ if(MYDEBUGWITHFILES){
+ string aMeshName = QString(theMeshName.c_str()).simplifyWhiteSpace().latin1();
+ string aFieldName = QString(theFieldName.c_str()).simplifyWhiteSpace().latin1();
+ string aFileName = string("/users/")+getenv("USER")+"/"+getenv("USER")+"-";
+ aFileName += aMeshName + dtos("-%d-",int(theEntity)) + aFieldName + dtos("-%d",theStampsNum) + "-Conv.vtk";
+ VISU::WriteToFile(aSource.get(),aFileName);
+ }
+ }
+ return aSource.get();
+}
+
+inline void PrintCells(int& theStartId,
+ vtkCellArray* theConnectivity,
+ const VISU::TMeshOnEntity::TConnect& theVector)
+{
+ vtkIdList *anIdList = vtkIdList::New();
+ int kEnd = theVector.size();
+ anIdList->SetNumberOfIds(kEnd);
+ for(int k = 0; k < kEnd; k++){
+ anIdList->SetId(k,theVector[k]);
+ //anIdList->InsertNextId(theVector[k]);
+ }
+ theConnectivity->InsertNextCell(anIdList);
+ anIdList->Delete();
+}
+
+void VISU_Convertor_impl::GetCellsOnEntity(VISU::TVTKSource& theStorage,
+ const VISU::TMeshOnEntity& theMeshOnEntity,
+ const string& theFamilyName)
+ const throw (std::runtime_error&)
+{
+ //Check on existing family
+ const VISU::TFamily* pFamily = VISU::GetFamily(theMeshOnEntity,theFamilyName);
+ bool isFamilyPresent = (pFamily != NULL);
+ const VISU::TFamily& aFamily = *pFamily;
+ //Main part of code
+ pair<int,int> aCellsDim = theMeshOnEntity.GetCellsDims(theFamilyName);
+ int aNbCells = aCellsDim.first, aCellsSize = aCellsDim.second;
+ vtkCellArray* aConnectivity = vtkCellArray::New();
+ //vtkIdType *anIdArray = aConnectivity->WritePointer(0,aCellsSize);
+ aConnectivity->Allocate(aCellsSize,0);
+ vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
+ aCellTypesArray->SetNumberOfComponents(1);
+ aCellTypesArray->SetNumberOfTuples(aNbCells);
+ if(MYDEBUG) MESSAGE("GetCellsOnEntity - isFamilyPresent = "<<isFamilyPresent);
+ const VISU::TMeshOnEntity::TCellsConn &aCellsConn = theMeshOnEntity.myCellsConn;
+ VISU::TMeshOnEntity::TCellsConn::const_iterator aCellsConnIter = aCellsConn.begin();
+ for(int i = 0, j = 0; aCellsConnIter != aCellsConn.end(); aCellsConnIter++){
+ const VISU::TMeshOnEntity::TConnForCellType& anArray = aCellsConnIter->second;
+ int aVtkType = aCellsConnIter->first;
+ if(MYDEBUG) MESSAGE("GetCellsOnEntity - aVtkType = "<<aVtkType<<"; anArray.size() = "<<anArray.size());
+ if(!isFamilyPresent)
+ for(int k = 0, kEnd = anArray.size(); k < kEnd; k++, i++){
+ PrintCells(i,aConnectivity,anArray[k]);
+ aCellTypesArray->SetValue(j++,(unsigned char)aVtkType);
+ //aCellTypesArray->InsertNextValue((unsigned char)aVtkType);
+ }
+ else{
+ const VISU::TFamily::TSubMesh& aSubMesh = aFamily.mySubMesh;
+ if(aSubMesh.empty()) throw std::runtime_error("GetCells >> There is no elements on the family !!!");
+ VISU::TFamily::TSubMesh::const_iterator aSubMeshIter = aSubMesh.find(aVtkType);
+ if(aSubMeshIter == aSubMesh.end()) continue;
+ const VISU::TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aSubMeshIter->second;
+ if(MYDEBUG) MESSAGE("GetCellsOnEntity - aSubMeshOnCellType.size() = "<<aSubMeshOnCellType.size());
+ VISU::TFamily::TSubMeshOnCellType::const_iterator aSubMeshOnCellTypeIter = aSubMeshOnCellType.begin();
+ for(; aSubMeshOnCellTypeIter != aSubMeshOnCellType.end(); aSubMeshOnCellTypeIter++, i++){
+ PrintCells(i,aConnectivity,anArray[*aSubMeshOnCellTypeIter]);
+ aCellTypesArray->SetValue(j++,(unsigned char)aVtkType);
+ //aCellTypesArray->InsertNextValue((unsigned char)aVtkType);
+ }
+ }
+ }
+ vtkIdType *pts = 0, npts = 0;
+ vtkIntArray* aCellLocationsArray = vtkIntArray::New();
+ aCellLocationsArray->SetNumberOfComponents(1);
+ aCellLocationsArray->SetNumberOfTuples(aNbCells);
+ aConnectivity->InitTraversal();
+ for(int i=0; aConnectivity->GetNextCell(npts,pts); i++){
+ aCellLocationsArray->SetValue(i,aConnectivity->GetTraversalLocation(npts));
+ //aCellLocationsArray->InsertNextValue(aConnectivity->GetTraversalLocation(npts));
+ }
+ theStorage->SetCells(aCellTypesArray,aCellLocationsArray,aConnectivity);
+}
+
+
+void VISU_Convertor_impl::GetCellsOnGroup(VISU::TVTKSource& theStorage,
+ const VISU::TMesh& theMesh,
+ const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet)
+ const throw (std::runtime_error&)
+{
+ //Calculate dimentions of the group
+ int aNbCells = 0, aCellsSize = 0;
+ VISU::TFamilyAndEntitySet::const_iterator aFamilyAndEntitySetIter = theFamilyAndEntitySet.begin();
+ for(; aFamilyAndEntitySetIter != theFamilyAndEntitySet.end(); aFamilyAndEntitySetIter++){
+ const VISU::TFamilyAndEntity& aFamilyAndEntity = *aFamilyAndEntitySetIter;
+ const string& aFamilyName = aFamilyAndEntity.first;
+ const VISU::TEntity& anEntity = aFamilyAndEntity.second;
+ const VISU::TMeshOnEntity& aMeshOnEntity = theMesh.myMeshOnEntityMap.find(anEntity)->second;
+ pair<int,int> aCellsDim = aMeshOnEntity.GetCellsDims(aFamilyName);
+ aNbCells += aCellsDim.first;
+ aCellsSize += aCellsDim.second;
+ }
+ vtkCellArray* aConnectivity = vtkCellArray::New();
+ //vtkIdType *anIdArray = aConnectivity->WritePointer(0,aCellsSize);
+ aConnectivity->Allocate(aCellsSize,0);
+ vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
+ aCellTypesArray->SetNumberOfComponents(1);
+ aCellTypesArray->SetNumberOfTuples(aNbCells);
+ aFamilyAndEntitySetIter = theFamilyAndEntitySet.begin();
+ for(int i = 0, j = 0; aFamilyAndEntitySetIter != theFamilyAndEntitySet.end(); aFamilyAndEntitySetIter++){
+ const VISU::TFamilyAndEntity& aFamilyAndEntity = *aFamilyAndEntitySetIter;
+ const string& aFamilyName = aFamilyAndEntity.first;
+ const VISU::TEntity& anEntity = aFamilyAndEntity.second;
+ const VISU::TMeshOnEntity& aMeshOnEntity = theMesh.myMeshOnEntityMap.find(anEntity)->second;
+ const VISU::TFamily& aFamily = *(VISU::GetFamily(aMeshOnEntity,aFamilyName));
+ const VISU::TMeshOnEntity::TCellsConn &aCellsConn = aMeshOnEntity.myCellsConn;
+ VISU::TMeshOnEntity::TCellsConn::const_iterator aCellsConnIter = aCellsConn.begin();
+ for(; aCellsConnIter != aCellsConn.end(); aCellsConnIter++){
+ const VISU::TMeshOnEntity::TConnForCellType& anArray = aCellsConnIter->second;
+ int aVtkType = aCellsConnIter->first;
+ if(MYDEBUG) MESSAGE("GetCellsOnGroup - aVtkType = "<<aVtkType<<"; anArray.size() = "<<anArray.size());
+ const VISU::TFamily::TSubMesh& aSubMesh = aFamily.mySubMesh;
+ if(aSubMesh.empty()) throw std::runtime_error("GetCells >> There is no elements on the family !!!");
+ VISU::TFamily::TSubMesh::const_iterator aSubMeshIter = aSubMesh.find(aVtkType);
+ if(aSubMeshIter == aSubMesh.end()) continue;
+ const VISU::TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aSubMeshIter->second;
+ if(MYDEBUG) MESSAGE("GetCellsOnGroup - aSubMeshOnCellType.size() = "<<aSubMeshOnCellType.size());
+ VISU::TFamily::TSubMeshOnCellType::const_iterator aSubMeshOnCellTypeIter = aSubMeshOnCellType.begin();
+ for(; aSubMeshOnCellTypeIter != aSubMeshOnCellType.end(); aSubMeshOnCellTypeIter++, i++){
+ PrintCells(i,aConnectivity,anArray[*aSubMeshOnCellTypeIter]);
+ aCellTypesArray->SetValue(j++,(unsigned char)aVtkType);
+ //aCellTypesArray->InsertNextValue((unsigned char)aVtkType);
+ }
+ }
+ }
+ vtkIdType *pts = 0, npts = 0;
+ vtkIntArray* aCellLocationsArray = vtkIntArray::New();
+ aCellLocationsArray->SetNumberOfComponents(1);
+ aCellLocationsArray->SetNumberOfTuples(aNbCells);
+ aConnectivity->InitTraversal();
+ for(int i = 0; aConnectivity->GetNextCell(npts,pts); i++){
+ aCellLocationsArray->SetValue(i,aConnectivity->GetTraversalLocation(npts));
+ //aCellLocationsArray->InsertNextValue(aConnectivity->GetTraversalLocation(npts));
+ }
+ theStorage->SetCells(aCellTypesArray,aCellLocationsArray,aConnectivity);
+}
+
+
+void VISU_Convertor_impl::GetPoints(VISU::TVTKSource& theStorage, const VISU::TMesh& theMesh)
+ const throw (std::runtime_error&)
+{
+ vtkPoints* aPoints = theMesh.myPoints.get();
+ if(!aPoints){
+ aPoints = vtkPoints::New();
+ const VISU::TMesh::TPointsCoord& anArray = theMesh.myPointsCoord;
+ vtkIdType iEnd = theMesh.myPointsCoord.size();
+ vtkIdType aNbPoints = iEnd / theMesh.myDim;
+ aPoints->SetNumberOfPoints(aNbPoints);
+ if(MYDEBUG)
+ MESSAGE("GetPoints - aNbPoints = "<<aNbPoints<<"; myDim = "<<theMesh.myDim);
+ switch(theMesh.myDim) {
+ case 1:
+ for (vtkIdType i = 0, j = 0; i < iEnd; i += theMesh.myDim, j++)
+ aPoints->SetPoint(j,anArray[i],0.0,0.0);
+ break;
+ case 2:
+ for (vtkIdType i = 0, j = 0; i < iEnd; i += theMesh.myDim, j++)
+ aPoints->SetPoint(j,anArray[i],anArray[i+1],0.0);
+ break;
+ case 3:
+ for (vtkIdType i = 0, j = 0; i < iEnd; i += theMesh.myDim, j++)
+ aPoints->SetPoint(j,anArray[i],anArray[i+1],anArray[i+2]);
+ break;
+ }
+ }
+ theStorage->SetPoints(aPoints);
+}
+
+void VISU_Convertor_impl::GetField(VISU::TVTKSource& theStorage,
+ const VISU::TMesh& theMesh,
+ const VISU::TMeshOnEntity& theMeshOnEntity,
+ const VISU::TField& theField,
+ const VISU::TField::TValForTime& theValForTime)
+ const throw (std::runtime_error&)
+{
+ if(MYDEBUG) MESSAGE("GetField - aTime = "<<theValForTime.myId<<"; theField.myName = "<<theField.myName);
+ int aNumberOfTuples;
+ vtkDataSetAttributes* aDataSetAttributes;
+ switch(theField.myEntity) {
+ case VISU::NODE_ENTITY :
+ {
+ int aNbPoints = theMesh.myPointsCoord.size()/theMesh.myDim;
+ aNumberOfTuples = aNbPoints;
+ aDataSetAttributes = theStorage->GetPointData();
+ break;
+ }
+ default:
+ {
+ pair<int,int> aCellsDim = theMeshOnEntity.GetCellsDims();
+ int aNbCells = aCellsDim.first, aCellsSize = aCellsDim.second;
+ aNumberOfTuples = aNbCells;
+ aDataSetAttributes = theStorage->GetCellData();
+ }
+ }
+ vtkFloatArray *aFloatArray = vtkFloatArray::New();
+ switch(theField.myNbComp) {
+ case 1:
+ aFloatArray->SetNumberOfComponents(1);
+ aDataSetAttributes->SetScalars(aFloatArray);
+ break;
+ default:
+ aFloatArray->SetNumberOfComponents(3);
+ aDataSetAttributes->SetVectors(aFloatArray);
+ }
+ aFloatArray->SetNumberOfTuples(aNumberOfTuples);
+ //const VISU::TField::TTime& aTime = theValForTime.myTime;
+ //string aFieldName = theField.myMeshName + ", " + theField.myName + ": " + GenerateName(aTime);
+ //aFloatArray->SetName(aFieldName.c_str());
+ if(MYDEBUG) MESSAGE("GetField - aNumberOfTuples = "<<aNumberOfTuples);
+ const VISU::TField::TValForCells& aValForCells = theValForTime.myValForCells;
+ VISU::TField::TValForCells::const_iterator aValForCellsIter = aValForCells.begin();
+ for(int k = 0; aValForCellsIter != aValForCells.end(); aValForCellsIter++) {
+ const VISU::TField::TValForCellsWithType& anArray = aValForCellsIter->second;
+ int iEnd = anArray.size()/theField.myNbComp;
+ int aVtkType = aValForCellsIter->first;
+ if(MYDEBUG) MESSAGE("GetField - iEnd = "<<iEnd<<"; aVtkType = "<<aVtkType);
+ switch(theField.myNbComp) {
+ case 1:
+ for (int i = 0; i < iEnd; i++)
+ aFloatArray->SetTuple1(k++,anArray[i]);
+ break;
+ case 2:
+ for (int i = 0, ji = 0; i < iEnd; ++i, ji = i*2)
+ aFloatArray->SetTuple3(k++,anArray[ji],anArray[ji+1],0.0);
+ break;
+ case 3:
+ for (int i = 0, ji = 0; i < iEnd; ++i, ji = i*3)
+ aFloatArray->SetTuple3(k++,anArray[ji],anArray[ji+1],anArray[ji+2]);
+ break;
+ default:
+ throw std::runtime_error("GetField - There is algorithm for representation the field !!!");
+ }
+ }
+}
+
+
+void VISU_Convertor_impl::FindMesh(const string& theMeshName, VISU::TMesh*& theMesh)
+ throw (std::runtime_error&)
+{
+ GetMeshMap();
+ if(myMeshMap.find(theMeshName) == myMeshMap.end())
+ throw std::runtime_error("FindMesh >> There is no mesh with the name!!!");
+ theMesh = &myMeshMap[theMeshName];
+}
+
+
+void VISU_Convertor_impl::FindMeshOnEntity(const string& theMeshName, VISU::TMesh*& theMesh,
+ const VISU::TEntity& theEntity, VISU::TMeshOnEntity*& theMeshOnEntity,
+ const string& theFamilyName, VISU::TFamily*& theFamily)
+ throw (std::runtime_error&)
+{
+ FindMesh(theMeshName,theMesh);
+ VISU::TMeshOnEntityMap& aMeshOnEntityMap = theMesh->myMeshOnEntityMap;
+ if(aMeshOnEntityMap.find(theEntity) == aMeshOnEntityMap.end())
+ throw std::runtime_error("FindMeshOnEntity >> There is no mesh on the entity!!!");
+ theMeshOnEntity = &aMeshOnEntityMap[theEntity];
+ theFamily = VISU::GetFamily(*theMeshOnEntity,theFamilyName);
+}
+
+
+vtkIdType VISU_Convertor_impl::GetMeshOnEntitySize(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFamilyName)
+ throw (std::runtime_error&)
+{
+ VISU::TMesh* pMesh = NULL;
+ VISU::TFamily* pFamily = NULL;
+ VISU::TMeshOnEntity* pMeshOnEntity = NULL;
+ FindMeshOnEntity(theMeshName,pMesh,theEntity,pMeshOnEntity,theFamilyName,pFamily);
+ vtkIdType aResult = 3*pMesh->myNbPoints*sizeof(VISU::TMesh::TCoord);
+ vtkIdType aNbCells, aCellsSize;
+ if(!pFamily){
+ aNbCells = pMeshOnEntity->myNbCells;
+ aCellsSize = pMeshOnEntity->myCellsSize;
+ }else{
+ aNbCells = pFamily->myNbCells;
+ aCellsSize = pFamily->myCellsSize;
+ }
+ //that is Connectivity + (Types + Locations + Links)
+ aResult += aCellsSize*sizeof(vtkIdType) +
+ aNbCells*(sizeof(char) + sizeof(int) + (sizeof(short) + sizeof(vtkIdType)));
+ if(MYDEBUG) cout<<"VISU_Convertor_impl::GetMeshOnEntitySize = "<<aResult<<endl;
+ return aResult;
+}
+
+
+void VISU_Convertor_impl::FindMeshOnGroup(const std::string& theMeshName, VISU::TMesh*& theMesh,
+ const std::string& theGroupName, VISU::TGroup*& theGroup)
+ throw (std::runtime_error&)
+{
+ FindMesh(theMeshName,theMesh);
+ VISU::TGroupMap& aGroupMap = theMesh->myGroupMap;
+ VISU::TGroupMap::iterator aGroupMapIter = aGroupMap.find(theGroupName);
+ if(aGroupMapIter == aGroupMap.end())
+ throw std::runtime_error("FindMeshOnGroup >> There is no the group in the mesh!!!");
+ theGroup = &aGroupMapIter->second;
+}
+
+
+vtkIdType VISU_Convertor_impl::GetMeshOnGroupSize(const std::string& theMeshName,
+ const std::string& theGroupName)
+ throw (std::runtime_error&)
+{
+ VISU::TMesh* pMesh = NULL;
+ VISU::TGroup* pGroup = NULL;
+ FindMeshOnGroup(theMeshName,pMesh,theGroupName,pGroup);
+ vtkIdType aResult = 3*pMesh->myNbPoints*sizeof(VISU::TMesh::TCoord);
+ aResult += pGroup->myCellsSize*sizeof(vtkIdType);
+ if(MYDEBUG) cout<<"VISU_Convertor_impl::GetMeshOnGroupSize = "<<aResult<<endl;
+ return aResult;
+}
+
+
+void VISU_Convertor_impl::FindField(const string& theMeshName, VISU::TMesh*& theMesh,
+ const VISU::TEntity& theEntity,
+ VISU::TMeshOnEntity*& theMeshOnEntity,
+ VISU::TMeshOnEntity*& theVTKMeshOnEntity,
+ const string& theFieldName, VISU::TField*& theField)
+ throw (std::runtime_error&)
+{
+ VISU::TFamily* pFamily = NULL;
+ VISU::TMeshOnEntity* pMeshOnEntity = NULL;
+ FindMeshOnEntity(theMeshName,theMesh,theEntity,pMeshOnEntity,"",pFamily);
+ theMeshOnEntity = pMeshOnEntity;
+ VISU::TMeshOnEntityMap& aMeshOnEntityMap = theMesh->myMeshOnEntityMap;
+ if(theEntity == VISU::NODE_ENTITY){
+ if(aMeshOnEntityMap.find(VISU::CELL_ENTITY) == aMeshOnEntityMap.end())
+ throw std::runtime_error("FindField >> There is no mesh on CELL_ENTITY!!!");
+ pMeshOnEntity = &aMeshOnEntityMap[VISU::CELL_ENTITY];
+ }
+ theVTKMeshOnEntity = pMeshOnEntity;
+ VISU::TFieldMap& aFieldMap = theMeshOnEntity->myFieldMap;
+ if(aFieldMap.find(theFieldName) == aFieldMap.end())
+ throw std::runtime_error("FindField >> There is no field on the mesh!!!");
+ theField = &aFieldMap[theFieldName];
+}
+
+
+vtkIdType VISU_Convertor_impl::GetFieldOnMeshSize(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName)
+ throw(std::runtime_error&)
+{
+ VISU::TMesh* pMesh = NULL;
+ VISU::TField* pField = NULL;
+ VISU::TMeshOnEntity *pMeshOnEntity = NULL, *pVTKMeshOnEntity = NULL;
+ FindField(theMeshName,pMesh,theEntity,pMeshOnEntity,pVTKMeshOnEntity,
+ theFieldName,pField);
+
+ vtkIdType aResult = GetMeshOnEntitySize(theMeshName,theEntity);
+ aResult += pField->myDataSize*sizeof(float)*pField->myNbValField;
+ if(MYDEBUG) cout<<"VISU_Convertor_impl::GetFieldOnMeshSize = "<<aResult<<endl;
+ return aResult;
+}
+
+
+void VISU_Convertor_impl::FindTimeStamp(const std::string& theMeshName, VISU::TMesh*& theMesh,
+ const VISU::TEntity& theEntity,
+ VISU::TMeshOnEntity*& theMeshOnEntity,
+ VISU::TMeshOnEntity*& theVTKMeshOnEntity,
+ const std::string& theFieldName, VISU::TField*& theField,
+ int theStampsNum, VISU::TField::TValForTime*& theValForTime)
+ throw (std::runtime_error&)
+{
+ FindField(theMeshName,theMesh,theEntity,theMeshOnEntity,theVTKMeshOnEntity,theFieldName,theField);
+ VISU::TField::TValField& aValField = theField->myValField;
+ if(aValField.find(theStampsNum) == aValField.end())
+ throw std::runtime_error("FindTimeStamp >> There is no field with the timestamp!!!");
+ theValForTime = &aValField[theStampsNum];
+}
+
+
+vtkIdType VISU_Convertor_impl::GetTimeStampSize(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName,
+ int theStampsNum)
+ throw (std::runtime_error&)
+{
+ VISU::TMesh* pMesh = NULL;
+ VISU::TField* pField = NULL;
+ VISU::TMeshOnEntity *pMeshOnEntity = NULL, *pVTKMeshOnEntity = NULL;
+ VISU::TField::TValForTime* pValForTime = NULL;
+ FindTimeStamp(theMeshName,pMesh,theEntity,pMeshOnEntity,pVTKMeshOnEntity,
+ theFieldName,pField,theStampsNum,pValForTime);
+
+ vtkIdType aResult = GetMeshOnEntitySize(theMeshName,theEntity);
+ aResult += pField->myDataSize*sizeof(float);
+ if(MYDEBUG) cout<<"VISU_Convertor_impl::GetTimeStampSize = "<<aResult<<endl;
+ return aResult;
+}
+
+
+const VISU::TField&
+VISU_Convertor_impl::GetField(const string& theMeshName,
+ VISU::TEntity theEntity,
+ const string& theFieldName)
+ throw (std::runtime_error&)
+{
+ VISU::TMesh* pMesh = NULL;
+ VISU::TField* pField = NULL;
+ VISU::TFamily* pFamily = NULL;
+ VISU::TMeshOnEntity *pMeshOnEntity = NULL, *pVTKMeshOnEntity = NULL;
+ FindField(theMeshName,pMesh,theEntity,pMeshOnEntity,pVTKMeshOnEntity,
+ theFieldName,pField);
+ return *pField;
+}
+
+
+const VISU::TField::TValForTime&
+VISU_Convertor_impl::GetTimeStamp(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName,
+ int theStampsNum)
+ throw (std::runtime_error&)
+{
+ VISU::TMesh* pMesh = NULL;
+ VISU::TField* pField = NULL;
+ VISU::TMeshOnEntity *pMeshOnEntity = NULL, *pVTKMeshOnEntity = NULL;
+ VISU::TField::TValForTime* pValForTime = NULL;
+ FindTimeStamp(theMeshName,pMesh,theEntity,pMeshOnEntity,pVTKMeshOnEntity,
+ theFieldName,pField,theStampsNum,pValForTime);
+ return *pValForTime;
+}
+
+
--- /dev/null
+// Copyright (C) 2003 CEA/DEN, EDF R&D
+//
+//
+//
+// File : VISU_Convertor_impl.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_Convertor_impl_HeaderFile
+#define VISU_Convertor_impl_HeaderFile
+
+#include "VISU_Convertor.hxx"
+
+extern "C"{
+#include <med.h>
+}
+
+#include <qstring.h>
+#include <qfileinfo.h>
+
+class VISU_Convertor_impl: public VISU_Convertor{
+private:
+ void GetPoints(VISU::TVTKSource& theStorage,
+ const VISU::TMesh& theMesh)
+ const throw (std::runtime_error&);
+ void GetCellsOnEntity(VISU::TVTKSource& theStorage,
+ const VISU::TMeshOnEntity& theMeshOnEntity,
+ const std::string& theFamilyName)
+ const throw (std::runtime_error&);
+ void GetCellsOnGroup(VISU::TVTKSource& theStorage,
+ const VISU::TMesh& theMesh,
+ const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet)
+ const throw (std::runtime_error&);
+ void GetField(VISU::TVTKSource& theStorage,
+ const VISU::TMesh& theMesh,
+ const VISU::TMeshOnEntity& theMeshOnEntity,
+ const VISU::TField& theField,
+ const VISU::TField::TValForTime& theValForTime)
+ const throw (std::runtime_error&);
+
+
+protected:
+ void FindMesh(const std::string& theMeshName, VISU::TMesh*& theMesh)
+ throw(std::runtime_error&);
+ void FindMeshOnEntity(const std::string& theMeshName, VISU::TMesh*& theMesh,
+ const VISU::TEntity& theEntity, VISU::TMeshOnEntity*& theMeshOnEntity,
+ const std::string& theFamilyName, VISU::TFamily*& theFamily)
+ throw (std::runtime_error&);
+
+ void FindMeshOnGroup(const std::string& theMeshName, VISU::TMesh*& theMesh,
+ const std::string& theGroupName, VISU::TGroup*& theGroup)
+ throw (std::runtime_error&);
+
+ void FindField(const std::string& theMeshName, VISU::TMesh*& theMesh,
+ const VISU::TEntity& theEntity,
+ VISU::TMeshOnEntity*& theMeshOnEntity,
+ VISU::TMeshOnEntity*& theVTKMeshOnEntity,
+ const std::string& theFieldName, VISU::TField*& theField)
+ throw (std::runtime_error&);
+ void FindTimeStamp(const std::string& theMeshName, VISU::TMesh*& theMesh,
+ const VISU::TEntity& theEntity,
+ VISU::TMeshOnEntity*& theMeshOnEntity,
+ VISU::TMeshOnEntity*& theVTKMeshOnEntity,
+ const std::string& theFieldName, VISU::TField*& theField,
+ int theStampsNum, VISU::TField::TValForTime*& theValForTime)
+ throw (std::runtime_error&);
+
+
+public:
+ virtual vtkIdType GetMeshOnEntitySize(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFamilyName = "")
+ throw (std::runtime_error&);
+ virtual vtkIdType GetMeshOnGroupSize(const std::string& theMeshName,
+ const std::string& theGroupName)
+ throw(std::runtime_error&);
+ virtual vtkIdType GetTimeStampSize(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName,
+ int theStampsNum)
+ throw(std::runtime_error&);
+ virtual vtkIdType GetFieldOnMeshSize(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName)
+ throw(std::runtime_error&);
+ virtual const VISU::TField& GetField(const std::string& theMeshName,
+ VISU::TEntity theEntity,
+ const std::string& theFieldName)
+ throw(std::runtime_error&);
+ virtual const VISU::TField::TValForTime& GetTimeStamp(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName,
+ int theStampsNum)
+ throw(std::runtime_error&);
+
+public:
+ VISU_Convertor_impl();
+ virtual ~VISU_Convertor_impl();
+ virtual VISU_Convertor* Build() throw (std::runtime_error&) { return this;};
+ virtual TOutput* GetMeshOnEntity(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFamilyName = "")
+ throw(std::runtime_error&);
+ virtual TOutput* GetMeshOnGroup(const std::string& theMeshName,
+ const std::string& theGroupName)
+ throw(std::runtime_error&);
+ virtual TOutput* GetTimeStampOnMesh(const std::string& theMeshName,
+ const VISU::TEntity& theEntity,
+ const std::string& theFieldName,
+ int theStampsNum)
+ throw(std::runtime_error&);
+
+ protected:
+ virtual int LoadMeshOnEntity(VISU::TMeshOnEntity& theMeshOnEntity,
+ const std::string& theFamilyName = "")
+ throw (std::runtime_error&) = 0;
+ virtual int LoadMeshOnGroup(VISU::TMesh& theMesh,
+ const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet)
+ throw (std::runtime_error&) = 0;
+ virtual int LoadFieldOnMesh(VISU::TMesh& theMesh,
+ VISU::TMeshOnEntity& theMeshOnEntity,
+ VISU::TField& theField,
+ VISU::TField::TValForTime& theValForTime)
+ throw (std::runtime_error&) = 0;
+};
+
+template<class T> std::string dtos(const std::string& fmt, T val){
+ static QString aString;
+ aString.sprintf(fmt.c_str(),val);
+ return aString.latin1();
+}
+
+extern "C"{
+ int getNbMedConnect(int theMedType, int theMedEntity, int theMeshDim);
+ int getNbMedNodes(int theMedType);
+ int med2vtkCellType(int theMedType);
+ int vtk2medCellType(int theVtkType);
+ int getIdMedType(int medType);
+}
+
+struct Med2vtk {
+ med_geometrie_element medType;
+ const char *medName;
+ int medNbNodes;
+ int vtkType;
+ const char *vtkName;
+ int vtkNbNodes;
+};
+extern Med2vtk med2vtk[MED_NBR_GEOMETRIE_MAILLE];
+#endif
--- /dev/null
+// Copyright (C) 2003 CEA/DEN, EDF R&D
+//
+//
+//
+// File : VISU_DatConvertor.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+using namespace std;
+#include "VISU_DatConvertor.hxx"
+using namespace std;
+
+#ifdef DEBUG
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+static int PRECISION = 7;
+
+extern "C"
+VISU_Convertor* CreateDatConvertor(const string& theFileName) throw(std::runtime_error&){
+ VISU_DatConvertor* aConvertor = new VISU_DatConvertor(theFileName);
+ aConvertor->Build();
+ return aConvertor;
+}
+VISU_DatConvertor::VISU_DatConvertor(const string& theFileName) throw(std::runtime_error&){
+ myFileInfo.setFile(QString(theFileName.c_str()));
+ myName = (const char*)(myFileInfo.baseName());
+}
+
+VISU_Convertor* VISU_DatConvertor::Build() throw (std::runtime_error&){
+ /*
+ ifstream stmIn(myFileInfo.absFilePath());
+ if(!stmIn.good())
+ throw std::runtime_error(string("VISU_DatConvertor::CreateResult() >> can't open file - ") +
+ (const char*)myFileInfo.absFilePath());
+ int aNbPoints, aNbCells, aNbFields;
+ ImportHead(&stmIn,&aNbPoints,&aNbCells,&aNbFields);
+ ImportPoints(&stmIn,aNbPoints);
+ vector<int> aCellsType(aNbCells);
+ ImportCells(&stmIn,&aCellsType);
+ for(int i = 0; i < aNbFields; i++)
+ ImportField(&stmIn,aNbPoints,&aCellsType);
+ myIsDone = true;
+ */
+ return this;
+}
+
+int VISU_DatConvertor::ImportField(ifstream* pStmIn, int theNbPoints, vector<int>* pCellsType)
+ throw (std::runtime_error&)
+{
+ /*
+ ifstream &stmIn = *pStmIn;
+ vector<int>& aCellsType = *pCellsType;
+ int aNbCells = aCellsType.size();
+ string aName; stmIn>>aName; stmIn>>aName;
+ VISU::TMesh& aMesh = myMeshMap[myName];
+ VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[VISU::CELL_ENTITY];
+ VISU::TField& aField = aMeshOnEntity.myFieldMap[aName];
+ aField.myMeshName = myName;
+ stmIn>>(aField.myNbComp);
+ aField.myNbComp %= 100;
+ int iEnd; stmIn>>iEnd;
+ if(iEnd == theNbPoints)
+ aField.myEntity = VISU::NODE_ENTITY;
+ else if(iEnd == aNbCells)
+ aField.myEntity = VISU::CELL_ENTITY;
+ else
+ throw std::runtime_error("ImportChamp >> elements doesn't connected to points or cells");
+ if(MYDEBUG)
+ MESSAGE("FieldInfo - myMeshName = "<<aField.myMeshName<<"; myNbComp = "<<aField.myNbComp);
+ for(int i = 0, tmp; i < iEnd; i++) {
+ stmIn>>tmp;
+ VISU::TField::TTime aTime(0.0,"");
+ VISU::TField::TValForCellsWithType &anArray = aField.myValField[aTime][aCellsType[i]];
+ for(int j = 0; j < aField.myNbComp; j++){
+ float tmp; stmIn>>tmp;
+ anArray.push_back(tmp);
+ }
+ }
+ */
+ return 0;
+}
+
+int VISU_DatConvertor::ImportHead(ifstream* pStmIn, int* theNbPoints,
+ int* theNbCells, int* theNbFields)
+ throw (std::runtime_error&)
+{
+ /*
+ ifstream &stmIn = *pStmIn;
+ const int BUFSIZE = 256;
+ char buf[BUFSIZE];
+ stmIn.getline(buf,BUFSIZE);
+ istrstream strIn(buf);
+ VISU::TMesh& aMesh = myMeshMap[myName];
+ *theNbFields = 0;
+ strIn>>(*theNbPoints); strIn>>(*theNbCells); strIn>>(*theNbFields);
+ if(MYDEBUG)
+ MESSAGE("ImportHead - theNbPoints = "<<(*theNbPoints)<<
+ "; theNbCells = "<<(*theNbCells)<<
+ "; theNbFields = "<<(*theNbFields));
+ */
+ return 0;
+}
+
+int VISU_DatConvertor::ImportPoints(ifstream* pStmIn, int theNbPoints)
+ throw (std::runtime_error&)
+{
+ /*
+ ifstream &stmIn = *pStmIn;
+ VISU::TMesh& aMesh = myMeshMap[myName];
+ aMesh.myName = myName;
+ aMesh.myDim = 3;
+ int iEnd = aMesh.myDim*theNbPoints;
+ if(MYDEBUG) MESSAGE("ImportPoints - iEnd = "<<iEnd);
+ vector<float> &aPointsCoord = aMesh.myPointsCoord;
+ aPointsCoord.resize(iEnd);
+ for(int i = 0, tmp; i < iEnd;){
+ stmIn>>tmp;
+ stmIn>>aPointsCoord[i++]; stmIn>>aPointsCoord[i++]; stmIn>>aPointsCoord[i++];
+ }
+ */
+ return 0;
+}
+
+int VISU_DatConvertor::ImportCells(ifstream* pStmIn, vector<int>* pCellsType)
+ throw (std::runtime_error&)
+{
+ /*
+ ifstream &stmIn = *pStmIn;
+ vector<int>& aCellsType = *pCellsType;
+ int aNbCells = aCellsType.size();
+ if(MYDEBUG) MESSAGE("ImportCells - theNbCells - Beginning");
+ VISU::TMesh& aMesh = myMeshMap[myName];
+ VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[VISU::CELL_ENTITY];
+ aMeshOnEntity.myEntity = VISU::CELL_ENTITY;
+ aMeshOnEntity.myMeshName = myName;
+ for(int i = 0, aMedType, aVtkType; i < aNbCells; i++){
+ stmIn>>aMedType; stmIn>>aMedType;
+ aCellsType[i] = aVtkType = med2vtkCellType(aMedType);
+ VISU::TMeshOnEntity::TConnForCellType& anArray = aMeshOnEntity.myCellsConn[aVtkType];
+ anArray.push_back(VISU::TMeshOnEntity::TConnect());
+ VISU::TMeshOnEntity::TConnect& aVector = anArray.back();
+ int jEnd = getNbMedNodes(aMedType);
+ aVector.resize(jEnd);
+ for(int j = 0, tmp; j < jEnd; j++){
+ stmIn>>tmp;
+ aVector[j] = tmp - 1;
+ }
+ }
+ if(MYDEBUG) MESSAGE("ImportCells - theNbCells - End");
+ */
+ return 0;
+}
+
+/*
+int VISU_Convertor_impl::ToDatFile(const string& theFileName) throw(std::runtime_error&){
+ if(MYDEBUG) MESSAGE("VISU_Convertor_impl::ToDatFile - "<<theFileName);
+ if(!myIsDone && Build() != NULL) myIsDone = true;
+ ofstream stmOut(theFileName.c_str(),ios::out);
+ stmOut.precision(PRECISION);
+ stmOut.setf(ios::scientific,ios::floatfield);
+
+ VISU::TMeshMap::const_iterator aMeshIter = myMeshMap.begin();
+ if(aMeshIter != myMeshMap.end()){
+ const VISU::TMesh &aMesh = aMeshIter->second;
+ if(MYDEBUG) MESSAGE("VISU_Convertor_impl::ToDatFile - aMeshName = "<<aMeshIter->first);
+ VISU::TFieldMap aFieldMap = GetFieldMapForMesh(aMeshIter->first);
+ const VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh.myMeshOnEntityMap;
+ VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter = aMeshOnEntityMap.find(VISU::CELL_ENTITY);
+ if(aMeshOnEntityMapIter != aMeshOnEntityMap.end()){
+ const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second;
+ int aNbPoints = aMesh.myPointsCoord.size()/aMesh.myDim;
+ int aNbCells = aMeshOnEntity.GetCellsDims().first;
+ stmOut<<aNbPoints<<"\t"<<aNbCells<<"\t"<<aFieldMap.size()<<endl;
+ if(MYDEBUG)
+ MESSAGE("VISU_Convertor_impl::ToDatFile - aNbPoints = "<<aNbPoints<<
+ "; aNbCells = "<<aNbCells<<"; aNbFields = "<<aFieldMap.size());
+ for(int i = 0, j = 0; i < aNbPoints; i++, j = 3*i){
+ stmOut<<(i+1)<<"\t";
+ stmOut<<aMesh.myPointsCoord[j]<<"\t";
+ stmOut<<aMesh.myPointsCoord[j+1]<<"\t";
+ stmOut<<aMesh.myPointsCoord[j+2]<<endl;
+ }
+ const VISU::TMeshOnEntity::TCellsConn &aCellsConn = aMeshOnEntity.myCellsConn;
+ VISU::TMeshOnEntity::TCellsConn::const_iterator iter = aCellsConn.begin();
+ for(int i = 0; iter != aCellsConn.end(); iter++){
+ if(MYDEBUG)
+ MESSAGE("VISU_Convertor_impl::ToDatFile - vtkCellType = "<<iter->first);
+ const VISU::TMeshOnEntity::TConnForCellType& anArray = iter->second;
+ for(int j = 0, jEnd = anArray.size(); j < jEnd; j++){
+ stmOut<<(++i)<<"\t";
+ stmOut<<vtk2medCellType(iter->first)<<"\t";
+ const vector<int>& aVector = anArray[j];
+ int kEnd = aVector.size();
+ for(int k = 0; k < kEnd; k++)
+ stmOut<<aVector[k]<<"\t";
+ stmOut<<endl;
+ }
+ }
+ if(MYDEBUG) MESSAGE("VISU_Convertor_impl::ToDatFile - Beginning of Field Conversion");
+ VISU::TFieldMap::const_iterator aFieldIter = aFieldMap.begin();
+ for(int i = 0; aFieldIter != aFieldMap.end(); aFieldIter++){
+ const VISU::TField &aField = aFieldIter->second;
+ const VISU::TField::TValField &aValField = aField.myValField;
+ VISU::TField::TValField::const_reverse_iterator iter = aField.myValField.rbegin();
+ for(int i = 0; iter != aValField.rend(); iter++, i++) {
+ if(MYDEBUG) MESSAGE("VISU_Convertor_impl::ToDatFile - aTime = "<<i);
+ const VISU::TField::TValForTime& aValForTime = iter->second;
+ VISU::TField::TValForTime::const_iterator jter = aValForTime.begin();
+ stmOut<<(++i)<<endl;
+ int prefix = (aField.myEntity == VISU::CELL_ENTITY? 100: 200);
+ int jEnd = (aField.myEntity == VISU::CELL_ENTITY? aNbCells: aNbPoints);
+ string aName = GenerateName((aFieldIter->first).c_str(),i);
+ stmOut<<aName<<endl;
+ stmOut<<(prefix + aField.myNbComp)<<"\t"<<jEnd<<endl;
+ if(MYDEBUG)
+ MESSAGE("VISU_Convertor_impl::ToDatFile - aName = "<<aName<<"; jEnd = "<<jEnd);
+ for(int j = 0; jter != aValForTime.end(); jter++) {
+ const VISU::TField::TValForCellsWithType& anArray = jter->second;
+ int kEnd = anArray.size(), aVtkType = jter->first;
+ switch(aField.myNbComp) {
+ case 1:
+ for (int k = 0; k < kEnd;) {
+ stmOut<<(++j)<<"\t";
+ stmOut<<anArray[k++]<<"\n";
+ }
+ break;
+ case 2:
+ for (int k = 0; k < kEnd;){
+ stmOut<<(++j)<<"\t";
+ stmOut<<anArray[k++]<<"\t";
+ stmOut<<anArray[k++]<<"\t";
+ stmOut<<0.0<<"\n";
+ }
+ break;
+ case 3:
+ for (int k = 0; k < kEnd;){
+ stmOut<<(++j)<<"\t";
+ stmOut<<anArray[k++]<<"\t";
+ stmOut<<anArray[k++]<<"\t";
+ stmOut<<anArray[k++]<<"\n";
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ return 1;
+}
+*/
--- /dev/null
+// Copyright (C) 2003 CEA/DEN, EDF R&D
+//
+//
+//
+// File : VISU_DatConvertor.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_DatConvertor_HeaderFile
+#define VISU_DatConvertor_HeaderFile
+
+#include "VISU_Convertor_impl.hxx"
+#include <fstream>
+
+class VISU_DatConvertor: public VISU_Convertor_impl{
+ VISU_DatConvertor();
+ VISU_DatConvertor(const VISU_DatConvertor&);
+public:
+ VISU_DatConvertor(const string& theFileName) throw (std::runtime_error&);
+ virtual VISU_Convertor* Build() throw (std::runtime_error&);
+protected:
+ QFileInfo myFileInfo;
+ int ImportHead(ifstream* pStmIn, int* theNbPoints, int* theNbCells, int* theNbFields)
+ throw (std::runtime_error&);
+ int ImportPoints(ifstream*, int theNbPoints)
+ throw (std::runtime_error&);
+ int ImportCells(ifstream*, vector<int>* aCellsType)
+ throw (std::runtime_error&);
+ int ImportField(ifstream*, int theNbPoints, vector<int>* aCellsType)
+ throw (std::runtime_error&);
+ protected:
+ virtual int LoadMeshOnEntity(VISU::TMeshOnEntity& theMeshOnEntity,
+ const string& theFamilyName = "")
+ throw (std::runtime_error&) {return 1;}
+ virtual int LoadMeshOnGroup(VISU::TMesh& theMesh,
+ const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet)
+ throw (std::runtime_error&) {return 1;}
+ virtual int LoadFieldOnMesh(VISU::TMesh& theMesh,
+ VISU::TMeshOnEntity& theMeshOnEntity,
+ VISU::TField& theField,
+ VISU::TField::TValForTime& theValForTime)
+ throw (std::runtime_error&) {return 1;}
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_MedConvertor.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_MedConvertor.hxx"
+#include <valarray>
+#include <vtkCellType.h>
+#define USER_INTERLACE MED_FULL_INTERLACE
+
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+static med_err ret = 0;
+
+typedef map<VISU::TEntity,med_entite_maillage> TVisu2MedEntity;
+
+static TVisu2MedEntity aVisu2MedEntity;
+
+static int INIT = (
+ aVisu2MedEntity[VISU::NODE_ENTITY] = MED_NOEUD,
+ aVisu2MedEntity[VISU::EDGE_ENTITY] = MED_ARETE,
+ aVisu2MedEntity[VISU::FACE_ENTITY] = MED_FACE,
+ aVisu2MedEntity[VISU::CELL_ENTITY] = MED_MAILLE,
+ 1);
+
+static med_geometrie_element NODEGEOM[1] = {MED_POINT1};
+
+static med_geometrie_element EDGEGEOM[MED_NBR_GEOMETRIE_ARETE] = {
+ MED_SEG2, MED_SEG3
+ };
+
+static med_geometrie_element FACEGEOM[MED_NBR_GEOMETRIE_FACE] = {
+ MED_TRIA3, MED_QUAD4, MED_TRIA6, MED_QUAD8
+ };
+
+static med_geometrie_element CELLGEOM[MED_NBR_GEOMETRIE_MAILLE] = {
+ MED_POINT1, MED_SEG2, MED_SEG3, MED_TRIA3,
+ MED_QUAD4, MED_TRIA6, MED_QUAD8, MED_TETRA4,
+ MED_PYRA5, MED_PENTA6, MED_HEXA8, MED_TETRA10,
+ MED_PYRA13, MED_PENTA15, MED_HEXA20
+ };
+
+void GetEntity2Geom(const VISU::TEntity& theEntity, med_geometrie_element*& theVector, int* theEnd)
+ throw (std::runtime_error&)
+{
+ switch(theEntity){
+ case VISU::CELL_ENTITY: theVector = CELLGEOM; *theEnd = MED_NBR_GEOMETRIE_MAILLE; break;
+ case VISU::FACE_ENTITY: theVector = FACEGEOM; *theEnd = MED_NBR_GEOMETRIE_FACE; break;
+ case VISU::EDGE_ENTITY: theVector = EDGEGEOM; *theEnd = MED_NBR_GEOMETRIE_ARETE; break;
+ case VISU::NODE_ENTITY: theVector = NODEGEOM; *theEnd = 1; break;
+ default:
+ throw std::runtime_error("GetEntity2Geom >> theEntity is uncorrect");
+ }
+}
+
+extern "C"
+VISU_Convertor* CreateMedConvertor(const string& theFileName) throw(std::runtime_error&){
+ return new VISU_MedConvertor(theFileName);
+}
+
+class MedFile{
+ char* myFileName;
+ med_idt myFid;
+ MedFile();
+ MedFile(const MedFile&);
+public:
+ MedFile(const char* theFileName) throw(std::runtime_error&) :
+ myFileName(strdup(theFileName))
+ {
+ myFid = MEDouvrir(myFileName,MED_LECT);
+ if(myFid < 0){
+ free(myFileName);
+ throw std::runtime_error(string("MedFile::MedFile >> MEDouvrir(...) - ") + theFileName);
+ }
+ }
+ ~MedFile(){
+ free(myFileName);
+ if(myFid >= 0)
+ MEDfermer(myFid);
+ }
+ const med_idt& GetFid() const { return myFid;};
+};
+
+VISU_MedConvertor::VISU_MedConvertor(const string& theFileName) throw (std::runtime_error&) {
+ myFileInfo.setFile(QString(theFileName.c_str()));
+ myName = myFileInfo.baseName().latin1();
+}
+
+VISU_Convertor* VISU_MedConvertor::Build() throw (std::runtime_error&) {
+ MedFile aMedFile(myFileInfo.absFilePath());
+ med_idt fid = aMedFile.GetFid();
+ med_int iMeshEnd = MEDnMaa(fid); //Get number of meshes
+ if(MYDEBUG) MESSAGE("ImportInfo - MEDnMaa = "<<iMeshEnd<<"; myFileInfo = "<<myFileInfo.filePath());
+ for(int iMesh = 1; iMesh <= iMeshEnd; iMesh++){
+ med_int aMeshDim;
+ char aMeshName[MED_TAILLE_NOM+1] = "";
+ MEDmaaInfo(fid,iMesh,aMeshName,&aMeshDim);
+ if(MYDEBUG) MESSAGE("ImportInfo - aMeshName = '"<<aMeshName<<"'; aMeshDim = "<<aMeshDim);
+ VISU::TMesh &aMesh = myMeshMap[aMeshName];
+ aMesh.myDim = aMeshDim;
+ aMesh.myName = aMeshName;
+ typedef map<med_int,VISU::TEntity> TFamily2EntityMap;
+ TFamily2EntityMap aFamily2EntityMap;
+ typedef map<med_int,med_int> TFamilyCounterMap;
+ TFamilyCounterMap aFamilyNbCellsCounterMap, aFamilyCellsSizeCounterMap;
+ TVisu2MedEntity::const_iterator aVisu2MedEntityIter = aVisu2MedEntity.begin();
+ for(; aVisu2MedEntityIter != aVisu2MedEntity.end(); aVisu2MedEntityIter++) {
+ VISU::TEntity anEntity = aVisu2MedEntityIter->first;
+ int iGeomElemEnd;
+ med_geometrie_element* aGeomElemVector;
+ GetEntity2Geom(anEntity,aGeomElemVector,&iGeomElemEnd);
+ med_entite_maillage& aMedEntity = aVisu2MedEntity[anEntity];
+ for (int iGeomElem = 0; iGeomElem < iGeomElemEnd; iGeomElem++) {
+ int medId = getIdMedType(aGeomElemVector[iGeomElem]);
+ int aVtkType = med2vtk[medId].vtkType;
+ med_geometrie_element aMedType = med2vtk[medId].medType;
+ if(aMedEntity == MED_NOEUD){
+ med_geometrie_element typgeo = (med_geometrie_element)0;
+ med_connectivite typco = (med_connectivite)0;
+ med_int iNumElemEnd = MEDnEntMaa(fid,aMeshName,MED_COOR,MED_NOEUD,typgeo,typco);
+ if(iNumElemEnd > 0){
+ VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity];
+ aMeshOnEntity.myEntity = anEntity;
+ aMeshOnEntity.myMeshName = aMeshName;
+ aMeshOnEntity.myNbCells = iNumElemEnd;
+ aMeshOnEntity.myCellsSize = 2*iNumElemEnd;
+ aMesh.myNbPoints = iNumElemEnd;
+ if(MYDEBUG)
+ MESSAGE("ImportInfo -\t anEntity = "<<anEntity<<
+ "; medName = "<<med2vtk[medId].medName<<
+ "; myNbCells = "<<aMeshOnEntity.myNbCells<<
+ "; myCellsSize = "<<aMeshOnEntity.myCellsSize);
+ med_booleen iname_elem, inum_elem;
+ valarray<med_int> num_elem(iNumElemEnd), num_fam_elem(iNumElemEnd);
+ valarray<char> name_elem('\0',iNumElemEnd*MED_TAILLE_PNOM+1);
+ med_repere rep;
+ valarray<char> name_coord('\0',aMesh.myDim*MED_TAILLE_PNOM+1);
+ valarray<char> unit_coord('\0',aMesh.myDim*MED_TAILLE_PNOM+1);
+ valarray<med_float> coord(aMesh.myDim*iNumElemEnd);
+ ret = MEDnoeudsLire(fid,aMeshName,aMesh.myDim,&coord[0],MED_FULL_INTERLACE,&rep,
+ &name_coord[0],&unit_coord[0],&name_elem[0],&iname_elem,
+ &num_elem[0],&inum_elem,&num_fam_elem[0],iNumElemEnd);
+ if(ret < 0) throw std::runtime_error("ImportInfo >> MEDnoeudsLire(...)");
+ for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++)
+ if(num_fam_elem[iNumElem] != 0){
+ aFamily2EntityMap[num_fam_elem[iNumElem]] = anEntity;
+ aFamilyNbCellsCounterMap[num_fam_elem[iNumElem]] += 1;
+ aFamilyCellsSizeCounterMap[num_fam_elem[iNumElem]] += 2;
+ }
+ }
+ }
+ //Get number of connectivities
+ med_int iNumElemEnd = MEDnEntMaa(fid,aMeshName,MED_CONN,aMedEntity,aMedType,MED_NOD);
+ if (iNumElemEnd > 0) {
+ VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity];
+ aMeshOnEntity.myEntity = anEntity;
+ aMeshOnEntity.myMeshName = aMeshName;
+ med_booleen iname_elem, inum_elem;
+ valarray<med_int> num_elem(iNumElemEnd), num_fam_elem(iNumElemEnd);
+ valarray<char> name_elem('\0',iNumElemEnd*MED_TAILLE_PNOM+1);
+ med_int aNbConnForElem = getNbMedConnect(aMedType,anEntity,aMesh.myDim);
+ aMeshOnEntity.myNbCells += iNumElemEnd;
+ aMeshOnEntity.myCellsSize += iNumElemEnd*(med2vtk[medId].vtkNbNodes + 1);
+ if(MYDEBUG)
+ MESSAGE("ImportInfo -\t anEntity = "<<anEntity<<
+ "; medName = "<<med2vtk[medId].medName<<
+ "; aNbConnForElem = "<<aNbConnForElem<<
+ "; myNbCells = "<<aMeshOnEntity.myNbCells<<
+ "; myCellsSize = "<<aMeshOnEntity.myCellsSize);
+ valarray<med_int> conn(0,aNbConnForElem*iNumElemEnd);
+ ret = MEDelementsLire(fid,aMeshName,aMesh.myDim,&conn[0],MED_FULL_INTERLACE,
+ &name_elem[0],&iname_elem,&num_elem[0],&inum_elem,
+ &num_fam_elem[0],iNumElemEnd,aMedEntity,aMedType,MED_NOD);
+ if (ret < 0) throw std::runtime_error("ImportInfo >> MEDelementsLire(...)");
+ for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++)
+ if(num_fam_elem[iNumElem] != 0){
+ aFamily2EntityMap[num_fam_elem[iNumElem]] = anEntity;
+ aFamilyNbCellsCounterMap[num_fam_elem[iNumElem]] += 1;
+ aFamilyCellsSizeCounterMap[num_fam_elem[iNumElem]] += med2vtk[medId].vtkNbNodes + 1;
+ }
+ }
+ }
+ }
+ med_int aNbFamily = MEDnFam(fid,aMeshName,0,MED_FAMILLE);
+ if(MYDEBUG) MESSAGE("ImportInfo - aNbFamily = "<<aNbFamily);
+ for(int aFamInd = 1; aFamInd <= aNbFamily; aFamInd++){
+ med_int aNbAttrib = MEDnFam(fid,aMeshName,aFamInd,MED_ATTR);
+ valarray<med_int> anAttId(aNbAttrib), anAttVal(aNbAttrib);
+ valarray<char> anAttDesc('\0',aNbAttrib*MED_TAILLE_DESC+1);
+ med_int aNbGroup = MEDnFam(fid,aMeshName,aFamInd,MED_GROUPE);
+ if(0 && MYDEBUG)
+ MESSAGE("ImportInfo - aFamInd = "<<aFamInd<<"; aNbAttrib = "<<aNbAttrib<<"; aNbGroup = "<<aNbGroup);
+ valarray<char> aGroupNames('\0',aNbGroup*MED_TAILLE_LNOM+1);
+ char aFamilyName[MED_TAILLE_NOM+1] = "";
+ med_int aFamilyNum;
+ ret = MEDfamInfo(fid,aMeshName,aFamInd,aFamilyName,&aFamilyNum,
+ &anAttId[0],&anAttVal[0],&anAttDesc[0],&aNbAttrib,
+ &aGroupNames[0],&aNbGroup);
+ if(ret < 0) throw std::runtime_error("ImportInfo >> MEDfamInfo");
+ if(0 && MYDEBUG)
+ MESSAGE("ImportInfo - aFamilyNum = "<<aFamilyNum<<"; aNbGroup = "<<aNbGroup);
+ if(aFamily2EntityMap.find(aFamilyNum) == aFamily2EntityMap.end()) {
+ if(MYDEBUG) MESSAGE("ImportInfo - a Family with name '"<<aFamilyName<<"' are empty !!!");
+ continue;
+ }
+ VISU::TEntity anEntity = aFamily2EntityMap[aFamilyNum];
+ VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity];
+ VISU::TFamily& aFamily = aMeshOnEntity.myFamilyMap[aFamilyName];
+ aFamily.myName = aFamilyName;
+ aFamily.myEntity = anEntity;
+ aFamily.myId = aFamilyNum;
+ aFamily.myNbCells = aFamilyNbCellsCounterMap[aFamilyNum];
+ aFamily.myCellsSize = aFamilyCellsSizeCounterMap[aFamilyNum];
+ if(MYDEBUG)
+ MESSAGE("ImportInfo - aFamily.myEntity = "<<anEntity<<
+ "; myName = '"<<aFamilyName<<
+ "'; myId = "<<aFamilyNum<<
+ "; myNbCells = "<<aFamily.myNbCells<<
+ "; myCellsSize = "<<aFamily.myCellsSize);
+ VISU::TBindGroups& aBindGroups = aFamily.myGroups;
+ for(int iGroup = 0, iPos = 0; iGroup < aNbGroup; iGroup++, iPos += MED_TAILLE_LNOM){
+ char aGroupName[MED_TAILLE_LNOM+1];
+ strncpy(aGroupName,&aGroupNames[iPos],MED_TAILLE_LNOM);
+ aGroupName[MED_TAILLE_LNOM] = '\0';
+ if(MYDEBUG) MESSAGE("ImportInfo - aGroupName["<<iGroup<<"] = '"<<aGroupName<<"'");
+ aBindGroups.insert(aGroupName);
+ }
+ }
+ //Calculation of TMesh.TGroupMap
+ const VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh.myMeshOnEntityMap;
+ if(aMeshOnEntityMap.empty()) continue;
+ VISU::TGroupMap& aGroupMap = aMesh.myGroupMap;
+ VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter = aMeshOnEntityMap.begin();
+ for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){
+ const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second;
+ const VISU::TFamilyMap& aFamilyMap = aMeshOnEntity.myFamilyMap;
+ if(aFamilyMap.empty()) continue;
+ VISU::TFamilyMap::const_iterator aFamilyMapIter = aFamilyMap.begin();
+ for(; aFamilyMapIter != aFamilyMap.end(); aFamilyMapIter++){
+ const VISU::TFamily& aFamily = aFamilyMapIter->second;
+ const VISU::TBindGroups& aBindGroups = aFamily.myGroups;
+ if(aBindGroups.empty()) continue;
+ VISU::TBindGroups::const_iterator aBindGroupsIter = aBindGroups.begin();
+ for(; aBindGroupsIter != aBindGroups.end(); aBindGroupsIter++){
+ const string& aGroupName = *aBindGroupsIter;
+ VISU::TGroup& aGroup = aGroupMap[aGroupName];
+ aGroup.myName = aGroupName;
+ aGroup.myMeshName = aMesh.myName;
+ VISU::TFamilyAndEntity aFamilyAndEntity(aFamily.myName,aFamily.myEntity);
+ aGroup.myFamilyAndEntitySet.insert(aFamilyAndEntity);
+ aGroup.myNbCells += aFamily.myNbCells;
+ aGroup.myCellsSize += aFamily.myCellsSize;
+ }
+ }
+ }
+ //Displaing information for the TMesh.TGroupMap
+ VISU::TGroupMap::const_iterator aGroupMapIter = aGroupMap.begin();
+ if(MYDEBUG) MESSAGE("ImportInfo - aGroupMap.size() = "<<aGroupMap.size());
+ for(; aGroupMapIter != aGroupMap.end(); aGroupMapIter++){
+ const VISU::TGroup& aCGroup = aGroupMapIter->second;
+ const string& aGroupName = aGroupMapIter->first;
+ if(MYDEBUG) MESSAGE("ImportInfo - aGroupName = '"<<aGroupName<<
+ "'; myNbCells = "<<aCGroup.myNbCells<<
+ "; myCellsSize = "<<aCGroup.myCellsSize);
+ const VISU::TGroup& aGroup = aGroupMapIter->second;
+ const VISU::TFamilyAndEntitySet& aFamilyAndEntitySet = aGroup.myFamilyAndEntitySet;
+ VISU::TFamilyAndEntitySet::const_iterator aFamilyAndEntitySetIter = aFamilyAndEntitySet.begin();
+ for(; aFamilyAndEntitySetIter != aFamilyAndEntitySet.end(); aFamilyAndEntitySetIter++){
+ const string& aFamilyName = aFamilyAndEntitySetIter->first;
+ if(MYDEBUG) MESSAGE("ImportInfo - \t aFamilyName = '"<<aFamilyName<<"'");
+ }
+ }
+ }
+ //Reading information about fields
+ med_int iFieldEnd = MEDnChamp(fid,0);
+ if (iFieldEnd < 0) throw std::runtime_error("ImportChamps >> MEDnChamp(fid,0)");
+ if(MYDEBUG) MESSAGE("ImportInfo - iFieldEnd = "<<iFieldEnd);
+ for(med_int iField = 1; iField <= iFieldEnd; iField++){
+ med_int ncomp = MEDnChamp(fid,iField);
+ if(ncomp < 0) throw std::runtime_error("ImportChamps >> MEDnChamp(fid,i)");
+ valarray<char> aCompNames('\0',ncomp*MED_TAILLE_PNOM + 1);
+ valarray<char> aUnitNames('\0',ncomp*MED_TAILLE_PNOM + 1);
+ char name_field[MED_TAILLE_NOM + 1] = "";
+ med_type_champ type_field;
+ if(MEDchampInfo(fid,iField,name_field,&type_field,&aCompNames[0],&aUnitNames[0],ncomp) < 0)
+ throw std::runtime_error(string("ImportInfo >> MEDchampInfo(...)"));
+ //if(type_field != MED_REEL64) continue; //There is some problem in reading INTXX values
+ TVisu2MedEntity::const_iterator aVisu2MedEntityIter = aVisu2MedEntity.begin();
+ for(; aVisu2MedEntityIter != aVisu2MedEntity.end(); aVisu2MedEntityIter++) {
+ VISU::TEntity anEntity = aVisu2MedEntityIter->first;
+ int iGeomElemEnd;
+ med_geometrie_element* aGeomElemVector;
+ GetEntity2Geom(anEntity,aGeomElemVector,&iGeomElemEnd);
+ med_entite_maillage& aMedEntity = aVisu2MedEntity[anEntity];
+ for (int iGeomElem = 0; iGeomElem < iGeomElemEnd; iGeomElem++) {
+ med_geometrie_element& aGeom = aGeomElemVector[iGeomElem];
+ med_int iTimeStampEnd = MEDnPasdetemps(fid,name_field,aMedEntity,aGeom);
+ if(iTimeStampEnd < 0) throw std::runtime_error("ImportInfo >> MEDnPasdetemps(...)");
+ if(iTimeStampEnd > 0) {
+ for(med_int iTimeStamp = 1; iTimeStamp <= iTimeStampEnd; iTimeStamp++) {
+ char aMeshName[MED_TAILLE_NOM+1] = "";
+ med_int ngauss = 0, numdt = 0, numo = 0;
+ char dt_unit[MED_TAILLE_PNOM+1] = "";
+ med_float dt = 0;
+ ret = MEDpasdetempsInfo(fid,name_field,aMedEntity,aGeom,iTimeStamp,
+ aMeshName,&ngauss,&numdt,dt_unit,&dt,&numo);
+ if(ret < 0) throw std::runtime_error("ImportInfo >> MEDpasdetempsInfo(...) < 0");
+ if(myMeshMap.find(aMeshName) == myMeshMap.end())
+ throw std::runtime_error("ImportInfo >> MEDpasdetempsInfo(...)");
+ VISU::TMesh &aMesh = myMeshMap[aMeshName];
+ VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity];
+ VISU::TFieldMap::iterator aFieldMapIter = aMeshOnEntity.myFieldMap.find(name_field);
+ //if(MYDEBUG && aFieldMapIter == aMeshOnEntity.myFieldMap.end()){
+ VISU::TField& aField = aMeshOnEntity.myFieldMap[name_field];
+ if(iTimeStamp == 1){
+ aField.myId = iField;
+ aField.myName = name_field;
+ aField.myEntity = anEntity;
+ aField.myMeshName = aMeshName;
+ aField.myNbComp = ncomp;
+ aField.myNbValField = iTimeStampEnd;
+ aField.myDataSize = aMeshOnEntity.myNbCells * ncomp;
+ aField.myCompNames.resize(ncomp);
+ aField.myUnitNames.resize(ncomp);
+ if(MYDEBUG)
+ MESSAGE("ImportInfo - aField.myName = '"<<name_field<<
+ "'; myMeshName = '"<<aMeshName<<
+ "'; myEntity = "<<anEntity<<
+ "; myNbComp = "<<ncomp<<
+ "; myDataSize = "<<aField.myDataSize);
+ for(int iComp = 0, iPos = 0; iComp < ncomp; iComp++, iPos += MED_TAILLE_PNOM){
+ char aCompName[MED_TAILLE_PNOM+1], aUnitName[MED_TAILLE_PNOM+1];
+ strncpy(aCompName,&aCompNames[iPos],MED_TAILLE_PNOM);
+ aCompName[MED_TAILLE_PNOM] = '\0';
+ aField.myCompNames[iComp] = aCompName;
+ strncpy(aUnitName,&aUnitNames[iPos],MED_TAILLE_PNOM);
+ aUnitName[MED_TAILLE_PNOM] = '\0';
+ aField.myUnitNames[iComp] = aUnitName;
+ if(MYDEBUG)
+ MESSAGE("ImportInfo - aCompName = '"<<aCompName<<"'; aUnitName = '"<<aUnitName<<"'");
+ }
+
+ }
+ VISU::TField::TValForTime& aValForTime = aField.myValField[iTimeStamp];
+ aValForTime.myId = iTimeStamp;
+ aValForTime.myFieldName = aField.myName;
+ aValForTime.myEntity = aField.myEntity;
+ aValForTime.myMeshName = aField.myMeshName;
+ aValForTime.myNbComp = aField.myNbComp;
+ aValForTime.myTime = VISU::TField::TTime(dt,dt_unit);
+ if(MYDEBUG && iGeomElem == 0)
+ MESSAGE("ImportInfo -\t aValForTime.myTime = "<<dt<<", "<<dt_unit);
+ }
+ }
+ }
+ }
+ }
+ return this;
+}
+
+int VISU_MedConvertor::LoadMeshOnEntity(VISU::TMeshOnEntity& theMeshOnEntity,
+ const string& theFamilyName)
+ throw (std::runtime_error&)
+{
+ //Open the med file (it will be closed by call of destructor)
+ MedFile aMedFile(myFileInfo.absFilePath());
+ med_idt fid = aMedFile.GetFid();
+ //Main part of code
+ const string& aMeshName = theMeshOnEntity.myMeshName;
+ const VISU::TEntity& anEntity = theMeshOnEntity.myEntity;
+ VISU::TMesh& aMesh = myMeshMap[aMeshName];
+ int isPointsUpdated;
+ if(anEntity == VISU::NODE_ENTITY)
+ isPointsUpdated = LoadPoints(fid,aMesh,theFamilyName);
+ else
+ isPointsUpdated = LoadPoints(fid,aMesh);
+ int isCellsOnEntityUpdated = LoadCellsOnEntity(fid,theMeshOnEntity,theFamilyName);
+
+ return (isPointsUpdated || isCellsOnEntityUpdated);
+}
+
+int VISU_MedConvertor::LoadMeshOnGroup(VISU::TMesh& theMesh,
+ const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet)
+ throw (std::runtime_error&)
+{
+ //Open the med file (it will be closed by call of destructor)
+ MedFile aMedFile(myFileInfo.absFilePath());
+ med_idt fid = aMedFile.GetFid();
+ //Main part of code
+ int isPointsUpdated = 0;
+ int isCellsOnEntityUpdated = 0;
+ VISU::TFamilyAndEntitySet::const_iterator aFamilyAndEntitySetIter = theFamilyAndEntitySet.begin();
+ for(; aFamilyAndEntitySetIter != theFamilyAndEntitySet.end(); aFamilyAndEntitySetIter++){
+ const string& aFamilyName = aFamilyAndEntitySetIter->first;
+ const VISU::TEntity& anEntity = aFamilyAndEntitySetIter->second;
+ VISU::TMeshOnEntity& aMeshOnEntity = theMesh.myMeshOnEntityMap[anEntity];
+ if(anEntity == VISU::NODE_ENTITY){
+ isPointsUpdated += LoadPoints(fid,theMesh,aFamilyName);
+ isCellsOnEntityUpdated += LoadCellsOnEntity(fid,aMeshOnEntity);
+ }else{
+ isPointsUpdated += LoadPoints(fid,theMesh);
+ isCellsOnEntityUpdated += LoadCellsOnEntity(fid,aMeshOnEntity,aFamilyName);
+ }
+ }
+
+ return (isPointsUpdated || isCellsOnEntityUpdated);
+}
+
+int VISU_MedConvertor::LoadFieldOnMesh(VISU::TMesh& theMesh,
+ VISU::TMeshOnEntity& theMeshOnEntity,
+ VISU::TField& theField,
+ VISU::TField::TValForTime& theValForTime)
+ throw (std::runtime_error&)
+{
+ //Open the med file (it will be closed by call of destructor)
+ MedFile aMedFile(myFileInfo.absFilePath());
+ med_idt fid = aMedFile.GetFid();
+ //Main part of code
+ int isPointsUpdated = LoadPoints(fid,theMesh);
+ int isCellsOnEntityUpdated = LoadCellsOnEntity(fid,theMeshOnEntity);
+ int isFieldUpdated = LoadField(fid,theMeshOnEntity,theField,theValForTime);
+
+ return (isPointsUpdated || isCellsOnEntityUpdated || isFieldUpdated);
+}
+
+int VISU_MedConvertor::LoadPoints(const med_idt& fid, VISU::TMesh& theMesh, const string& theFamilyName)
+ throw (std::runtime_error&)
+{
+ try{
+ //Check on existing family
+ VISU::TMeshOnEntity& aMeshOnEntity = theMesh.myMeshOnEntityMap[VISU::NODE_ENTITY];
+ aMeshOnEntity.myEntity = VISU::NODE_ENTITY;
+ aMeshOnEntity.myMeshName = theMesh.myName;
+ VISU::TFamily* pFamily = VISU::GetFamily(aMeshOnEntity,theFamilyName);
+ bool isFamilyPresent = (pFamily != NULL);
+ VISU::TFamily& aFamily = *pFamily;
+ //Check on loading already done
+ bool isPointsLoaded = !theMesh.myPointsCoord.empty();
+ if(isPointsLoaded)
+ if(!isFamilyPresent) return 0;
+ else if(!aFamily.mySubMesh.empty()) return 0;
+ if(MYDEBUG)
+ MESSAGE("LoadPoints - isPointsLoaded = "<<isPointsLoaded<<"; theFamilyName = '"<<theFamilyName<<"'");
+ //Main part of code
+ char aMeshName[MED_TAILLE_NOM+1] = "";
+ strcpy(aMeshName,theMesh.myName.c_str());
+ med_geometrie_element typgeo = (med_geometrie_element)0; //MED_POINT1
+ med_connectivite typco = (med_connectivite)0; //MED_NOD
+ med_int iNumElemEnd = MEDnEntMaa(fid,aMeshName,MED_COOR,MED_NOEUD,typgeo,typco);
+ if (iNumElemEnd <= 0) throw std::runtime_error("LoadPoints >> MEDnEntMaa(...)");
+ if(MYDEBUG) MESSAGE("LoadPoints - iNumElemEnd = "<<iNumElemEnd);
+ med_repere rep;
+ med_booleen iname_elem, inum_elem;
+ valarray<med_int> num_elem(iNumElemEnd), num_fam_elem(iNumElemEnd);
+ valarray<char> name_elem('\0',iNumElemEnd*MED_TAILLE_PNOM+1);
+ valarray<char> name_coord('\0',theMesh.myDim*MED_TAILLE_PNOM+1);
+ valarray<char> unit_coord('\0',theMesh.myDim*MED_TAILLE_PNOM+1);
+ valarray<med_float> coord(theMesh.myDim*iNumElemEnd);
+ ret = MEDnoeudsLire(fid,aMeshName,theMesh.myDim,&coord[0],MED_FULL_INTERLACE,&rep,
+ &name_coord[0],&unit_coord[0],&name_elem[0],&iname_elem,
+ &num_elem[0],&inum_elem,&num_fam_elem[0],iNumElemEnd);
+ if(ret < 0) throw std::runtime_error("LoadPoints >> MEDnoeudsLire(...)");
+ if(!isPointsLoaded){
+ VISU::TMesh::TPointsCoord& aPointsCoord = theMesh.myPointsCoord;
+ aPointsCoord.resize(iNumElemEnd*theMesh.myDim);
+ if(MYDEBUG) MESSAGE("LoadPoints - Filling coordinates of the mesh - inum_elem = "<<inum_elem);
+ inum_elem = MED_FAUX; // It is workaround
+ if(inum_elem == MED_FAUX)
+ for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++)
+ for(int iDim = 0, iNumElem2Dim = iNumElem*theMesh.myDim; iDim < theMesh.myDim; iDim++, iNumElem2Dim++)
+ aPointsCoord[iNumElem2Dim] = coord[iNumElem2Dim];
+ else
+ for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++)
+ for(int iDim = 0, iNumElem2Dim = iNumElem*theMesh.myDim; iDim < theMesh.myDim; iDim++, iNumElem2Dim++)
+ aPointsCoord[num_elem[iNumElem2Dim]] = coord[iNumElem2Dim];
+ if(MYDEBUG) MESSAGE("LoadPoints - Filling aMeshOnEntity with type NODE_ENTITY");
+ VISU::TMeshOnEntity::TConnForCellType& aConnForCellType = aMeshOnEntity.myCellsConn[VTK_VERTEX];
+ aConnForCellType.resize(iNumElemEnd);
+ for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++)
+ aConnForCellType[iNumElem] = VISU::TMeshOnEntity::TConnect(1,iNumElem);
+ }
+ if(isFamilyPresent && iNumElemEnd > 0){
+ if(MYDEBUG) MESSAGE("LoadPoints - Filling aFamily SubMesh");
+ VISU::TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aFamily.mySubMesh[VTK_VERTEX];
+ for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++)
+ if(num_fam_elem[iNumElem] == aFamily.myId)
+ aSubMeshOnCellType.insert(iNumElem);
+ }
+ return 1;
+ }catch(std::runtime_error& exc){
+ theMesh.myPointsCoord.clear();
+ throw std::runtime_error(exc.what());
+ }catch(...){
+ theMesh.myPointsCoord.clear();
+ throw std::runtime_error("Unknown exception !!!");
+ }
+ return 0;
+}
+
+int VISU_MedConvertor::LoadCellsOnEntity(const med_idt& fid, VISU::TMeshOnEntity& theMeshOnEntity,
+ const string& theFamilyName)
+ throw (std::runtime_error&)
+{
+ try{
+ //Check on existing family
+ VISU::TFamily* pFamily = VISU::GetFamily(theMeshOnEntity,theFamilyName);
+ bool isFamilyPresent = (pFamily != NULL);
+ VISU::TFamily& aFamily = *pFamily;
+ //Check on loading already done
+ bool isCellsLoaded = !theMeshOnEntity.myCellsConn.empty();
+ if(isCellsLoaded)
+ if(!isFamilyPresent) return 0;
+ else if(!aFamily.mySubMesh.empty()) return 0;
+ if(MYDEBUG) {
+ MESSAGE("LoadCellsOnEntity - theFamilyName = '"<<theFamilyName<<"'");
+ MESSAGE("LoadCellsOnEntity - isCellsLoaded = "<<isCellsLoaded<<"; isFamilyPresent = "<<isFamilyPresent);
+ }
+ //Main part of code
+ int iGeomElemEnd;
+ med_geometrie_element* aGeomElemVector;
+ const VISU::TEntity& anEntity = theMeshOnEntity.myEntity;
+ GetEntity2Geom(anEntity,aGeomElemVector,&iGeomElemEnd);
+ const med_entite_maillage& aMedEntity = aVisu2MedEntity[anEntity];
+ char aMeshName[MED_TAILLE_NOM+1] = "";
+ strcpy(aMeshName,theMeshOnEntity.myMeshName.c_str());
+ if(MYDEBUG)
+ MESSAGE("LoadCellsOnEntity - theMeshOnEntity.myEntity = "<<theMeshOnEntity.myEntity<<
+ "; iGeomElemEnd = "<<iGeomElemEnd<<"; theFamilyName = '"<<theFamilyName<<"'");
+ VISU::TMesh &aMesh = myMeshMap[theMeshOnEntity.myMeshName];
+ int aNbPoints = aMesh.myPointsCoord.size()/aMesh.myDim;
+ for (int iGeomElem = 0; iGeomElem < iGeomElemEnd; iGeomElem++) {
+ int medId = getIdMedType(aGeomElemVector[iGeomElem]);
+ int nbMedNodes = med2vtk[medId].medNbNodes;
+ int nbVtkNodes = med2vtk[medId].vtkNbNodes;
+ int aVtkType = med2vtk[medId].vtkType;
+ med_geometrie_element aMedType = med2vtk[medId].medType;
+ med_int iNumElemEnd = MEDnEntMaa(fid,aMeshName,MED_CONN,aMedEntity,aMedType,MED_NOD);
+ if (iNumElemEnd > 0) {
+ med_booleen iname_elem, inum_elem;
+ valarray<med_int> num_elem(iNumElemEnd), num_fam_elem(iNumElemEnd);
+ valarray<char> name_elem('\0',iNumElemEnd*MED_TAILLE_PNOM+1);
+ med_int aNbConnForElem = getNbMedConnect(aMedType,anEntity,aMesh.myDim);
+ if(MYDEBUG) MESSAGE("LoadCellsOnEntity - medName = "<<med2vtk[medId].medName<<
+ "; iNumElemEnd = "<<iNumElemEnd<<"; aNbConnForElem = "<<aNbConnForElem);
+ valarray<med_int> conn(aNbConnForElem*iNumElemEnd);
+ ret = MEDelementsLire(fid,aMeshName,aMesh.myDim,&conn[0],MED_FULL_INTERLACE,
+ &name_elem[0],&iname_elem,&num_elem[0],&inum_elem,
+ &num_fam_elem[0],iNumElemEnd,aMedEntity,aMedType,MED_NOD);
+ if (ret < 0) throw std::runtime_error("LoadCellsOnEntity >> MEDelementsLire(...)");
+ if(!isCellsLoaded){
+ VISU::TMeshOnEntity::TConnForCellType& aConnForCellType = theMeshOnEntity.myCellsConn[aVtkType];
+ aConnForCellType.resize(iNumElemEnd);
+ valarray<med_int> aConnect(nbMedNodes);
+ for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++) {
+ VISU::TMeshOnEntity::TConnect& anArray = aConnForCellType[iNumElem];
+ anArray.resize(nbVtkNodes);
+ for (int k = 0, kj = iNumElem*aNbConnForElem; k < nbMedNodes; k++) {
+ aConnect[k] = conn[kj+k] - 1;
+ }
+ switch(aMedType){
+ case MED_TETRA4 :
+ case MED_TETRA10 :
+ anArray[0] = aConnect[0];
+ anArray[1] = aConnect[1];
+ anArray[2] = aConnect[3];
+ anArray[3] = aConnect[2];
+ break;
+ case MED_PYRA5 :
+ case MED_PYRA13 :
+ anArray[0] = aConnect[0];
+ anArray[1] = aConnect[3];
+ anArray[2] = aConnect[2];
+ anArray[3] = aConnect[1];
+ anArray[4] = aConnect[4];
+ break;
+ default:
+ for (int k = 0; k < nbVtkNodes; k++)
+ anArray[k] = aConnect[k];
+ }
+ for (int k = 0; k < nbVtkNodes; k++)
+ if(anArray[k] < 0 || aNbPoints <= anArray[k]){
+ static QString aString;
+ aString.sprintf("ImportCells >> aNbPoints(%d) <= anArray[%d][%d](%d) < 0",aNbPoints,iNumElem,k,anArray[k]);
+ throw std::runtime_error(aString.latin1());
+ }
+ }
+ }
+ //Filling aFamily SubMesh
+ if(isFamilyPresent){
+ VISU::TFamily::TSubMeshOnCellType& aSubMeshOnCellType = aFamily.mySubMesh[aVtkType];
+ for (int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++)
+ if(num_fam_elem[iNumElem] == aFamily.myId)
+ aSubMeshOnCellType.insert(iNumElem);
+ }
+ }
+ }
+ return 1;
+ }catch(std::runtime_error& exc){
+ theMeshOnEntity.myCellsConn.clear();
+ throw std::runtime_error(exc.what());
+ }catch(...){
+ theMeshOnEntity.myCellsConn.clear();
+ throw std::runtime_error("Unknown exception !!!");
+ }
+ return 0;
+}
+
+int VISU_MedConvertor::LoadField(const med_idt& fid, const VISU::TMeshOnEntity& theMeshOnEntity,
+ const VISU::TField& theField, VISU::TField::TValForTime& theValForTime)
+ throw (std::runtime_error&)
+{
+ //Check on loading already done
+ if(!theValForTime.myValForCells.empty()) return 0;
+ //Main part of code
+ med_int ncomp = MEDnChamp(fid,theField.myId);
+ if(ncomp < 0) throw std::runtime_error("LoadField >> MEDnChamp(fid,i)");
+ valarray<char> comp('\0',ncomp*MED_TAILLE_PNOM + 1);
+ valarray<char> unit('\0',ncomp*MED_TAILLE_PNOM + 1);
+ char aFieldName[MED_TAILLE_NOM + 1] = "";
+ med_type_champ type_field;
+ if(MEDchampInfo(fid,theField.myId,aFieldName,&type_field,&comp[0],&unit[0],ncomp) < 0)
+ throw std::runtime_error(string("LoadField >> MEDchampInfo(...)"));
+ int iGeomElemEnd;
+ med_geometrie_element* aGeomElemVector;
+ const VISU::TEntity& anEntity = theField.myEntity;
+ GetEntity2Geom(anEntity,aGeomElemVector,&iGeomElemEnd);
+ med_entite_maillage& aMedEntity = aVisu2MedEntity[anEntity];
+ if(MYDEBUG) {
+ MESSAGE("LoadField - aFieldName = '"<<aFieldName<<"'; anEntity = "<<anEntity<<"; iGeomElemEnd = "<<iGeomElemEnd);
+ MESSAGE("LoadField - ncomp = "<<ncomp<<"; type_field = "<<type_field<<"; myId = "<<theValForTime.myId);
+ }
+ for (int iGeomElem = 0; iGeomElem < iGeomElemEnd; iGeomElem++) {
+ med_geometrie_element& aGeom = aGeomElemVector[iGeomElem];
+ med_int iTimeStampEnd = MEDnPasdetemps(fid,aFieldName,aMedEntity,aGeom);
+ if(iTimeStampEnd > 0) {
+ char aMeshName[MED_TAILLE_NOM+1] = "";
+ med_int ngauss = 0, numdt = 0, numo = 0;
+ char dt_unit[MED_TAILLE_PNOM+1] = "";
+ med_float dt = 0;
+ ret = MEDpasdetempsInfo(fid,aFieldName,aMedEntity,aGeom,theValForTime.myId,
+ aMeshName,&ngauss,&numdt,dt_unit,&dt,&numo);
+ if(ret < 0) throw std::runtime_error("LoadField >> MEDpasdetempsInfo(...)");
+ med_int nval = MEDnVal(fid,aFieldName,aMedEntity,aGeom,numdt,numo);
+ if (nval <= 0) throw std::runtime_error("LoadField >> MEDnVal(...) - nval <= 0");
+ else{
+ //Checking for accordance between the mesh and the field on number of geomterical elements
+ int aVtkType = med2vtkCellType(aGeom);
+ const VISU::TMeshOnEntity::TCellsConn& aCellsConn = theMeshOnEntity.myCellsConn;
+ VISU::TMeshOnEntity::TCellsConn::const_iterator aCellsConnIter = aCellsConn.find(aVtkType);
+ if(aCellsConnIter == aCellsConn.end()) throw std::runtime_error("LoadField - There is no the geom. elem. on the mesh !!!");
+ const VISU::TMeshOnEntity::TConnForCellType aConnForCellType = aCellsConnIter->second;
+ if(aConnForCellType.size() != nval) throw std::runtime_error("LoadField - Size of values and size of mesh not equal !!!");
+ if(MYDEBUG) MESSAGE("LoadField - aGeom = "<<aGeom<<"; nval = "<<nval<<"; iTimeStampEnd = "<<iTimeStampEnd);
+ VISU::TField::TValForCellsWithType &anArray = theValForTime.myValForCells[aVtkType];
+ int jEnd = theField.myNbComp*nval;
+ anArray.resize(jEnd);
+ char pflname[MED_TAILLE_NOM + 1] = "";
+ switch(type_field){
+ case MED_REEL64 : {
+ valarray<med_float> valr(jEnd);
+ ret = MEDchampLire(fid,aMeshName,aFieldName,(unsigned char*)&valr[0],MED_FULL_INTERLACE,MED_ALL,
+ pflname,aMedEntity,aGeom,numdt,numo);
+ for (med_int j = 0; j < jEnd; j++) anArray[j] = valr[j];
+ break;
+ }
+ //case MED_INT64 : //valarray<long long> valr(jEnd);
+ case MED_INT32 : //valarray<long int> valr(jEnd);
+ case MED_INT : {
+ valarray<med_int> valr(jEnd);
+ ret = MEDchampLire(fid,aMeshName,aFieldName,(unsigned char*)&valr[0],MED_FULL_INTERLACE,MED_ALL,
+ pflname,aMedEntity,aGeom,numdt,numo);
+ for (med_int j = 0; j < jEnd; j++) anArray[j] = valr[j];
+ break;
+ }
+ default :
+ throw std::runtime_error("LoadField >> Value of med_type_champ for the field is wrong !!!");
+ }
+ if(ret < 0) throw std::runtime_error("ChampLire >> MEDchampLire(...)");
+ }
+ }
+ }
+ return 1;
+}
--- /dev/null
+// Copyright (C) 2003 CEA/DEN, EDF R&D
+//
+//
+//
+// File : VISU_MedConvertor.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_MedConvertor_HeaderFile
+#define VISU_MedConvertor_HeaderFile
+
+#include "VISU_Convertor_impl.hxx"
+
+extern "C"{
+#include <med.h>
+}
+
+class VISU_MedConvertor: public VISU_Convertor_impl{
+ VISU_MedConvertor();
+ VISU_MedConvertor(const VISU_MedConvertor&);
+public:
+ VISU_MedConvertor(const std::string& theFileName) throw (std::runtime_error&);
+ virtual VISU_Convertor* Build() throw (std::runtime_error&);
+protected:
+ QFileInfo myFileInfo;
+
+ virtual int LoadMeshOnEntity(VISU::TMeshOnEntity& theMeshOnEntity,
+ const std::string& theFamilyName = "")
+ throw (std::runtime_error&);
+ virtual int LoadMeshOnGroup(VISU::TMesh& theMesh,
+ const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet)
+ throw (std::runtime_error&);
+ virtual int LoadFieldOnMesh(VISU::TMesh& theMesh,
+ VISU::TMeshOnEntity& theMeshOnEntity,
+ VISU::TField& theField,
+ VISU::TField::TValForTime& theValForTime)
+ throw (std::runtime_error&);
+
+ int LoadPoints(const med_idt& fid, VISU::TMesh& theMesh,
+ const std::string& theFamilyName = "")
+ throw (std::runtime_error&);
+ int LoadCellsOnEntity(const med_idt& fid, VISU::TMeshOnEntity& theMeshOnEntity,
+ const std::string& theFamilyName = "")
+ throw (std::runtime_error&);
+ int LoadField(const med_idt& fid, const VISU::TMeshOnEntity& theMeshOnEntity,
+ const VISU::TField& theField, VISU::TField::TValForTime& theValForTime)
+ throw (std::runtime_error&);
+};
+
+#endif
@COMMENCE@
-SUBDIRS = OBJECT VISU_I VISUGUI VISU_SWIG
+SUBDIRS = CONVERTOR PIPELINE OBJECT VISU_I VISUGUI VISU_SWIG
@MODULE@
@COMMENCE@
-EXPORT_HEADERS = VISU_Actor.h VISU_LookupTable.hxx VISU_ScalarBarActor.hxx
-
+EXPORT_HEADERS = VISU_Actor.h VISU_MeshAct.h VISU_ScalarMapAct.h VISU_VectorsAct.h
# Libraries targets
LIB = libVisuObject.la
-LIB_SRC = VISU_Actor.cxx VISU_LookupTable.cxx VISU_ScalarBarActor.cxx
+LIB_SRC = VISU_Actor.cxx VISU_MeshAct.cxx VISU_ScalarMapAct.cxx VISU_VectorsAct.cxx
LIB_CLIENT_IDL =
BIN_SRC =
CPPFLAGS+= $(OCC_INCLUDES) $(VTK_INCLUDES)
-LDFLAGS+= $(OCC_LIBS) $(VTK_LIBS) -lSalomeObject
-
-%_moc.cxx: %.h
- $(MOC) $< -o $@
-
+LDFLAGS+= $(VTK_LIBS) -lSalomeObject -lVisuPipeLine
@CONCLUDE@
// Module : VISU
// $Header$
-using namespace std;
#include "VISU_Actor.h"
-#include "VISU_LookupTable.hxx"
-#include "VISU_ScalarBarActor.hxx"
+#include "VISU_PipeLine.hxx"
+#include "SALOME_PassThroughFilter.h"
// VTK Includes
-#include <vtkActor.h>
#include <vtkProperty.h>
+#include <vtkDataSetMapper.h>
#include <vtkShrinkPolyData.h>
-#include <vtkFeatureEdges.h>
#include <vtkObjectFactory.h>
-static int VISU_POINT_SIZE = 3;
+using namespace std;
//=======================================================================
-VISU_Actor* VISU_Actor::New(){
- vtkObject* ret = vtkObjectFactory::CreateInstance("VISU_Actor");
- if(ret) return (VISU_Actor*)ret;
- return new VISU_Actor;
-}
+vtkStandardNewMacro(VISU_Actor);
VISU_Actor::VISU_Actor(){
myIsShrunk = false;
myIsShrinkable = false;
myParent = this;
+ myPipeLine = NULL;
myPrs3d = NULL;
myIO = NULL;
myName = theIO->getName();
}
-void VISU_Actor::setPrs3d(VISU::Prs3d_i* thePrs3d){
+void VISU_Actor::SetPrs3d(VISU::Prs3d_i* thePrs3d){
myPrs3d = thePrs3d;
}
-void VISU_Actor::SetParent(VISU_Actor* theParent){
- myParent = theParent;
+void VISU_Actor::SetPipeLine(VISU_PipeLine* thePipeLine) throw(std::runtime_error&){
+ if (myPipeLine != thePipeLine){
+ if (myPipeLine != NULL) myPipeLine->UnRegister(this);
+ myPipeLine = thePipeLine;
+ if (myPipeLine != NULL) myPipeLine->Register(this);
+ this->Modified();
+ vtkMapper *aMapper = myPipeLine->GetMapper();
+ vtkDataSet *aDataSet = aMapper->GetInput();
+ if(!aDataSet)
+ throw std::runtime_error("VISU_Actor::SetPipeLine >> There is no input data");
+ aDataSet->Update();
+ static float eps = VTK_LARGE_FLOAT * 0.1 ;
+ if(aDataSet->GetLength() > eps)
+ throw std::runtime_error("VISU_Actor::SetPipeLine >> Diagonal of the actor is too large");
+ if(!aDataSet->GetNumberOfCells())
+ throw std::runtime_error("VISU_Actor::SetPipeLine >> There is no visible elements");
+ SetShrinkable(aDataSet->GetNumberOfCells() > 10);
+
+ vtkDataSetMapper* aNewMapper = vtkDataSetMapper::New();
+ aNewMapper->SetInput(aDataSet);
+ aMapper->ShallowCopy(aMapper);
+ SetMapper(aNewMapper);
+ aNewMapper->Delete();
+ }
}
-void VISU_Actor::SetMapper(vtkMapper* theMapper){
- SALOME_Actor::SetMapper(theMapper);
+void VISU_Actor::SetParent(VISU_Actor* theParent){
+ myParent = theParent;
}
void VISU_Actor::SetShrinkable(bool theIsShrinkable){
myIsShrinkable = theIsShrinkable;
}
-void VISU_Actor::setShrink(float theFactor){
+void VISU_Actor::SetShrink(float theFactor){
if(!myIsShrinkable || myIsShrunk) return;
vtkShrinkPolyData *aShrinkFilter = vtkShrinkPolyData::New();
aShrinkFilter->SetShrinkFactor(theFactor);
// use for post-filtering
aShrinkFilter->SetInput(myPassFilter[2]->GetPolyDataOutput());
myPassFilter[3]->SetInput(aShrinkFilter->GetOutput());
- myPassFilter[3]->Modified();
+ aShrinkFilter->Register(myPassFilter[3]);
aShrinkFilter->Delete();
myIsShrunk = true;
}
-void VISU_Actor::unShrink(){
+void VISU_Actor::UnShrink(){
if(!myIsShrunk) return;
myPassFilter[3]->SetInput(myPassFilter[2]->GetPolyDataOutput());
myPassFilter[3]->Modified();
return GetProperty()->GetLineWidth();
}
-void VISU_Actor::SetRepresentation(int theMode) {
- GetProperty()->SetRepresentation(theMode);
- if(theMode == 0)
- GetProperty()->SetPointSize(VISU_POINT_SIZE);
-}
-
-int VISU_Actor::GetRepresentation(){
- return GetProperty()->GetRepresentation();
-}
-
void VISU_Actor::ShallowCopy(vtkProp *prop){
VISU_Actor *anActor = VISU_Actor::SafeDownCast(prop);
if(anActor != NULL){
if(ishighlighted) ishighlighted=false;
}
}
-
-//=======================================================================
-
-VISUScalarMap_Actor* VISUScalarMap_Actor::New(){
- vtkObject* ret = vtkObjectFactory::CreateInstance("VISUScalarMap_Actor");
- if(ret) return (VISUScalarMap_Actor*)ret;
- return new VISUScalarMap_Actor;
-}
-
-VISUScalarMap_Actor::VISUScalarMap_Actor(){
- myScalarBar = VISU_ScalarBarActor::New();
- GetProperty()->FrontfaceCullingOff();
- GetProperty()->BackfaceCullingOff();
-}
-
-VISUScalarMap_Actor::~VISUScalarMap_Actor(){
- myScalarBar->Delete();
-}
-
-void VISUScalarMap_Actor::AddToRender(vtkRenderer* theRenderer){
- SALOME_Actor::AddToRender(theRenderer);
- if(myScalarBar)
- theRenderer->AddActor2D(myScalarBar);
-}
-
-void VISUScalarMap_Actor::RemoveFromRender(vtkRenderer* theRenderer){
- SALOME_Actor::RemoveFromRender(theRenderer);
- if(myScalarBar)
- theRenderer->RemoveActor(myScalarBar);
-}
-
-void VISUScalarMap_Actor::SetVisibility(int theMode){
- SALOME_Actor::SetVisibility(theMode);
- if(myScalarBar) myScalarBar->SetVisibility(*myBarVisibility && theMode);
-}
-
-int VISUScalarMap_Actor::GetVisibility(){
- return SALOME_Actor::GetVisibility();
-}
-
-void VISUScalarMap_Actor::SetBarVisibility(const bool* theMode){
- myBarVisibility = theMode;
- if(myScalarBar) myScalarBar->SetVisibility(*myBarVisibility);
-}
-
-//=======================================================================
-
-VISUMesh_Actor* VISUMesh_Actor::New(){
- vtkObject* ret = vtkObjectFactory::CreateInstance("VISUMesh_Actor");
- if(ret) return (VISUMesh_Actor*)ret;
- return new VISUMesh_Actor;
-}
-
-VISUMesh_Actor::VISUMesh_Actor(){
- myEdgeMapper = vtkPolyDataMapper::New();
- mySurfaceActor = VISU_Actor::New();
- mySurfaceActor->SetParent(this);
- mySurfaceActor->GetProperty()->SetPointSize(VISU_POINT_SIZE);
- mySurfaceActor->GetProperty()->FrontfaceCullingOff();
- mySurfaceActor->GetProperty()->BackfaceCullingOff();
- mySurfaceActor->SetRepresentation(2);
-
- myEdgeActor = VISU_Actor::New();
- myEdgeActor->SetParent(this);
- myEdgeActor->PickableOff();
- myEdgeActor->GetProperty()->SetPointSize(VISU_POINT_SIZE);
- myEdgeActor->GetProperty()->FrontfaceCullingOff();
- myEdgeActor->GetProperty()->BackfaceCullingOff();
- myEdgeActor->SetRepresentation(2);
-
- myRepresentation = 2; //SURFACE
- myVisibility = 1; //On
-}
-
-VISUMesh_Actor::~VISUMesh_Actor(){
- myEdgeMapper->Delete();
- mySurfaceActor->Delete();
- myEdgeActor->Delete();
-}
-
-void VISUMesh_Actor::setIO(const Handle(SALOME_InteractiveObject)& theIO){
- mySurfaceActor->setIO(theIO);
- myEdgeActor->setIO(theIO);
-}
-
-void VISUMesh_Actor::setPrs3d(VISU::Prs3d_i* thePrs3d){
- if(thePrs3d){
- VISU_Actor::setPrs3d(thePrs3d);
- mySurfaceActor->setPrs3d(thePrs3d);
- myEdgeActor->setPrs3d(thePrs3d);
- }
-}
-
-void VISUMesh_Actor::AddToRender(vtkRenderer* theRenderer){
- theRenderer->AddActor(mySurfaceActor);
- theRenderer->AddActor(myEdgeActor);
-}
-
-void VISUMesh_Actor::RemoveFromRender(vtkRenderer* theRenderer){
- theRenderer->RemoveActor(mySurfaceActor);
- theRenderer->RemoveActor(myEdgeActor);
-}
-
-void VISUMesh_Actor::SetMapper(vtkMapper* theMapper){
- VISU_Actor::SetMapper(theMapper);
- SALOME_PassThroughFilter* aPassFilter = SALOME_PassThroughFilter::New();
- aPassFilter->SetInput(theMapper->GetInput());
- vtkFeatureEdges *aFeatureEdges = vtkFeatureEdges::New();
- aFeatureEdges->SetInput(aPassFilter->GetPolyDataOutput());
- aFeatureEdges->BoundaryEdgesOn();
- aFeatureEdges->ManifoldEdgesOn();
- myEdgeMapper->SetInput(aFeatureEdges->GetOutput());
- aFeatureEdges->Delete();
- myEdgeMapper->ScalarVisibilityOff();
- myEdgeActor->SetMapper(myEdgeMapper);
- mySurfaceActor->SetMapper(theMapper);
-}
-
-void VISUMesh_Actor::SetTransform(SALOME_Transform* theTransform){
- mySurfaceActor->SetTransform(theTransform);
- myEdgeActor->SetTransform(theTransform);
-}
-
-void VISUMesh_Actor::SetShrinkable(bool theIsShrinkable){
- myIsShrinkable = theIsShrinkable;
- myEdgeActor->SetShrinkable(myIsShrinkable);
- mySurfaceActor->SetShrinkable(myIsShrinkable);
-}
-
-vtkProperty* VISUMesh_Actor::GetProperty(){
- mySurfaceActor->GetProperty();
-}
-
-void VISUMesh_Actor::SetProperty(vtkProperty* theProperty){
- mySurfaceActor->SetProperty(theProperty);
-}
-
-vtkProperty* VISUMesh_Actor::GetEdgeProperty(){
- myEdgeActor->GetProperty();
-}
-
-void VISUMesh_Actor::SetEdgeProperty(vtkProperty* theProperty){
- myEdgeActor->SetProperty(theProperty);
-}
-
-void VISUMesh_Actor::SetLineWidth(float theLineWidth){
- GetProperty()->SetLineWidth(theLineWidth);
- GetEdgeProperty()->SetLineWidth(theLineWidth);
-}
-
-float VISUMesh_Actor::GetLineWidth(){
- return GetProperty()->GetLineWidth();
-}
-
-void VISUMesh_Actor::setShrink(float theFactor){
- if(!myIsShrinkable || myIsShrunk || myRepresentation == 0) return;
- mySurfaceActor->setShrink(theFactor);
- myIsShrunk = true;
- SetRepresentation(myRepresentation);
-}
-
-void VISUMesh_Actor::unShrink(){
- if(!myIsShrunk) return;
- mySurfaceActor->unShrink();
- myIsShrunk = false;
- SetRepresentation(myRepresentation);
-}
-
-void VISUMesh_Actor::SetRepresentation(int theMode){
- if(theMode < 0 || theMode >2) return;
- myRepresentation = theMode;
- myEdgeActor->SetRepresentation(2);
- mySurfaceActor->SetRepresentation(myRepresentation);
- switch(theMode){
- case 0: //POINTS
- myEdgeActor->VisibilityOff();
- mySurfaceActor->VisibilityOn();
- break;
- case 1: //WIREFRAME
- myEdgeActor->VisibilityOff();
- mySurfaceActor->VisibilityOn();
- break;
- case 2: //SURFACE
- myEdgeActor->SetVisibility(!myIsShrunk);
- mySurfaceActor->VisibilityOn();
- break;
- }
- myRepresentation = theMode;
-}
-
-void VISUMesh_Actor::SetVisibility(int theMode){
- SetRepresentation(myRepresentation);
- myEdgeActor->SetVisibility(theMode);
- mySurfaceActor->SetVisibility(theMode);
- myVisibility = theMode;
-}
-
-//=======================================================================
-
// Module : VISU
// $Header$
-using namespace std;
-
#ifndef VISU_ACTOR_H
#define VISU_ACTOR_H
#include "SALOME_Actor.h"
+
+#include <stdexcept>
#include <string>
class vtkProp;
-class vtkPolyData;
class vtkProperty;
-class vtkPolyDataMapper;
namespace VISU {
class Prs3d_i;
}
-class VISU_ScalarBarActor;
+class VISU_PipeLine;
#ifdef _WIN_32
#define VTKOCC_EXPORT __declspec (dllexport)
virtual void setIO(const Handle(SALOME_InteractiveObject)& theIO);
- VISU::Prs3d_i* getPrs3d(){ return myPrs3d;}
- virtual void setPrs3d(VISU::Prs3d_i* thePrs3d);
+ VISU::Prs3d_i* GetPrs3d(){ return myPrs3d;}
+ virtual void SetPrs3d(VISU::Prs3d_i* thePrs3d);
+
+ virtual VISU_PipeLine* GetPipeLine() { return myPipeLine;}
+ virtual void SetPipeLine(VISU_PipeLine* thePipeLine) throw(std::runtime_error&);
VISU_Actor* GetParent(){ return myParent;}
virtual void SetParent(VISU_Actor* theParent);
void SetOpacity(float opa) {};
float GetOpacity() { return 0;};
- virtual void SetMapper(vtkMapper* theMapper);
-
virtual void SetShrinkable(bool theIsShrinkable);
virtual bool GetShrinkable() { return myIsShrinkable;}
- virtual bool isShrunk() { return myIsShrunk;}
- virtual void setShrink(float theFactor = 0.8);
- virtual void unShrink();
+ virtual bool IsShrunk() { return myIsShrunk;}
+ virtual void SetShrink(float theFactor = 0.8);
+ virtual void UnShrink();
virtual void SetVisibility(int theMode);
virtual int GetVisibility();
virtual void SetLineWidth(float theLineWidth);
virtual float GetLineWidth();
- virtual void SetRepresentation(int theMode);
- virtual int GetRepresentation();
-
bool IsHighlighting;
std::string myFieldName;
VISU_Actor* myParent;
VISU::Prs3d_i* myPrs3d;
+ VISU_PipeLine* myPipeLine;
vtkProperty* HighlightProperty;
bool myIsShrinkable;
bool myIsShrunk;
};
-//=======================================================================
-
-class VTKOCC_EXPORT VISUScalarMap_Actor : public VISU_Actor {
- public:
- vtkTypeMacro(VISUScalarMap_Actor,VISU_Actor);
- static VISUScalarMap_Actor* New();
- ~VISUScalarMap_Actor();
-
- virtual void AddToRender(vtkRenderer* theRenderer);
- virtual void RemoveFromRender(vtkRenderer* theRenderer);
-
- virtual void SetVisibility(int theMode);
- virtual int GetVisibility();
-
- virtual VISU_ScalarBarActor* GetScalarBar(){ return myScalarBar;}
-
- virtual void SetBarVisibility(const bool* theMode);
- virtual bool GetBarVisibility(){ return *myBarVisibility;}
-
- protected:
- VISUScalarMap_Actor();
- const bool* myBarVisibility;
- VISU_ScalarBarActor* myScalarBar;
-};
-
-//=======================================================================
-
-class VTKOCC_EXPORT VISUMesh_Actor : public VISU_Actor {
- public:
- vtkTypeMacro(VISUMesh_Actor,VISU_Actor);
- static VISUMesh_Actor* New();
- ~VISUMesh_Actor();
-
- virtual void setIO(const Handle(SALOME_InteractiveObject)& theIO);
- virtual void setPrs3d(VISU::Prs3d_i* thePrs3d);
-
- virtual void AddToRender(vtkRenderer* theRenderer);
- virtual void RemoveFromRender(vtkRenderer* theRenderer);
-
- virtual void SetMapper(vtkMapper* theMapper);
- virtual void SetTransform(SALOME_Transform* theTransform);
-
- virtual vtkProperty* GetProperty();
- virtual void SetProperty(vtkProperty* theProperty);
-
- virtual vtkProperty* GetEdgeProperty();
- virtual void SetEdgeProperty(vtkProperty* theProperty);
-
- virtual void SetLineWidth(float theLineWidth);
- virtual float GetLineWidth();
-
- virtual void SetRepresentation(int theMode);
- virtual int GetRepresentation() { return myRepresentation;};
-
- virtual void SetVisibility(int theMode);
- virtual int GetVisibility() { return myVisibility;}
-
- virtual void SetShrinkable(bool theIsShrinkable);
-
- virtual void setShrink(float theFactor = 0.8);
- virtual void unShrink();
-
- protected:
- VISUMesh_Actor();
- int myRepresentation, myVisibility;
- vtkPolyDataMapper* myEdgeMapper;
- VISU_Actor *mySurfaceActor, *myEdgeActor;
-};
-
-//=======================================================================
-
#endif //VISU_ACTOR_H
-
-
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : VISU_MeshAct.cxx
+// Author : Laurent CORNABE with the help of Nicolas REJNERI
+// Module : VISU
+// $Header$
+
+#include "VISU_MeshAct.h"
+#include "SALOME_PassThroughFilter.h"
+
+#include <vtkFeatureEdges.h>
+#include <vtkDataSetMapper.h>
+#include <vtkDataSet.h>
+
+vtkStandardNewMacro(VISU_MeshAct);
+
+VISU_MeshAct::VISU_MeshAct(){
+ mySurfaceActor = VISU_Actor::New();
+ mySurfaceActor->SetParent(this);
+ mySurfaceActor->GetProperty()->FrontfaceCullingOff();
+ mySurfaceActor->GetProperty()->BackfaceCullingOff();
+ mySurfaceActor->SetRepresentation(2); //SURFACE
+
+ myEdgeActor = VISU_Actor::New();
+ myEdgeActor->SetParent(this);
+ myEdgeActor->PickableOff();
+ myEdgeActor->GetProperty()->FrontfaceCullingOff();
+ myEdgeActor->GetProperty()->BackfaceCullingOff();
+ myEdgeActor->SetRepresentation(1); //WIREFRAME
+
+ myNodeActor = VISU_Actor::New();
+ myNodeActor->SetParent(this);
+ myNodeActor->PickableOff();
+ myNodeActor->GetProperty()->SetPointSize(SALOME_POINT_SIZE);
+ myNodeActor->GetProperty()->FrontfaceCullingOff();
+ myNodeActor->GetProperty()->BackfaceCullingOff();
+ myNodeActor->SetRepresentation(0); //POINT
+
+ SetRepresentation(2); //SURFACE
+}
+
+VISU_MeshAct::~VISU_MeshAct(){
+ mySurfaceActor->Delete();
+ myEdgeActor->Delete();
+ myNodeActor->Delete();
+}
+
+void VISU_MeshAct::setIO(const Handle(SALOME_InteractiveObject)& theIO){
+ mySurfaceActor->setIO(theIO);
+ myEdgeActor->setIO(theIO);
+ myNodeActor->setIO(theIO);
+}
+
+void VISU_MeshAct::SetPrs3d(VISU::Prs3d_i* thePrs3d){
+ if(thePrs3d){
+ VISU_Actor::SetPrs3d(thePrs3d);
+ mySurfaceActor->SetPrs3d(thePrs3d);
+ myEdgeActor->SetPrs3d(thePrs3d);
+ myNodeActor->SetPrs3d(thePrs3d);
+ }
+}
+
+void VISU_MeshAct::AddToRender(vtkRenderer* theRenderer){
+ theRenderer->AddActor(mySurfaceActor);
+ theRenderer->AddActor(myEdgeActor);
+ theRenderer->AddActor(myNodeActor);
+}
+
+void VISU_MeshAct::RemoveFromRender(vtkRenderer* theRenderer){
+ theRenderer->RemoveActor(mySurfaceActor);
+ theRenderer->RemoveActor(myEdgeActor);
+ theRenderer->RemoveActor(myNodeActor);
+}
+
+void VISU_MeshAct::SetPipeLine(VISU_PipeLine* thePipeLine) throw(std::runtime_error&){
+ VISU_Actor::SetPipeLine(thePipeLine);
+ mySurfaceActor->SetPipeLine(thePipeLine);
+ myEdgeActor->SetPipeLine(thePipeLine);
+ myNodeActor->SetPipeLine(thePipeLine);
+}
+
+void VISU_MeshAct::SetTransform(SALOME_Transform* theTransform){
+ mySurfaceActor->SetTransform(theTransform);
+ myEdgeActor->SetTransform(theTransform);
+ myNodeActor->SetTransform(theTransform);
+}
+
+void VISU_MeshAct::SetShrinkable(bool theIsShrinkable){
+ VISU_Actor::SetShrinkable(theIsShrinkable);
+ mySurfaceActor->SetShrinkable(theIsShrinkable);
+ myEdgeActor->SetShrinkable(theIsShrinkable);
+ myNodeActor->SetShrinkable(theIsShrinkable);
+}
+
+vtkProperty* VISU_MeshAct::GetProperty(){
+ mySurfaceActor->GetProperty();
+}
+
+void VISU_MeshAct::SetProperty(vtkProperty* theProperty){
+ mySurfaceActor->SetProperty(theProperty);
+}
+
+vtkProperty* VISU_MeshAct::GetEdgeProperty(){
+ myEdgeActor->GetProperty();
+}
+
+void VISU_MeshAct::SetEdgeProperty(vtkProperty* theProperty){
+ myEdgeActor->SetProperty(theProperty);
+}
+
+vtkProperty* VISU_MeshAct::GetNodeProperty(){
+ myNodeActor->GetProperty();
+}
+
+void VISU_MeshAct::SetNodeProperty(vtkProperty* theProperty){
+ myNodeActor->SetProperty(theProperty);
+}
+
+void VISU_MeshAct::SetLineWidth(float theLineWidth){
+ GetEdgeProperty()->SetLineWidth(theLineWidth);
+}
+
+float VISU_MeshAct::GetLineWidth(){
+ return GetEdgeProperty()->GetLineWidth();
+}
+
+void VISU_MeshAct::SetShrink(float theFactor){
+ VISU_Actor::SetShrink(theFactor);
+ mySurfaceActor->SetShrink(theFactor);
+ myEdgeActor->SetShrink(theFactor);
+ SetRepresentation(GetRepresentation());
+}
+
+void VISU_MeshAct::UnShrink(){
+ VISU_Actor::UnShrink();
+ mySurfaceActor->UnShrink();
+ myEdgeActor->UnShrink();
+ SetRepresentation(GetRepresentation());
+}
+
+void VISU_MeshAct::SetRepresentation(int theMode){
+ SALOME_Actor::SetRepresentation(theMode);
+ mySurfaceActor->VisibilityOff();
+ myEdgeActor->VisibilityOff();
+ myNodeActor->VisibilityOff();
+ switch(theMode){
+ case 0: //POINTS
+ myNodeActor->VisibilityOn();
+ break;
+ case 1: //WIREFRAME
+ myEdgeActor->VisibilityOn();
+ myEdgeActor->SetRepresentation(1);
+ break;
+ case 2: //SURFACE
+ mySurfaceActor->VisibilityOn();
+ break;
+ case 3: //INSIDEFRAME
+ myEdgeActor->VisibilityOn();
+ myEdgeActor->SetRepresentation(3);
+ break;
+ case 4: //SURFACEFRAME
+ myEdgeActor->VisibilityOn();
+ myEdgeActor->SetRepresentation(1);
+ mySurfaceActor->VisibilityOn();
+ break;
+ }
+}
+
+void VISU_MeshAct::SetVisibility(int theMode){
+ VISU_Actor::SetVisibility(theMode);
+ if(GetVisibility())
+ SetRepresentation(GetRepresentation());
+ else{
+ myNodeActor->VisibilityOff();
+ myEdgeActor->VisibilityOff();
+ mySurfaceActor->VisibilityOff();
+ }
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : VISU_MeshAct.h
+// Author : Laurent CORNABE with the help of Nicolas REJNERI
+// Module : VISU
+// $Header$
+
+#ifndef VISU_MeshAct_HeaderFile
+#define VISU_MeshAct_HeaderFile
+
+#include "VISU_Actor.h"
+class vtkDataSetMapper;
+
+class VTKOCC_EXPORT VISU_MeshAct : public VISU_Actor {
+ public:
+ vtkTypeMacro(VISU_MeshAct,VISU_Actor);
+ static VISU_MeshAct* New();
+ ~VISU_MeshAct();
+
+ virtual void setIO(const Handle(SALOME_InteractiveObject)& theIO);
+ virtual void SetPrs3d(VISU::Prs3d_i* thePrs3d);
+
+ virtual void AddToRender(vtkRenderer* theRenderer);
+ virtual void RemoveFromRender(vtkRenderer* theRenderer);
+
+ virtual void SetPipeLine(VISU_PipeLine* thePipeLine) throw(std::runtime_error&);
+ virtual void SetTransform(SALOME_Transform* theTransform);
+
+ virtual vtkProperty* GetProperty();
+ virtual void SetProperty(vtkProperty* theProperty);
+
+ virtual vtkProperty* GetEdgeProperty();
+ virtual void SetEdgeProperty(vtkProperty* theProperty);
+
+ virtual vtkProperty* GetNodeProperty();
+ virtual void SetNodeProperty(vtkProperty* theProperty);
+
+ virtual void SetLineWidth(float theLineWidth);
+ virtual float GetLineWidth();
+
+ virtual void SetRepresentation(int theMode);
+
+ virtual void SetVisibility(int theMode);
+
+ virtual void SetShrinkable(bool theIsShrinkable);
+
+ virtual void SetShrink(float theFactor = 0.8);
+ virtual void UnShrink();
+
+ protected:
+ VISU_MeshAct();
+ VISU_Actor *mySurfaceActor, *myEdgeActor, *myNodeActor;
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : VISU_MeshAct.hxx
+// Author : Laurent CORNABE with the help of Nicolas REJNERI
+// Module : VISU
+// $Header$
+
+#include "VISU_ScalarMapAct.h"
+#include "VISU_LookupTable.hxx"
+#include "VISU_ScalarBarActor.hxx"
+
+vtkStandardNewMacro(VISU_ScalarMapAct);
+
+VISU_ScalarMapAct::VISU_ScalarMapAct(){
+ myScalarBar = VISU_ScalarBarActor::New();
+ GetProperty()->FrontfaceCullingOff();
+ GetProperty()->BackfaceCullingOff();
+}
+
+VISU_ScalarMapAct::~VISU_ScalarMapAct(){
+ myScalarBar->Delete();
+}
+
+void VISU_ScalarMapAct::AddToRender(vtkRenderer* theRenderer){
+ SALOME_Actor::AddToRender(theRenderer);
+ if(myScalarBar)
+ theRenderer->AddActor2D(myScalarBar);
+}
+
+void VISU_ScalarMapAct::RemoveFromRender(vtkRenderer* theRenderer){
+ SALOME_Actor::RemoveFromRender(theRenderer);
+ if(myScalarBar)
+ theRenderer->RemoveActor(myScalarBar);
+}
+
+void VISU_ScalarMapAct::SetVisibility(int theMode){
+ SALOME_Actor::SetVisibility(theMode);
+ if(myScalarBar) myScalarBar->SetVisibility(myBarVisibility && theMode);
+}
+
+int VISU_ScalarMapAct::GetVisibility(){
+ return SALOME_Actor::GetVisibility();
+}
+
+void VISU_ScalarMapAct::SetBarVisibility(bool theMode){
+ myBarVisibility = theMode;
+ if(myScalarBar) myScalarBar->SetVisibility(myBarVisibility);
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : VISU_ScalarMapAct.h
+// Author : Laurent CORNABE with help of Nicolas REJNERI
+// Module : VISU
+// $Header$
+
+#ifndef VISU_ScalarMapAct_HeaderFile
+#define VISU_ScalarMapAct_HeaderFile
+
+#include "VISU_Actor.h"
+
+class VISU_ScalarBarActor;
+
+class VTKOCC_EXPORT VISU_ScalarMapAct : public VISU_Actor {
+ public:
+ vtkTypeMacro(VISU_ScalarMapAct,VISU_Actor);
+ static VISU_ScalarMapAct* New();
+ ~VISU_ScalarMapAct();
+
+ virtual void AddToRender(vtkRenderer* theRenderer);
+ virtual void RemoveFromRender(vtkRenderer* theRenderer);
+
+ virtual void SetVisibility(int theMode);
+ virtual int GetVisibility();
+
+ virtual VISU_ScalarBarActor* GetScalarBar(){ return myScalarBar;}
+
+ virtual void SetBarVisibility(bool theMode);
+ virtual bool GetBarVisibility(){ return myBarVisibility;}
+
+ protected:
+ VISU_ScalarMapAct();
+ bool myBarVisibility;
+ VISU_ScalarBarActor* myScalarBar;
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : VISU_VectorsAct.cxx
+// Author : Laurent CORNABE with help of Nicolas REJNERI
+// Module : VISU
+// $Header$
+
+#include "VISU_VectorsAct.h"
+#include "VISU_VectorsPL.hxx"
+#include "SALOME_PassThroughFilter.h"
+
+// VTK Includes
+#include <vtkObjectFactory.h>
+
+using namespace std;
+
+//=======================================================================
+
+vtkStandardNewMacro(VISU_VectorsAct);
+
+
+VISU_VectorsAct::VISU_VectorsAct(){}
+
+
+VISU_VectorsAct::~VISU_VectorsAct(){}
+
+
+void VISU_VectorsAct::SetPipeLine(VISU_PipeLine* thePipeLine) throw(std::runtime_error&){
+ if(myPipeLine = dynamic_cast<VISU_VectorsPL*>(thePipeLine)){
+ VISU_Actor::SetPipeLine(myPipeLine);
+ myPipeLine->Delete();
+ }
+}
+
+
+void VISU_VectorsAct::SetTransform(SALOME_Transform* theTransform){
+ myPipeLine->SetTransform(theTransform);
+ Modified();
+}
+
+
+void VISU_VectorsAct::SetMapper(vtkMapper* theMapper){
+ if(theMapper){
+ myPassFilter[0]->SetInput(theMapper->GetInput());
+ myPassFilter[0]->Update();
+ myPassFilter[1]->SetInput(myPassFilter[0]->GetPolyDataOutput());
+ myPassFilter[1]->Update();
+ myPassFilter[2]->SetInput(myPassFilter[1]->GetPolyDataOutput());
+ myPassFilter[2]->Update();
+ myPassFilter[3]->SetInput(myPassFilter[2]->GetPolyDataOutput());
+ myPassFilter[3]->Update();
+ if(vtkDataSetMapper* aMapper = dynamic_cast<vtkDataSetMapper*>(theMapper))
+ aMapper->SetInput(myPassFilter[3]->GetPolyDataOutput());
+ else if(vtkPolyDataMapper* aMapper = dynamic_cast<vtkPolyDataMapper*>(theMapper))
+ aMapper->SetInput(myPassFilter[3]->GetPolyDataOutput());
+ }
+ vtkLODActor::SetMapper(theMapper);
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : VISU_VectorsAct.h
+// Author : Laurent CORNABE with help of Nicolas REJNERI
+// Module : VISU
+// $Header$
+
+#ifndef VISU_VectorsAct_HeaderFile
+#define VISU_VectorsAct_HeaderFile
+
+#include "VISU_ScalarMapAct.h"
+
+class SALOME_Transform;
+class VISU_VectorsPL;
+
+class VTKOCC_EXPORT VISU_VectorsAct : public VISU_ScalarMapAct {
+ public:
+ vtkTypeMacro(VISU_VectorsAct,VISU_ScalarMapAct);
+ static VISU_VectorsAct* New();
+ ~VISU_VectorsAct();
+
+ virtual void SetPipeLine(VISU_PipeLine* thePipeLine) throw(std::runtime_error&);
+
+ virtual void SetTransform(SALOME_Transform* theTransform);
+
+ virtual void SetMapper(vtkMapper* theMapper);
+
+ protected:
+ VISU_VectorsAct();
+
+ VISU_VectorsPL* myPipeLine;
+};
+
+#endif
--- /dev/null
+# VISU OBJECT : interactive object for VISU entities implementation
+#
+# Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# 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.
+#
+# 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+#
+#
+#
+# File : Makefile.in
+# Module : VISU
+
+top_srcdir=@top_srcdir@
+top_builddir=../../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl
+
+
+@COMMENCE@
+
+EXPORT_HEADERS = VISU_PipeLine.hxx VISU_PipeLineUtils.hxx \
+ VISU_MeshPL.hxx VISU_ScalarMapPL.hxx \
+ VISU_CutPlanesPL.hxx VISU_CutLinesPL.hxx \
+ VISU_IsoSurfacesPL.hxx VISU_DeformedShapePL.hxx \
+ VISU_VectorsPL.hxx VISU_StreamLinesPL.hxx \
+ VISU_LookupTable.hxx VISU_ScalarBarActor.hxx \
+ VISU_Extractor.hxx VISU_FieldTransform.hxx \
+ VISU_UsedPointsFilter.hxx
+
+# Libraries targets
+
+LIB = libVisuPipeLine.la
+LIB_SRC = VISU_PipeLine.cxx VISU_PipeLineUtils.cxx \
+ VISU_MeshPL.cxx VISU_ScalarMapPL.cxx \
+ VISU_CutPlanesPL.cxx VISU_CutLinesPL.cxx \
+ VISU_IsoSurfacesPL.cxx VISU_DeformedShapePL.cxx \
+ VISU_VectorsPL.cxx VISU_StreamLinesPL.cxx \
+ VISU_LookupTable.cxx VISU_ScalarBarActor.cxx \
+ VISU_Extractor.cxx VISU_FieldTransform.cxx \
+ VISU_UsedPointsFilter.cxx
+
+# Executables targets
+
+BIN = VISUPipeLine
+BIN_SRC =
+
+CPPFLAGS+= $(VTK_INCLUDES)
+LDFLAGS+= $(VTK_LIBS) -lSalomeVTKFilter -lVisuConvertor
+
+@CONCLUDE@
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#include "VISU_Convertor.hxx"
+#include "VISU_MeshPL.hxx"
+#include "VISU_ScalarMapPL.hxx"
+#include "VISU_IsoSurfacesPL.hxx"
+#include "VISU_CutPlanesPL.hxx"
+#include "VISU_CutLinesPL.hxx"
+#include "VISU_DeformedShapePL.hxx"
+#include "VISU_VectorsPL.hxx"
+#include "VISU_StreamLinesPL.hxx"
+
+typedef VISU_StreamLinesPL TPresent;
+
+#include <vtkUnstructuredGrid.h>
+#include <vtkDataSetMapper.h>
+
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderer.h>
+#include <vtkCamera.h>
+#include <vtkActor.h>
+
+using namespace std;
+
+static int isOnlyMesh = false;
+
+int main(int argc, char** argv){
+ try{
+ if(argc > 1){
+ vtkRenderWindow *renWin = vtkRenderWindow::New();
+ vtkRenderer *ren = vtkRenderer::New();
+ renWin->AddRenderer(ren);
+ ren->GetActiveCamera()->ParallelProjectionOn();
+ vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+ iren->SetRenderWindow(renWin);
+ VISU_Convertor* aConvertor = CreateConvertor(argv[1]);
+ const VISU::TMeshMap& aMeshMap = aConvertor->GetMeshMap();
+ VISU::TMeshMap::const_iterator aMeshMapIter = aMeshMap.begin();
+ if(aMeshMapIter == aMeshMap.end()) return 0;
+ const string& aMeshName = aMeshMapIter->first;
+ const VISU::TMesh& aMesh = aMeshMapIter->second;
+ const VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh.myMeshOnEntityMap;
+ VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter;
+ if(isOnlyMesh){
+ const VISU::TEntity& anEntity = VISU::CELL_ENTITY;
+ aMeshOnEntityMapIter = aMeshOnEntityMap.find(anEntity);
+ vtkUnstructuredGrid* aDataSet = aConvertor->GetMeshOnEntity(aMeshName,anEntity);
+
+ VISU_MeshPL* aPresent = VISU_MeshPL::New();
+ aPresent->SetInput(aDataSet);
+ aPresent->Build();
+
+ vtkActor* aActor = vtkActor::New();
+ aActor->SetMapper(aPresent->GetMapper());
+ aActor->GetProperty()->SetRepresentation(VTK_WIREFRAME);
+ //ren->ResetCameraClippingRange();
+
+ ren->AddActor(aActor);
+
+ renWin->Render();
+ iren->Start();
+ return 0;
+ }
+ //Import fields
+ aMeshOnEntityMapIter = aMeshOnEntityMap.begin();
+ for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++) {
+ const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first;
+ const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second;
+ const VISU::TFieldMap& aFieldMap = aMeshOnEntity.myFieldMap;
+ VISU::TFieldMap::const_iterator aFieldMapIter = aFieldMap.begin();
+ for(; aFieldMapIter != aFieldMap.end(); aFieldMapIter++){
+ const VISU::TField& aField = aFieldMapIter->second;
+ if(aField.myNbComp == 1) continue;
+ const string& aFieldName = aFieldMapIter->first;
+ const VISU::TField::TValField& aValField = aField.myValField;
+ VISU::TField::TValField::const_iterator aValFieldIter = aValField.begin();
+ if(aValFieldIter == aValField.end()) return 0;
+ int aTimeStamp = aValFieldIter->first;
+ vtkUnstructuredGrid* aDataSet = aConvertor->GetTimeStampOnMesh(aMeshName,anEntity,aFieldName,aTimeStamp);
+
+ TPresent* aPresent = TPresent::New();
+ aPresent->SetInput(aDataSet);
+ aPresent->Build();
+ aPresent->Init();
+ //aPresent->SetPartDefault(0);
+ //aPresent->SetScalarMin(0.01);
+ //aPresent->SetScaling(VTK_SCALE_LOG10);
+ aPresent->Update();
+
+ vtkActor* anActor = vtkActor::New();
+ anActor->SetMapper(aPresent->GetMapper());
+
+ VISU_ScalarBarActor * aScalarBar = VISU_ScalarBarActor::New();
+ aScalarBar->SetLookupTable(aPresent->GetBarTable());
+
+ aPresent->Build();
+
+ ren->AddActor(anActor);
+ ren->AddActor2D(aScalarBar);
+ ren->ResetCameraClippingRange();
+
+ renWin->Render();
+ iren->Start();
+ return 0;
+ }
+ }
+ }
+ }catch(std::runtime_error& exc){
+ cout<<"Follow exception was accured :\n"<<exc.what()<<endl;
+ }catch(...){
+ cout<<"Unknown exception was accured in VISU_Convertor_impl"<<endl;
+ }
+ return 1;
+}
--- /dev/null
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_CutLinesPL.hxx"
+#include "VISU_PipeLineUtils.hxx"
+#include "SALOME_GeometryFilter.h"
+
+#include <vtkAppendPolyData.h>
+
+using namespace std;
+
+vtkStandardNewMacro(VISU_CutLinesPL);
+
+VISU_CutLinesPL::VISU_CutLinesPL(){}
+
+void VISU_CutLinesPL::ShallowCopy(VISU_PipeLine *thePipeLine){
+ VISU_CutPlanesPL::ShallowCopy(thePipeLine);
+ if(VISU_CutLinesPL *aPipeLine = dynamic_cast<VISU_CutLinesPL*>(thePipeLine)){
+ SetPlaneOrientation(aPipeLine->GetPlaneOrientation(1),1);
+ SetDisplacement(aPipeLine->GetDisplacement(1),1);
+ SetDefault();
+ if (!aPipeLine->IsDefault()) SetPosition(aPipeLine->GetPosition());
+ SetRotateX(aPipeLine->GetRotateX(1),1);
+ SetRotateY(aPipeLine->GetRotateY(1),1);
+ }
+}
+
+void VISU_CutLinesPL::Init(){
+ VISU_CutPlanesPL::Init();
+
+ myBasePlane[0] = XY;
+ myBasePlane[1] = YZ;
+ myDisplacement[0] = myDisplacement[1] = 0.5;
+ myAng[0][0] = myAng[0][1] = myAng[0][2] = 0.0;
+ myAng[1][0] = myAng[1][1] = myAng[1][2] = 0.0;
+
+ myCondition = 1;
+ myPosition = 0;
+}
+
+
+void VISU_CutLinesPL::SetPosition(float thePosition){
+ myPosition = thePosition;
+ myCondition = 0;
+ Modified();
+}
+float VISU_CutLinesPL::GetPosition(){
+ float aPosition = myPosition;
+ if(myCondition){
+ float aDir[3], aBounds[6], aBoundPrj[3];
+ myInput->GetBounds(aBounds);
+ GetDir(aDir,myAng[0],myBasePlane[0]);
+ GetBoundProject(aBoundPrj,aBounds,aDir);
+ aPosition = aBoundPrj[0] + aBoundPrj[2]*myDisplacement[0];
+ }
+ return aPosition;
+}
+
+void VISU_CutLinesPL::SetDefault(){
+ myCondition = 1;
+ Modified();
+}
+int VISU_CutLinesPL::IsDefault(){
+ return myCondition;
+}
+
+
+void VISU_CutLinesPL::Update(){
+ ClearAppendPolyData(myAppendPolyData);
+ SetPartPosition(1);
+ vtkAppendPolyData *anAppendPolyData = vtkAppendPolyData::New();
+ //Build base plane
+ float aDir[2][3], aBaseBounds[6];
+ myInput->GetBounds(aBaseBounds);
+ GetDir(aDir[0],myAng[0],myBasePlane[0]);
+ vtkUnstructuredGrid* anUnstructuredGrid =
+ myFieldTransform->GetUnstructuredGridOutput();
+ CutWithPlanes(anAppendPolyData,anUnstructuredGrid,1,aDir[0],aBaseBounds,
+ myPosition,myCondition,myDisplacement[0]);
+ //Build lines
+ float aBounds[6];
+ vtkDataSet *aDataSet = anAppendPolyData->GetOutput();
+ aDataSet->Update();
+ if(aDataSet->GetNumberOfCells() == 0)
+ aDataSet = anUnstructuredGrid;
+ aDataSet->GetBounds(aBounds);
+ GetDir(aDir[1],myAng[1],myBasePlane[1]);
+ VISU_CutPlanesPL::CutWithPlanes(myAppendPolyData,aDataSet,GetNbParts(),aDir[1],aBounds,
+ myPartPosition,myPartCondition,myDisplacement[1]);
+ anAppendPolyData->Register(myAppendPolyData);
+ anAppendPolyData->Delete();
+ //Calculate values for building of table
+ vtkMath::Cross(aDir[0],aDir[1],myDirLn);
+ GetBoundProject(myBoundPrjLn, aBaseBounds, myDirLn);
+ VISU::Mul(myDirLn,myBoundPrjLn[0],myBasePnt);
+ CorrectPnt(myBasePnt,aBaseBounds);
+
+ VISU_ScalarMapPL::Update();
+}
+
+
+void VISU_CutLinesPL::CutWithPlanes(vtkAppendPolyData* theAppendPolyData, vtkDataSet* theDataSet,
+ int theNbPlanes, float theDir[3], float theBounds[6],
+ float thePartPosition, int thePartCondition,
+ float theDisplacement)
+{
+ vector<float> aPartPosition(1,thePartPosition);
+ vector<int> aPartCondition(1,thePartCondition);
+ VISU_CutPlanesPL::CutWithPlanes(theAppendPolyData,theDataSet,theNbPlanes,theDir,theBounds,
+ aPartPosition,aPartCondition,theDisplacement);
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_CutLinesPL_HeaderFile
+#define VISU_CutLinesPL_HeaderFile
+
+#include "VISU_CutPlanesPL.hxx"
+
+class vtkAppendPolyData;
+
+class VISU_CutLinesPL : public VISU_CutPlanesPL{
+protected:
+ VISU_CutLinesPL();
+ VISU_CutLinesPL(const VISU_CutLinesPL&);
+public:
+ vtkTypeMacro(VISU_CutLinesPL,VISU_CutPlanesPL);
+ static VISU_CutLinesPL* New();
+ virtual void ShallowCopy(VISU_PipeLine *thePipeLine);
+
+ virtual void SetPosition(float thePosition);
+ virtual float GetPosition();
+
+ virtual void SetDefault();
+ virtual int IsDefault();
+
+public:
+ virtual void Init();
+ virtual void Update();
+
+ static void CutWithPlanes(vtkAppendPolyData* theAppendPolyData, vtkDataSet* theDataSet,
+ int theNbPlanes, float theDir[3], float theBounds[6],
+ float thePlanePosition, int thePlaneCondition,
+ float theDisplacement);
+
+ const float* GetDirLn(){ return myDirLn;}
+ const float* GetBoundPrjLn(){ return myBoundPrjLn;}
+ const float* GetBasePnt(){ return myBasePnt;}
+
+protected:
+ float myDirLn[3], myBoundPrjLn[3], myBasePnt[3];
+ float myPosition;
+ int myCondition;
+};
+
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_CutPlanesPL.hxx"
+#include "VISU_PipeLineUtils.hxx"
+#include "SALOME_GeometryFilter.h"
+
+#include <vtkAppendPolyData.h>
+#include <vtkCutter.h>
+#include <vtkPlane.h>
+
+using namespace std;
+
+static float EPS = 1.0E-3;
+
+vtkStandardNewMacro(VISU_CutPlanesPL);
+
+VISU_CutPlanesPL::VISU_CutPlanesPL(){
+ myAppendPolyData = vtkAppendPolyData::New();
+}
+
+VISU_CutPlanesPL::~VISU_CutPlanesPL(){
+ myAppendPolyData->Delete();
+}
+
+void VISU_CutPlanesPL::ShallowCopy(VISU_PipeLine *thePipeLine){
+ VISU_ScalarMapPL::ShallowCopy(thePipeLine);
+ if(VISU_CutPlanesPL *aPipeLine = dynamic_cast<VISU_CutPlanesPL*>(thePipeLine)){
+ SetPlaneOrientation(aPipeLine->GetPlaneOrientation());
+ SetDisplacement(aPipeLine->GetDisplacement());
+ SetNbParts(aPipeLine->GetNbParts());
+ for (int i = 0, iend = GetNbParts(); i < iend; i++)
+ if(!aPipeLine->IsPartDefault(i)) SetPartPosition(i, aPipeLine->GetPartPosition(i));
+ SetRotateX(aPipeLine->GetRotateX());
+ SetRotateY(aPipeLine->GetRotateY());
+ }
+}
+
+void VISU_CutPlanesPL::Init(){
+ VISU_ScalarMapPL::Init();
+
+ SetNbParts(10);
+ myBasePlane[0] = YZ;
+ myDisplacement[0] = 0.5;
+ myAng[0][0] = myAng[0][1] = myAng[0][2] = 0.0;
+}
+
+VISU_ScalarMapPL::THook* VISU_CutPlanesPL::DoHook(){
+ return myAppendPolyData->GetOutput();
+}
+
+void VISU_CutPlanesPL::Update(){
+ ClearAppendPolyData(myAppendPolyData);
+ SetPartPosition();
+ float aDir[3];
+ GetDir(aDir,myAng[0],myBasePlane[0]);
+ float aBounds[6];
+ myInput->GetBounds(aBounds);
+ vtkDataSet* aDataSet = myFieldTransform->GetUnstructuredGridOutput();
+ CutWithPlanes(myAppendPolyData,aDataSet,myNbParts,aDir,aBounds,
+ myPartPosition,myPartCondition,myDisplacement[0]);
+
+ VISU_ScalarMapPL::Update();
+}
+
+void VISU_CutPlanesPL::SetPartPosition(int theNum){
+ for(int i = 0; i < myNbParts; i++)
+ myPartPosition[i] = GetPartPosition(i,theNum);
+}
+
+void VISU_CutPlanesPL::ClearAppendPolyData(vtkAppendPolyData *theAppendPolyData){
+ int iEnd = theAppendPolyData->GetNumberOfInputs();
+ for(int i = iEnd-1; i >= 0; i--)
+ theAppendPolyData->RemoveInput(theAppendPolyData->GetInput(i));
+}
+
+float* VISU_CutPlanesPL::GetRx(float theRx[3][3], float thaAng){
+ theRx[0][0] = 1.0; theRx[0][1] = 0.0; theRx[0][2] = 0.0;
+ theRx[1][0] = 0.0; theRx[1][1] = cos(thaAng); theRx[1][2] = -sin(thaAng);
+ theRx[2][0] = 0.0; theRx[2][1] = sin(thaAng); theRx[2][2] = cos(thaAng);
+ return theRx[0];
+}
+
+
+float* VISU_CutPlanesPL::GetRy(float theRy[3][3], float thaAng){
+ theRy[0][0] = cos(thaAng); theRy[0][1] = 0.0; theRy[0][2] = sin(thaAng);
+ theRy[1][0] = 0.0; theRy[1][1] = 1.0; theRy[1][2] = 0.0;
+ theRy[2][0] = -sin(thaAng); theRy[2][1] = 0.0; theRy[2][2] = cos(thaAng);
+ return theRy[0];
+}
+
+
+float* VISU_CutPlanesPL::GetRz(float theRz[3][3], float thaAng){
+ theRz[0][0] = cos(thaAng); theRz[0][1] = -sin(thaAng); theRz[0][2] = 0.0;
+ theRz[1][0] = sin(thaAng); theRz[1][1] = cos(thaAng); theRz[1][2] = 0.0;
+ theRz[2][0] = 0.0; theRz[2][1] = 0.0; theRz[2][2] = 1.0;
+ return theRz[0];
+}
+
+
+void VISU_CutPlanesPL::CorrectPnt(float thePnt[3], const float BoundPrj[6]){
+ for(int i = 0, j = 0; i < 3; ++i, j=2*i){
+ if(thePnt[i] < BoundPrj[j]) thePnt[i] = BoundPrj[j];
+ if(thePnt[i] > BoundPrj[j+1]) thePnt[i] = BoundPrj[j+1];
+ }
+}
+
+void VISU_CutPlanesPL::GetBoundProject(float BoundPrj[3], const float BoundBox[6], const float Dir[3]){
+ float BoundPoints[8][3] = { {BoundBox[0],BoundBox[2],BoundBox[4]},
+ {BoundBox[1],BoundBox[2],BoundBox[4]},
+ {BoundBox[0],BoundBox[3],BoundBox[4]},
+ {BoundBox[1],BoundBox[3],BoundBox[4]},
+ {BoundBox[0],BoundBox[2],BoundBox[5]},
+ {BoundBox[1],BoundBox[2],BoundBox[5]},
+ {BoundBox[0],BoundBox[3],BoundBox[5]},
+ {BoundBox[1],BoundBox[3],BoundBox[5]}};
+ BoundPrj[0] = vtkMath::Dot(Dir,BoundPoints[0]), BoundPrj[1] = BoundPrj[0];
+ for(int i = 1; i < 8; i++){
+ float tmp = vtkMath::Dot(Dir,BoundPoints[i]);
+ if(BoundPrj[1] < tmp) BoundPrj[1] = tmp;
+ if(BoundPrj[0] > tmp) BoundPrj[0] = tmp;
+ }
+ BoundPrj[2] = BoundPrj[1] - BoundPrj[0];
+ BoundPrj[1] = BoundPrj[0] + (1.0 - EPS)*BoundPrj[2];
+ BoundPrj[0] = BoundPrj[0] + EPS*BoundPrj[2];
+ BoundPrj[2] = BoundPrj[1] - BoundPrj[0];
+}
+
+void VISU_CutPlanesPL::SetRotateX(float theAng, int theNum){
+ switch(myBasePlane[theNum]){
+ case XY: myAng[theNum][0] = theAng; break;
+ case YZ: myAng[theNum][1] = theAng; break;
+ case ZX: myAng[theNum][2] = theAng; break;
+ }
+}
+
+float VISU_CutPlanesPL::GetRotateX(int theNum){
+ switch(myBasePlane[theNum]){
+ case XY: return myAng[theNum][0];
+ case YZ: return myAng[theNum][1];
+ case ZX: return myAng[theNum][2];
+ }
+}
+
+void VISU_CutPlanesPL::SetRotateY(float theAng, int theNum){
+ switch(myBasePlane[theNum]){
+ case XY: myAng[theNum][1] = theAng; break;
+ case YZ: myAng[theNum][2] = theAng; break;
+ case ZX: myAng[theNum][0] = theAng; break;
+ }
+}
+
+float VISU_CutPlanesPL::GetRotateY(int theNum){
+ switch(myBasePlane[theNum]){
+ case XY: return myAng[theNum][1];
+ case YZ: return myAng[theNum][2];
+ case ZX: return myAng[theNum][0];
+ }
+}
+
+
+void VISU_CutPlanesPL::SetNbParts(int theNb) {
+ myNbParts = theNb;
+ myPartPosition.resize(myNbParts);
+ myPartCondition.resize(myNbParts,1);
+ Modified();
+}
+
+
+void VISU_CutPlanesPL::SetPartPosition(int thePartNumber, float thePartPosition){
+ if(thePartNumber >= myNbParts) return;
+ myPartPosition[thePartNumber] = thePartPosition;
+ myPartCondition[thePartNumber] = 0;
+ Modified();
+}
+float VISU_CutPlanesPL::GetPartPosition(int thePartNumber, int theNum){
+ if(thePartNumber >= myNbParts) return 0;
+ float aPosition = myPartPosition[thePartNumber];
+ if(myPartCondition[thePartNumber]){
+ float aDir[3], aBounds[6], aBoundPrj[3];
+ myInput->GetBounds(aBounds);
+ GetDir(aDir,myAng[theNum],myBasePlane[theNum]);
+ GetBoundProject(aBoundPrj,aBounds,aDir);
+ if (myNbParts > 1){
+ float aDBoundPrj = aBoundPrj[2]/(myNbParts - 1);
+ float aDisplacement = aDBoundPrj * myDisplacement[theNum];
+ float aStartPosition = aBoundPrj[0] - 0.5*aDBoundPrj + aDisplacement;
+ aPosition = aStartPosition + thePartNumber*aDBoundPrj;
+ }else
+ aPosition = aBoundPrj[0] + aBoundPrj[2]*myDisplacement[theNum];
+ }
+ return aPosition;
+}
+
+
+void VISU_CutPlanesPL::SetPartDefault(int thePartNumber){
+ if(thePartNumber >= myNbParts) return;
+ myPartPosition[thePartNumber] = GetPartPosition(thePartNumber);
+ myPartCondition[thePartNumber] = 1;
+ Modified();
+}
+int VISU_CutPlanesPL::IsPartDefault(int thePartNumber){
+ if(thePartNumber >= myNbParts) return 1;
+ return myPartCondition[thePartNumber];
+}
+
+
+void VISU_CutPlanesPL::GetDir(float theDir[3], float theAng[3], const PlaneOrientation& theBasePlane){
+ int iPlane = 0;
+ float aRx[3][3], aRy[3][3], aRz[3][3], aRotation[3][3];
+ switch(theBasePlane){
+ case XY:
+ if(fabs(theAng[0]) > EPS) GetRx(aRx,theAng[0]); else vtkMath::Identity3x3(aRx);
+ if(fabs(theAng[1]) > EPS) GetRy(aRy,theAng[1]); else vtkMath::Identity3x3(aRy);
+ vtkMath::Multiply3x3(aRx,aRy,aRotation);
+ iPlane = 2;
+ break;
+ case YZ:
+ if(fabs(theAng[1]) > EPS) GetRy(aRy,theAng[1]); else vtkMath::Identity3x3(aRy);
+ if(fabs(theAng[2]) > EPS) GetRz(aRz,theAng[2]); else vtkMath::Identity3x3(aRz);
+ vtkMath::Multiply3x3(aRy,aRz,aRotation);
+ iPlane = 0;
+ break;
+ case ZX:
+ if(fabs(theAng[2]) > EPS) GetRz(aRz,theAng[2]); else vtkMath::Identity3x3(aRz);
+ if(fabs(theAng[0]) > EPS) GetRx(aRx,theAng[0]); else vtkMath::Identity3x3(aRx);
+ vtkMath::Multiply3x3(aRz,aRx,aRotation);
+ iPlane = 1;
+ break;
+ }
+ for(int i = 0; i < 3; i++)
+ theDir[i] = aRotation[i][iPlane];
+}
+
+
+void VISU_CutPlanesPL::CutWithPlane(vtkAppendPolyData* theAppendPolyData,
+ vtkDataSet* theDataSet,
+ float theDir[3], float theOrig[3])
+{
+ vtkCutter *aCutPlane = vtkCutter::New();
+ aCutPlane->SetInput(theDataSet);
+ vtkPlane *aPlane = vtkPlane::New();
+ aPlane->SetOrigin(theOrig);
+
+ aPlane->SetNormal(theDir);
+ aCutPlane->SetCutFunction(aPlane);
+ aPlane->Delete();
+ theAppendPolyData->AddInput(aCutPlane->GetOutput());
+ aCutPlane->Register(theAppendPolyData);
+ aCutPlane->Delete();
+}
+
+
+void VISU_CutPlanesPL::CutWithPlanes(vtkAppendPolyData* theAppendPolyData, vtkDataSet* theDataSet,
+ int theNbPlanes, float theDir[3], float theBounds[6],
+ const vector<float>& thePlanePosition,
+ const vector<int>& thePlaneCondition,
+ float theDisplacement)
+{
+ float aBoundPrj[3], aOrig[3], aPosition;
+ GetBoundProject(aBoundPrj, theBounds, theDir);
+ if(theNbPlanes > 1){
+ float aDBoundPrj = aBoundPrj[2]/(theNbPlanes - 1);
+ float aDisplacement = aDBoundPrj*theDisplacement;
+ float aStartPosition = aBoundPrj[0] - 0.5*aDBoundPrj + aDisplacement;
+ for (int i = 0; i < theNbPlanes; i++){
+ aPosition = aStartPosition + i*aDBoundPrj;
+ float aDelta = (aBoundPrj[0] - aPosition) / aBoundPrj[2];
+ if(thePlaneCondition[i]){
+ aPosition = aStartPosition + i*aDBoundPrj;
+ }else
+ aPosition = thePlanePosition[i];
+ VISU::Mul(theDir,aPosition,aOrig);
+ CutWithPlane(theAppendPolyData,theDataSet,theDir,aOrig);
+ }
+ }else{
+ if(thePlaneCondition[0])
+ aPosition = aBoundPrj[0] + aBoundPrj[2]*theDisplacement;
+ else
+ aPosition = thePlanePosition[0];
+ VISU::Mul(theDir,aPosition,aOrig);
+ CutWithPlane(theAppendPolyData,theDataSet,theDir,aOrig);
+ }
+ vtkPolyData *aPolyData = theAppendPolyData->GetOutput();
+ aPolyData->Update();
+ theAppendPolyData->Update();
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_CutPlanesPL.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_CutPlanesPL_HeaderFile
+#define VISU_CutPlanesPL_HeaderFile
+
+#include "VISU_ScalarMapPL.hxx"
+
+#include <vector>
+
+class vtkAppendPolyData;
+
+class VISU_CutPlanesPL : public VISU_ScalarMapPL{
+protected:
+ VISU_CutPlanesPL();
+ VISU_CutPlanesPL(const VISU_CutPlanesPL&);
+public:
+ vtkTypeMacro(VISU_CutPlanesPL,VISU_ScalarMapPL);
+ static VISU_CutPlanesPL* New();
+ virtual ~VISU_CutPlanesPL();
+ virtual void ShallowCopy(VISU_PipeLine *thePipeLine);
+
+ enum PlaneOrientation {XY, YZ, ZX};
+ virtual const PlaneOrientation& GetPlaneOrientation(int theNum = 0) { return myBasePlane[theNum];}
+ virtual void SetPlaneOrientation(const PlaneOrientation& theOrient, int theNum = 0) {
+ myBasePlane[theNum] = theOrient;
+ }
+
+ virtual float GetDisplacement(int theNum = 0) { return myDisplacement[theNum];}
+ virtual void SetDisplacement(float theDisp, int theNum = 0) { myDisplacement[theNum] = theDisp;}
+
+ virtual void SetPartPosition(int thePartNumber, float thePartPosition);
+ virtual float GetPartPosition(int thePartNumber, int theNum = 0);
+
+ virtual void SetPartDefault(int thePartNumber);
+ virtual int IsPartDefault(int thePartNumber);
+
+ virtual void SetRotateX(float theAngle, int theNum = 0);
+ virtual float GetRotateX(int theNum = 0);
+ virtual void SetRotateY(float theAngle, int theNum = 0);
+ virtual float GetRotateY(int theNum = 0);
+
+ virtual void SetNbParts(int theNb);
+ virtual int GetNbParts(){ return myNbParts;}
+
+public:
+ virtual void Init();
+ virtual void Update();
+ virtual vtkAppendPolyData* GetAppendPolyData() { return myAppendPolyData; }
+
+public:
+ static float* GetRx(float theRx[3][3], float thaAng);
+ static float* GetRy(float theRy[3][3], float thaAng);
+ static float* GetRz(float theRz[3][3], float thaAng);
+
+ static void CorrectPnt(float thePnt[3], const float BoundPrj[6]);
+ static void GetBoundProject(float BoundPrj[3], const float BoundBox[6], const float Dir[3]);
+
+ static void GetDir(float theDir[3], float theAng[3], const PlaneOrientation& theBasePlane);
+
+ static void ClearAppendPolyData(vtkAppendPolyData *theAppendPolyData);
+
+ static void CutWithPlane(vtkAppendPolyData* theAppendPolyData, vtkDataSet* theDataSet,
+ float theDir[3], float theOrig[3]);
+ static void CutWithPlanes(vtkAppendPolyData* theAppendPolyData, vtkDataSet* theDataSet,
+ int theNbPlanes, float theDir[3], float theBounds[6],
+ const std::vector<float>& thePlanePosition,
+ const std::vector<int>& thePlaneCondition,
+ float theDisplacement);
+protected:
+ virtual THook* DoHook();
+ void SetPartPosition(int theNum = 0);
+
+ int myNbParts;
+ PlaneOrientation myBasePlane[2];
+ float myAng[2][3], myDisplacement[2];
+ vtkAppendPolyData *myAppendPolyData;
+ std::vector<float> myPartPosition;
+ std::vector<int> myPartCondition;
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_DeformedShapePL.hxx"
+#include "VISU_PipeLineUtils.hxx"
+#include "SALOME_Transform.h"
+
+#include <vtkWarpVector.h>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+vtkStandardNewMacro(VISU_DeformedShapePL);
+
+VISU_DeformedShapePL::VISU_DeformedShapePL(){
+ myWarpVector = vtkWarpVector::New();
+}
+
+VISU_DeformedShapePL::~VISU_DeformedShapePL(){
+ myWarpVector->Delete();
+}
+
+void VISU_DeformedShapePL::ShallowCopy(VISU_PipeLine *thePipeLine){
+ VISU_ScalarMapPL::ShallowCopy(thePipeLine);
+ if(VISU_DeformedShapePL *aPipeLine = dynamic_cast<VISU_DeformedShapePL*>(thePipeLine)){
+ SetScale(aPipeLine->GetScale());
+ }
+}
+
+float VISU_DeformedShapePL::GetScaleFactor(vtkDataSet* theDataSet){
+ if(!theDataSet) return 0.0;
+ theDataSet->Update();
+ int aNbCells = theDataSet->GetNumberOfCells();
+ int aNbPoints = theDataSet->GetNumberOfPoints();
+ int aNbElem = aNbCells? aNbCells: aNbPoints;
+ float* aBounds = theDataSet->GetBounds();
+ float aVolume = 1, aVol, idim = 0;
+ for(int i = 0; i < 6; i += 2){
+ aVol = fabs(aBounds[i+1] - aBounds[i]);
+ if(aVol > 0) {
+ idim++;
+ aVolume *= aVol;
+ }
+ }
+ aVolume /= aNbElem;
+ return pow(aVolume,float(1.0/idim));
+}
+
+
+void VISU_DeformedShapePL::SetScale(float theScale) {
+ if(myScaleFactor == theScale) return;
+ myScaleFactor = theScale;
+ myWarpVector->SetScaleFactor(myScaleFactor);
+ Modified();
+}
+float VISU_DeformedShapePL::GetScale() {
+ return myWarpVector->GetScaleFactor();
+}
+
+void VISU_DeformedShapePL::Init(){
+ VISU_ScalarMapPL::Init();
+ float aScalarRange[2];
+ GetSourceRange(aScalarRange);
+ SetScale(GetScaleFactor(myInput)/aScalarRange[1]);
+}
+
+VISU_ScalarMapPL::THook* VISU_DeformedShapePL::DoHook(){
+ VISU::CellDataToPoint(myWarpVector,myInput,myFieldTransform);
+ return myWarpVector->GetOutput();
+}
+
+void VISU_DeformedShapePL::Update(){
+ VISU_ScalarMapPL::Update();
+}
+
+void VISU_DeformedShapePL::SetMapScale(float theMapScale){
+ VISU_ScalarMapPL::SetMapScale(theMapScale);
+
+ myWarpVector->SetScaleFactor(myScaleFactor*theMapScale);
+ Modified();
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_DeformedShapePL_HeaderFile
+#define VISU_DeformedShapePL_HeaderFile
+
+#include "VISU_ScalarMapPL.hxx"
+
+class SALOME_Transform;
+class vtkWarpVector;
+
+class VISU_DeformedShapePL : public VISU_ScalarMapPL{
+protected:
+ VISU_DeformedShapePL();
+ VISU_DeformedShapePL(const VISU_DeformedShapePL&);
+public:
+ vtkTypeMacro(VISU_DeformedShapePL,VISU_ScalarMapPL);
+ static VISU_DeformedShapePL* New();
+ virtual ~VISU_DeformedShapePL();
+ virtual void ShallowCopy(VISU_PipeLine *thePipeLine);
+
+ virtual void SetScale(float theScale);
+ virtual float GetScale();
+
+public:
+ virtual void Init();
+ virtual void Update();
+ virtual void SetMapScale(float theMapScale = 1.0);
+
+ static float GetScaleFactor(vtkDataSet* theDataSet);
+
+protected:
+ virtual THook* DoHook();
+
+ vtkWarpVector *myWarpVector;
+ float myScaleFactor;
+};
+
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Extractor.cxx
+// Module : VISU
+
+#include "VISU_Extractor.hxx"
+
+#include <vtkObjectFactory.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkFloatArray.h>
+#include <vtkPointData.h>
+#include <vtkCellData.h>
+
+using namespace std;
+
+#ifdef DEBUG
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+vtkStandardNewMacro(VISU_Extractor);
+
+VISU_Extractor::VISU_Extractor(){
+ myScalarMode = 0;
+}
+
+VISU_Extractor::~VISU_Extractor() {}
+
+void VISU_Extractor::SetScalarMode(int theScalarMode){
+ if(myScalarMode != theScalarMode){
+ myScalarMode = theScalarMode;
+ Modified();
+ }
+}
+
+
+template<typename TypeData> void
+execute(int theNbComp, int theScalarMode, TypeData* theInputData, TypeData* theOutputData){
+ vtkDataArray *inVectors = theInputData->GetVectors();
+ if ( !inVectors || theNbComp < 1 )
+ return;
+ vtkFloatArray *newScalars = vtkFloatArray::New();
+ //newScalars->SetName(inVectors->GetName());
+ newScalars->SetNumberOfComponents(1);
+ newScalars->SetNumberOfTuples(theNbComp);
+ for (int ptId = 0; ptId < theNbComp; ptId++) {
+ float v[3], s;
+ inVectors->GetTuple(ptId,v);
+ if ( theScalarMode < 1 || theScalarMode > 3)
+ s = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+ else
+ s = v[theScalarMode - 1];
+ newScalars->SetTuple1(ptId, s);
+ }
+ theOutputData->SetScalars(newScalars);
+ //theOutputData->SetActiveScalars(newScalars->GetName());
+ newScalars->Delete();
+}
+
+
+void VISU_Extractor::Execute(){
+ vtkDataSet *input = this->GetInput(), *output = this->GetOutput();
+ output->CopyStructure(input);
+ output->GetPointData()->CopyAllOff();
+ output->GetCellData()->CopyAllOff();
+ if(input->GetPointData()->GetNumberOfArrays()){
+ output->GetPointData()->CopyVectorsOn();
+ int nbComp = input->GetNumberOfPoints();
+ vtkPointData *inData = input->GetPointData(), *outData = output->GetPointData();
+ if(inData->GetAttribute(vtkDataSetAttributes::VECTORS))
+ execute(nbComp,myScalarMode,inData,outData);
+ else
+ output->GetPointData()->CopyScalarsOn();
+ outData->PassData(inData);
+ }else{
+ output->GetCellData()->CopyVectorsOn();
+ int nbComp = input->GetNumberOfCells();
+ vtkCellData *inData = input->GetCellData(), *outData = output->GetCellData();
+ if(inData->GetAttribute(vtkDataSetAttributes::VECTORS))
+ execute(nbComp,myScalarMode,inData,outData);
+ else
+ output->GetCellData()->CopyScalarsOn();
+ outData->PassData(inData);
+ }
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Extractor.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_Extractor_HeaderFile
+#define VISU_Extractor_HeaderFile
+
+#include <vtkPointSetToPointSetFilter.h>
+
+class VTK_EXPORT VISU_Extractor : public vtkPointSetToPointSetFilter{
+public:
+ vtkTypeMacro(VISU_Extractor,vtkPointSetToPointSetFilter);
+ static VISU_Extractor *New();
+ ~VISU_Extractor();
+
+ virtual int GetScalarMode(){ return myScalarMode;}
+ virtual void SetScalarMode(int theScalarMode = 0);
+
+protected:
+ VISU_Extractor();
+ VISU_Extractor(const VISU_Extractor&);
+
+ virtual void Execute();
+
+ int myScalarMode;
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2003 CEA/DEN, EDF R&D
+//
+//
+//
+// File : VISU_FieldTransform.cxx
+// Module : VISU
+
+#include "VISU_FieldTransform.hxx"
+#include "SALOME_Transform.h"
+
+#include <vtkObjectFactory.h>
+#include <vtkFloatArray.h>
+#include <vtkPointData.h>
+#include <vtkCellData.h>
+#include <vtkDataSet.h>
+#include <vtkMath.h>
+
+using namespace std;
+
+#ifdef DEBUG
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+vtkStandardNewMacro(VISU_FieldTransform);
+
+double VISU_FieldTransform::Ident(double theArg){
+ return theArg;
+}
+double VISU_FieldTransform::Log10(double theArg){
+ if(theArg <= 0.0) return -VTK_LARGE_FLOAT;
+ return log10(theArg);
+}
+
+
+VISU_FieldTransform::VISU_FieldTransform(){
+ myFunction = &Ident;
+ myTransform = NULL;
+}
+
+VISU_FieldTransform::~VISU_FieldTransform() {}
+
+
+void VISU_FieldTransform::Update(){
+ if(myTransform && myTransform->GetMTime() > vtkSource::GetMTime())
+ Modified();
+ vtkSource::Update();
+}
+
+unsigned long VISU_FieldTransform::GetMTime(){
+ if(myTransform && myTransform->GetMTime() > vtkSource::GetMTime())
+ return myTransform->GetMTime();
+ return vtkSource::GetMTime();
+}
+
+void VISU_FieldTransform::SetScalarTransform(TTransformFun theFunction) {
+ myFunction = theFunction;
+ if(myFunction == NULL) myFunction = &Ident;
+ Modified();
+}
+
+void VISU_FieldTransform::SetSpaceTransform(SALOME_Transform* theTransform){
+ if(myTransform != theTransform){
+ if (myTransform != NULL) myTransform->UnRegister(this);
+ myTransform = theTransform;
+ if (myTransform != NULL) myTransform->Register(this);
+ this->Modified();
+ }
+}
+
+
+void VISU_FieldTransform::SetScalarRange(float theScalarRange[2]) {
+ myScalarRange[0] = theScalarRange[0];
+ myScalarRange[1] = theScalarRange[1];
+ Modified();
+}
+void VISU_FieldTransform::SetScalarMin(float theValue){
+ float aScalarRange[2] = {theValue, GetScalarRange()[1]};
+ SetScalarRange(aScalarRange);
+}
+void VISU_FieldTransform::SetScalarMax(float theValue){
+ float aScalarRange[2] = {GetScalarRange()[0], theValue};
+ SetScalarRange(aScalarRange);
+}
+
+template<typename TypeData> void
+ExecVectors(VISU_FieldTransform::TTransformFun theFunction,
+ SALOME_Transform* theTransform,
+ float theScalarRange[2], int theNbComponent,
+ TypeData* theInputData, TypeData* theOutputData)
+{
+ vtkDataArray *inVectors = theInputData->GetVectors();
+ if ( !inVectors || theNbComponent < 1 ) return;
+ vtkFloatArray *newVectors = vtkFloatArray::New();
+ newVectors->SetNumberOfComponents(3);
+ newVectors->SetNumberOfTuples(theNbComponent);
+ float aScalarRange[2] = {(*theFunction)(theScalarRange[0]),(*theFunction)(theScalarRange[1])};
+ float *V, v[3], vMag, aDelta = aScalarRange[1] - aScalarRange[0];
+ float aScale[3] = {1.0, 1.0, 1.0};
+ if(theTransform){
+ aScale[0] = theTransform->GetScale()[0];
+ aScale[1] = theTransform->GetScale()[1];
+ aScale[2] = theTransform->GetScale()[2];
+ }
+ for (int ptId = 0; ptId < theNbComponent; ptId++) {
+ V = inVectors->GetTuple3(ptId);
+ vMag = vtkMath::Norm(V);
+ vMag = ((*theFunction)(vMag) - aScalarRange[0]) / aDelta * theScalarRange[1] / vMag;
+ if(vMag <= 0.0) vMag = 0.0;
+ v[0] = V[0]*vMag*aScale[0];
+ v[1] = V[1]*vMag*aScale[1];
+ v[2] = V[2]*vMag*aScale[2];
+ newVectors->SetTuple3(ptId, v[0], v[1], v[2]);
+ }
+ theOutputData->SetVectors(newVectors);
+ newVectors->Delete();
+}
+
+template<typename TypeData> void
+ExecScalars(VISU_FieldTransform::TTransformFun theFunction, float theScalarRange[2],
+ int theNbComponent, TypeData* theInputData, TypeData* theOutputData)
+{
+ vtkDataArray *inScalars = theInputData->GetScalars();
+ if ( !inScalars || theNbComponent < 1 )
+ return;
+ vtkFloatArray *newScalars = vtkFloatArray::New();
+ newScalars->SetNumberOfComponents(1);
+ newScalars->SetNumberOfTuples(theNbComponent);
+ float aScalarRange[2] = {(*theFunction)(theScalarRange[0]),(*theFunction)(theScalarRange[1])};
+ for (int ptId = 0; ptId < theNbComponent; ptId++) {
+ float s = (*theFunction)(inScalars->GetTuple1(ptId ));
+ if(s < aScalarRange[0]) s = aScalarRange[0];
+ newScalars->SetTuple1(ptId, s);
+ }
+ theOutputData->SetScalars(newScalars);
+ newScalars->Delete();
+}
+
+void VISU_FieldTransform::Execute(){
+ vtkDataSet *input = this->GetInput(), *output = this->GetOutput();
+ output->CopyStructure(input);
+ if(myFunction != &Ident || (myTransform && !myTransform->IsIdentity())){
+ output->GetPointData()->CopyAllOff();
+ output->GetCellData()->CopyAllOff();
+
+ ExecScalars(myFunction,myScalarRange,input->GetNumberOfPoints(),input->GetPointData(),output->GetPointData());
+ ExecVectors(myFunction,myTransform,myScalarRange,input->GetNumberOfPoints(),input->GetPointData(),output->GetPointData());
+
+ ExecScalars(myFunction,myScalarRange,input->GetNumberOfCells(),input->GetCellData(),output->GetCellData());
+ ExecVectors(myFunction,myTransform,myScalarRange,input->GetNumberOfCells(),input->GetCellData(),output->GetCellData());
+ }else{
+ output->GetPointData()->CopyAllOn();
+ output->GetCellData()->CopyAllOn();
+
+ output->GetPointData()->PassData(input->GetPointData());
+ output->GetCellData()->PassData(input->GetCellData());
+ }
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Extractor.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_FieldTransform_HeaderFile
+#define VISU_FieldTransform_HeaderFile
+
+#include <vtkDataSetToDataSetFilter.h>
+
+class SALOME_Transform;
+
+class VTK_EXPORT VISU_FieldTransform : public vtkDataSetToDataSetFilter{
+public:
+ vtkTypeMacro(VISU_FieldTransform,vtkDataSetToDataSetFilter);
+ static VISU_FieldTransform *New();
+
+ virtual void Update();
+ virtual unsigned long GetMTime();
+
+ static double Ident(double theArg);
+ static double Log10(double theArg);
+ typedef double (*TTransformFun)(double);
+ void SetScalarTransform(TTransformFun theFunction);
+ TTransformFun GetScalarTransform() { return myFunction;}
+
+ void SetSpaceTransform(SALOME_Transform* theTransform);
+ SALOME_Transform* GetSpaceTransform() { return myTransform;}
+
+ float* GetScalarRange(){ return myScalarRange; }
+ void SetScalarRange(float theScalarRange[2]);
+ void SetScalarMin(float theValue);
+ void SetScalarMax(float theValue);
+
+protected:
+ VISU_FieldTransform();
+ virtual ~VISU_FieldTransform();
+ VISU_FieldTransform(const VISU_FieldTransform&) {};
+ void operator=(const VISU_FieldTransform&) {};
+ void Execute();
+
+ SALOME_Transform *myTransform;
+ TTransformFun myFunction;
+ float myScalarRange[2];
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File: VISU_PipeLine.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_IsoSurfacesPL.hxx"
+#include "VISU_PipeLineUtils.hxx"
+
+#include <vtkContourFilter.h>
+
+VISU_IsoSurfacesPL* VISU_IsoSurfacesPL::New(){
+ vtkObject* ret = vtkObjectFactory::CreateInstance("VISU_IsoSurfacesPL");
+ if(ret) return (VISU_IsoSurfacesPL*)ret;
+ return new VISU_IsoSurfacesPL;
+}
+
+VISU_IsoSurfacesPL::VISU_IsoSurfacesPL(){
+ myContourFilter = vtkContourFilter::New();
+}
+
+VISU_IsoSurfacesPL::~VISU_IsoSurfacesPL(){
+ myContourFilter->Delete();
+}
+
+void VISU_IsoSurfacesPL::ShallowCopy(VISU_PipeLine *thePipeLine){
+ VISU_ScalarMapPL::ShallowCopy(thePipeLine);
+ if(VISU_IsoSurfacesPL *aPipeLine = dynamic_cast<VISU_IsoSurfacesPL*>(thePipeLine)){
+ SetNbParts(aPipeLine->GetNbParts());
+ float aRange[2] = {aPipeLine->GetMin(), aPipeLine->GetMax()};
+ SetRange(aRange);
+ }
+}
+
+int VISU_IsoSurfacesPL::GetNbParts() {
+ return myContourFilter->GetNumberOfContours();
+}
+void VISU_IsoSurfacesPL::SetNbParts(int theNb) {
+ myContourFilter->SetNumberOfContours(theNb);
+ Modified();
+}
+
+
+void VISU_IsoSurfacesPL::SetScaling(int theScaling) {
+ VISU_ScalarMapPL::SetScaling(theScaling);
+ SetRange(myRange);
+}
+void VISU_IsoSurfacesPL::SetRange(float theRange[2]){
+ if(theRange[0] <= theRange[1]){
+ myRange[0] = theRange[0]; myRange[1] = theRange[1];
+ float aRange[2] = {myRange[0], myRange[1]};
+ if(GetScaling() == VTK_SCALE_LOG10)
+ VISU_LookupTable::ComputeLogRange(theRange,aRange);
+ myContourFilter->GenerateValues(GetNbParts(),aRange);
+ Modified();
+ }
+}
+float VISU_IsoSurfacesPL::GetMin() {
+ return myRange[0];
+}
+float VISU_IsoSurfacesPL::GetMax() {
+ return myRange[1];
+}
+
+
+void VISU_IsoSurfacesPL::Init(){
+ VISU_ScalarMapPL::Init();
+
+ SetNbParts(10);
+ float aScalarRange[2];
+ GetSourceRange(aScalarRange);
+ SetRange(aScalarRange);
+}
+
+VISU_ScalarMapPL::THook* VISU_IsoSurfacesPL::DoHook(){
+ return myContourFilter->GetOutput();
+}
+
+
+void VISU_IsoSurfacesPL::Update(){
+ VISU::CellDataToPoint(myContourFilter,myInput,myFieldTransform);
+ SetMapScale();
+
+ VISU_ScalarMapPL::Update();
+}
+
+void VISU_IsoSurfacesPL::SetMapScale(float theMapScale){
+ VISU_ScalarMapPL::SetMapScale(theMapScale);
+
+ float aRange[2] = {GetMax() - theMapScale*(GetMax()-GetMin()), GetMax()};
+ float aNewRange[2] = {aRange[0], aRange[1]};
+ if(GetScaling() == VTK_SCALE_LOG10)
+ VISU_LookupTable::ComputeLogRange(aRange,aNewRange);
+ myContourFilter->GenerateValues(GetNbParts(),aNewRange);
+ Modified();
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_IsoSurfacesPL_HeaderFile
+#define VISU_IsoSurfacesPL_HeaderFile
+
+#include "VISU_ScalarMapPL.hxx"
+
+class vtkContourFilter;
+
+class VISU_IsoSurfacesPL : public VISU_ScalarMapPL{
+protected:
+ VISU_IsoSurfacesPL();
+ VISU_IsoSurfacesPL(const VISU_IsoSurfacesPL&);
+public:
+ vtkTypeMacro(VISU_IsoSurfacesPL,VISU_ScalarMapPL);
+ static VISU_IsoSurfacesPL* New();
+ virtual ~VISU_IsoSurfacesPL();
+ virtual void ShallowCopy(VISU_PipeLine *thePipeLine);
+
+ virtual int GetNbParts();
+ virtual void SetNbParts(int theNb = 10);
+
+ virtual void SetScaling(int theScaling = VTK_SCALE_LINEAR);
+ virtual void SetRange(float theRange[2]);
+ virtual float GetMin();
+ virtual float GetMax();
+
+public:
+ virtual void Init();
+ virtual void Update();
+ virtual THook* DoHook();
+ virtual void SetMapScale(float theMapScale = 1.0);
+
+protected:
+ int myNbParts;
+ float myRange[2];
+ vtkContourFilter *myContourFilter;
+};
+
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_LookupTable.cxx
+// Author : Vitaliy Smetannikov
+// Module : VISU
+
+#include "VISU_LookupTable.hxx"
+
+#include <vtkObjectFactory.h>
+#include <vtkBitArray.h>
+#include <math.h>
+
+using namespace std;
+
+VISU_LookupTable *VISU_LookupTable::New() {
+ vtkObject* ret = vtkObjectFactory::CreateInstance("VISU_LookupTable");
+ if(ret)
+ return (VISU_LookupTable*)ret;
+ return new VISU_LookupTable;
+}
+
+VISU_LookupTable::VISU_LookupTable(int sze, int ext)
+ : vtkLookupTable(sze, ext), myScale(1.0) {}
+
+int VISU_LookupTable::ComputeLogRange(float inRange[2], float outRange[2]){
+ if(inRange[0] >= inRange[1])
+ return -1;
+ if(0.0 <= inRange[0] && 0.0 < inRange[1]){
+ if(inRange[0] != 0.0)
+ outRange[0] = log10((double)inRange[0]);
+ else
+ outRange[0] = log10((double)inRange[1]*1.0E-6);
+ outRange[1] = log10((double)inRange[1]);
+ return 0;
+ }else if(inRange[0] < 0.0 && inRange[1] <= 0.0){
+ outRange[0] = log10((double)-inRange[0]);
+ outRange[1] = log10((double)-inRange[1]);
+ return 1;
+ }else
+ return -1;
+}
+
+unsigned char* VISU_LookupTable::MapValue(float v) {
+ if(GetScale() == VTK_SCALE_LOG10) {
+ float aLowBound = log10(this->TableRange[0]);
+ v = pow(10.0f,aLowBound + (v - aLowBound)*myScale);
+ return vtkLookupTable::MapValue(v);
+ }else{
+ v = this->TableRange[0] + (v - this->TableRange[0])*myScale;
+ return vtkLookupTable::MapValue(v);
+ }
+}
+
+// Apply log to value, with appropriate constraints.
+inline float VISU_ApplyLogScale(float v, float range[2],
+ float logRange[2])
+{
+ // is the range set for negative numbers?
+ if (range[0] < 0)
+ {
+ if (v < 0)
+ {
+ v = log10(-static_cast<double>(v));
+ }
+ else if (range[0] > range[1])
+ {
+ v = logRange[0];
+ }
+ else
+ {
+ v = logRange[1];
+ }
+ }
+ else
+ {
+ if (v > 0)
+ {
+ v = log10(static_cast<double>(v));
+ }
+ else if (range[0] < range[1])
+ {
+ v = logRange[0];
+ }
+ else
+ {
+ v = logRange[1];
+ }
+ }
+ return v;
+}
+
+// Apply shift/scale to the scalar value v and do table lookup.
+inline unsigned char *VISU_LinearLookup(float v,
+ unsigned char *table,
+ float maxIndex,
+ float shift, float scale)
+{
+ float findx = (v + shift)*scale;
+ if (findx < 0)
+ {
+ findx = 0;
+ }
+ if (findx > maxIndex)
+ {
+ findx = maxIndex;
+ }
+ return &table[4*static_cast<int>(findx)];
+ /* round
+ return &table[4*(int)(findx + 0.5f)];
+ */
+}
+
+// accelerate the mapping by copying the data in 32-bit chunks instead
+// of 8-bit chunks
+template<class T>
+void VISU_LookupTableMapData(vtkLookupTable *self, T *input,
+ unsigned char *output, int length,
+ int inIncr, int outFormat, float theMapScale)
+{
+ int i = length;
+ float *range = self->GetTableRange();
+ float maxIndex = self->GetNumberOfColors() - 1;
+ float shift, scale;
+ unsigned char *table = self->GetPointer(0);
+ unsigned char *cptr;
+ float alpha;
+
+ if ( (alpha=self->GetAlpha()) >= 1.0 ) //no blending required
+ {
+ if (self->GetScale() == VTK_SCALE_LOG10)
+ {
+ float val;
+ float logRange[2];
+ VISU_LookupTable::ComputeLogRange(range, logRange);
+ shift = -logRange[0];
+ if (logRange[1] <= logRange[0])
+ {
+ scale = VTK_LARGE_FLOAT;
+ }
+ else
+ {
+ scale = (maxIndex + 1)/(logRange[1] - logRange[0]);
+ }
+ /* correct scale
+ scale = maxIndex/(logRange[1] - logRange[0]);
+ */
+ if (outFormat == VTK_RGBA)
+ {
+ while (--i >= 0)
+ {
+ val = VISU_ApplyLogScale(*input, range, logRange);
+ cptr = VISU_LinearLookup(val, table, maxIndex, shift, scale*theMapScale);
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ input += inIncr;
+ }
+ }
+ else if (outFormat == VTK_RGB)
+ {
+ while (--i >= 0)
+ {
+ val = VISU_ApplyLogScale(*input, range, logRange);
+ cptr = VISU_LinearLookup(val, table, maxIndex, shift, scale*theMapScale);
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ input += inIncr;
+ }
+ }
+ else if (outFormat == VTK_LUMINANCE_ALPHA)
+ {
+ while (--i >= 0)
+ {
+ val = VISU_ApplyLogScale(*input, range, logRange);
+ cptr = VISU_LinearLookup(val, table, maxIndex, shift, scale*theMapScale);
+ *output++ = static_cast<unsigned char>(cptr[0]*0.30 + cptr[1]*0.59 +
+ cptr[2]*0.11 + 0.5);
+ *output++ = cptr[3];
+ input += inIncr;
+ }
+ }
+ else // outFormat == VTK_LUMINANCE
+ {
+ while (--i >= 0)
+ {
+ val = VISU_ApplyLogScale(*input, range, logRange);
+ cptr = VISU_LinearLookup(val, table, maxIndex, shift, scale*theMapScale);
+ *output++ = static_cast<unsigned char>(cptr[0]*0.30 + cptr[1]*0.59 +
+ cptr[2]*0.11 + 0.5);
+ input += inIncr;
+ }
+ }
+ }//if log scale
+
+ else //not log scale
+ {
+ shift = -range[0];
+ if (range[1] <= range[0])
+ {
+ scale = VTK_LARGE_FLOAT;
+ }
+ else
+ {
+ scale = (maxIndex + 1)/(range[1] - range[0]);
+ }
+ /* correct scale
+ scale = maxIndex/(range[1] - range[0]);
+ */
+
+ if (outFormat == VTK_RGBA)
+ {
+ while (--i >= 0)
+ {
+ cptr = VISU_LinearLookup(*input, table, maxIndex, shift, scale*theMapScale);
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ input += inIncr;
+ }
+ }
+ else if (outFormat == VTK_RGB)
+ {
+ while (--i >= 0)
+ {
+ cptr = VISU_LinearLookup(*input, table, maxIndex, shift, scale*theMapScale);
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ input += inIncr;
+ }
+ }
+ else if (outFormat == VTK_LUMINANCE_ALPHA)
+ {
+ while (--i >= 0)
+ {
+ cptr = VISU_LinearLookup(*input, table, maxIndex, shift, scale*theMapScale);
+ *output++ = static_cast<unsigned char>(cptr[0]*0.30 + cptr[1]*0.59 +
+ cptr[2]*0.11 + 0.5);
+ *output++ = cptr[3];
+ input += inIncr;
+ }
+ }
+ else // outFormat == VTK_LUMINANCE
+ {
+ while (--i >= 0)
+ {
+ cptr = VISU_LinearLookup(*input, table, maxIndex, shift, scale*theMapScale);
+ *output++ = static_cast<unsigned char>(cptr[0]*0.30 + cptr[1]*0.59 +
+ cptr[2]*0.11 + 0.5);
+ input += inIncr;
+ }
+ }
+ }//if not log lookup
+ }//if blending not needed
+
+ else //blend with the specified alpha
+ {
+ if (self->GetScale() == VTK_SCALE_LOG10)
+ {
+ float val;
+ float logRange[2];
+ VISU_LookupTable::ComputeLogRange(range, logRange);
+ shift = -logRange[0];
+ if (logRange[1] <= logRange[0])
+ {
+ scale = VTK_LARGE_FLOAT;
+ }
+ else
+ {
+ scale = (maxIndex + 1)/(logRange[1] - logRange[0]);
+ }
+ /* correct scale
+ scale = maxIndex/(logRange[1] - logRange[0]);
+ */
+ if (outFormat == VTK_RGBA)
+ {
+ while (--i >= 0)
+ {
+ val = VISU_ApplyLogScale(*input, range, logRange);
+ cptr = VISU_LinearLookup(val, table, maxIndex, shift, scale*theMapScale);
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = static_cast<unsigned char>((*cptr)*alpha); cptr++;
+ input += inIncr;
+ }
+ }
+ else if (outFormat == VTK_RGB)
+ {
+ while (--i >= 0)
+ {
+ val = VISU_ApplyLogScale(*input, range, logRange);
+ cptr = VISU_LinearLookup(val, table, maxIndex, shift, scale*theMapScale);
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ input += inIncr;
+ }
+ }
+ else if (outFormat == VTK_LUMINANCE_ALPHA)
+ {
+ while (--i >= 0)
+ {
+ val = VISU_ApplyLogScale(*input, range, logRange);
+ cptr = VISU_LinearLookup(val, table, maxIndex, shift, scale*theMapScale);
+ *output++ = static_cast<unsigned char>(cptr[0]*0.30 + cptr[1]*0.59 +
+ cptr[2]*0.11 + 0.5);
+ *output++ = static_cast<unsigned char>(alpha*cptr[3]);
+ input += inIncr;
+ }
+ }
+ else // outFormat == VTK_LUMINANCE
+ {
+ while (--i >= 0)
+ {
+ val = VISU_ApplyLogScale(*input, range, logRange);
+ cptr = VISU_LinearLookup(val, table, maxIndex, shift, scale*theMapScale);
+ *output++ = static_cast<unsigned char>(cptr[0]*0.30 + cptr[1]*0.59 +
+ cptr[2]*0.11 + 0.5);
+ input += inIncr;
+ }
+ }
+ }//log scale with blending
+
+ else //no log scale with blending
+ {
+ shift = -range[0];
+ if (range[1] <= range[0])
+ {
+ scale = VTK_LARGE_FLOAT;
+ }
+ else
+ {
+ scale = (maxIndex + 1)/(range[1] - range[0]);
+ }
+ /* correct scale
+ scale = maxIndex/(range[1] - range[0]);
+ */
+
+ if (outFormat == VTK_RGBA)
+ {
+ while (--i >= 0)
+ {
+ cptr = VISU_LinearLookup(*input, table, maxIndex, shift, scale);
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = static_cast<unsigned char>((*cptr)*alpha); cptr++;
+ input += inIncr;
+ }
+ }
+ else if (outFormat == VTK_RGB)
+ {
+ while (--i >= 0)
+ {
+ cptr = VISU_LinearLookup(*input, table, maxIndex, shift, scale);
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ *output++ = *cptr++;
+ input += inIncr;
+ }
+ }
+ else if (outFormat == VTK_LUMINANCE_ALPHA)
+ {
+ while (--i >= 0)
+ {
+ cptr = VISU_LinearLookup(*input, table, maxIndex, shift, scale);
+ *output++ = static_cast<unsigned char>(cptr[0]*0.30 + cptr[1]*0.59 +
+ cptr[2]*0.11 + 0.5);
+ *output++ = static_cast<unsigned char>(cptr[3]*alpha);
+ input += inIncr;
+ }
+ }
+ else // outFormat == VTK_LUMINANCE
+ {
+ while (--i >= 0)
+ {
+ cptr = VISU_LinearLookup(*input, table, maxIndex, shift, scale);
+ *output++ = static_cast<unsigned char>(cptr[0]*0.30 + cptr[1]*0.59 +
+ cptr[2]*0.11 + 0.5);
+ input += inIncr;
+ }
+ }
+ }//no log scale
+ }//alpha blending
+}
+
+// Although this is a relatively expensive calculation,
+// it is only done on the first render. Colors are cached
+// for subsequent renders.
+template<class T>
+void VISU_LookupTableMapMag(vtkLookupTable *self, T *input,
+ unsigned char *output, int length,
+ int inIncr, int outFormat, float theMapScale)
+{
+ double tmp, sum;
+ double *mag;
+ int i, j;
+
+ mag = new double[length];
+ for (i = 0; i < length; ++i)
+ {
+ sum = 0;
+ for (j = 0; j < inIncr; ++j)
+ {
+ tmp = (double)(*input);
+ sum += (tmp * tmp);
+ ++input;
+ }
+ mag[i] = sqrt(sum);
+ }
+
+ VISU_LookupTableMapData(self, mag, output, length, 1, outFormat, theMapScale);
+
+ delete [] mag;
+}
+
+
+void VISU_LookupTable::MapScalarsThroughTable2(void *input,
+ unsigned char *output,
+ int inputDataType,
+ int numberOfValues,
+ int inputIncrement,
+ int outputFormat)
+{
+ if (this->UseMagnitude && inputIncrement > 1)
+ {
+ switch (inputDataType)
+ {
+ case VTK_BIT:
+ vtkErrorMacro("Cannot comput magnitude of bit array.");
+ break;
+ case VTK_CHAR:
+ VISU_LookupTableMapMag(this,static_cast<char *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ return;
+ case VTK_UNSIGNED_CHAR:
+ VISU_LookupTableMapMag(this,static_cast<unsigned char *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ return;
+ case VTK_SHORT:
+ VISU_LookupTableMapMag(this,static_cast<short *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ return;
+ case VTK_UNSIGNED_SHORT:
+ VISU_LookupTableMapMag(this,static_cast<unsigned short *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ return;
+ case VTK_INT:
+ VISU_LookupTableMapMag(this,static_cast<int *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ return;
+ case VTK_UNSIGNED_INT:
+ VISU_LookupTableMapMag(this,static_cast<unsigned int *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ return;
+ case VTK_LONG:
+ VISU_LookupTableMapMag(this,static_cast<long *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ return;
+ case VTK_UNSIGNED_LONG:
+ VISU_LookupTableMapMag(this,static_cast<unsigned long *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ return;
+ case VTK_FLOAT:
+ VISU_LookupTableMapMag(this,static_cast<float *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ return;
+ case VTK_DOUBLE:
+ VISU_LookupTableMapMag(this,static_cast<double *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ return;
+ default:
+ vtkErrorMacro(<< "MapImageThroughTable: Unknown input ScalarType");
+ return;
+ }
+ }
+
+ switch (inputDataType)
+ {
+ case VTK_BIT:
+ {
+ vtkIdType i, id;
+ vtkBitArray *bitArray = vtkBitArray::New();
+ bitArray->SetVoidArray(input,numberOfValues,1);
+ vtkUnsignedCharArray *newInput = vtkUnsignedCharArray::New();
+ newInput->SetNumberOfValues(numberOfValues);
+ for (id=i=0; i<numberOfValues; i++, id+=inputIncrement)
+ {
+ newInput->SetValue(i, bitArray->GetValue(id));
+ }
+ VISU_LookupTableMapData(this,
+ static_cast<unsigned char*>(newInput->GetPointer(0)),
+ output,numberOfValues,
+ inputIncrement,outputFormat,myScale);
+ newInput->Delete();
+ bitArray->Delete();
+ }
+ break;
+
+ case VTK_CHAR:
+ VISU_LookupTableMapData(this,static_cast<char *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ break;
+
+ case VTK_UNSIGNED_CHAR:
+ VISU_LookupTableMapData(this,static_cast<unsigned char *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ break;
+
+ case VTK_SHORT:
+ VISU_LookupTableMapData(this,static_cast<short *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ break;
+
+ case VTK_UNSIGNED_SHORT:
+ VISU_LookupTableMapData(this,static_cast<unsigned short *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ break;
+
+ case VTK_INT:
+ VISU_LookupTableMapData(this,static_cast<int *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ break;
+
+ case VTK_UNSIGNED_INT:
+ VISU_LookupTableMapData(this,static_cast<unsigned int *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ break;
+
+ case VTK_LONG:
+ VISU_LookupTableMapData(this,static_cast<long *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ break;
+
+ case VTK_UNSIGNED_LONG:
+ VISU_LookupTableMapData(this,static_cast<unsigned long *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ break;
+
+ case VTK_FLOAT:
+ VISU_LookupTableMapData(this,static_cast<float *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ break;
+
+ case VTK_DOUBLE:
+ VISU_LookupTableMapData(this,static_cast<double *>(input),output,
+ numberOfValues,inputIncrement,outputFormat,myScale);
+ break;
+
+ default:
+ vtkErrorMacro(<< "MapImageThroughTable: Unknown input ScalarType");
+ return;
+ }
+}
+
--- /dev/null
+// Copyright (C) 2003 CEA/DEN, EDF R&D
+//
+//
+//
+// File : VISU_LookupTable.h
+// Author : Vitaliy Smetannikov
+// Module : VISU
+
+#ifndef VISU_LookupTable_H
+#define VISU_LookupTable_H
+
+#include <vtkLookupTable.h>
+
+class VISU_LookupTable: public vtkLookupTable {
+ public:
+ vtkTypeMacro(VISU_LookupTable,vtkLookupTable);
+ static VISU_LookupTable *New();
+
+ virtual void MapScalarsThroughTable2(void *input, unsigned char *output,
+ int inputDataType, int numberOfValues,
+ int inputIncrement, int outputIncrement);
+
+ float GetMapScale() { return myScale; }
+ void SetMapScale(float theScale = 1.0) { myScale = theScale; Modified(); }
+
+ static int ComputeLogRange(float inRange[2], float outRange[2]);
+ unsigned char *MapValue(float v);
+
+ protected:
+ VISU_LookupTable(int sze=256, int ext=256);
+ ~VISU_LookupTable() {};
+
+ float myScale;
+};
+#endif // VISU_LookupTable_H
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File: VISU_PipeLine.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_MeshPL.hxx"
+#include "SALOME_GeometryFilter.h"
+
+#include <vtkProperty.h>
+#include <vtkObjectFactory.h>
+#include <vtkDataSetMapper.h>
+#include <vtkUnstructuredGrid.h>
+
+vtkStandardNewMacro(VISU_MeshPL);
+
+VISU_MeshPL::VISU_MeshPL(){}
+
+void VISU_MeshPL::Build() {
+ myMapper->SetInput(myInput);
+}
+
+void VISU_MeshPL::Init(){
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_MeshPL_HeaderFile
+#define VISU_MeshPL_HeaderFile
+
+#include "VISU_PipeLine.hxx"
+
+class VISU_MeshPL : public VISU_PipeLine{
+protected:
+ VISU_MeshPL();
+ VISU_MeshPL(const VISU_MeshPL&);
+public:
+ vtkTypeMacro(VISU_MeshPL,VISU_PipeLine);
+ static VISU_MeshPL* New();
+
+public:
+ virtual void Build();
+ virtual void Init();
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File: VISU_PipeLine.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_PipeLine.hxx"
+
+#include <vtkObjectFactory.h>
+#include <vtkDataSetMapper.h>
+#include <vtkUnstructuredGrid.h>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+VISU_PipeLine::VISU_PipeLine(){
+ myMapper = TMapper::New();
+ myInput = NULL;
+}
+
+VISU_PipeLine::~VISU_PipeLine(){
+ myMapper->Delete();
+ SetInput(NULL);
+}
+
+void VISU_PipeLine::ShallowCopy(VISU_PipeLine *thePipeLine){
+ SetInput(thePipeLine->GetInput());
+ myMapper->ShallowCopy(thePipeLine->GetMapper());
+ Build();
+}
+
+void VISU_PipeLine::SetInput(TInput* theInput){
+ if (myInput != theInput){
+ if (myInput != NULL) myInput->UnRegister(this);
+ myInput = theInput;
+ if (myInput != NULL) {
+ myInput->Register(this);
+ myInput->Update();
+ }
+ Modified();
+ }
+}
+
+VISU_PipeLine::TMapper* VISU_PipeLine::GetMapper() {
+ if(myInput){
+ if(!myMapper->GetInput()){
+ myInput->Update();
+ Build();
+ }
+ myMapper->Update();
+ }
+ return myMapper;
+}
+
+void VISU_PipeLine::Update(){
+ myMapper->Update();
+}
+
+
+size_t VISU_PipeLine::CheckAvailableMemory(const size_t& theSize){
+ try{
+ char *aCheck = new char[theSize];
+ if(aCheck) delete [] aCheck;
+ if(MYDEBUG && aCheck == NULL)
+ cout<<"VISU_PipeLine::CheckAvailableMemory("<<theSize<<") - cannot alloacate such amount of memory!!!\n";
+ return aCheck != NULL;
+ //return theSize < 1000*1024*1024;
+ }catch(...){
+ if(MYDEBUG)
+ cout<<"VISU_PipeLine::CheckAvailableMemory("<<theSize<<") - unexpected exception was caught!!!\n";
+ }
+ return 0;
+}
+
+
+size_t VISU_PipeLine::GetAvailableMemory(size_t theSize, size_t theMinSize){
+ while(!CheckAvailableMemory(theSize))
+ if(theSize > theMinSize)
+ theSize /= 2;
+ else
+ return 0;
+ return theSize;
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_PipeLine_HeaderFile
+#define VISU_PipeLine_HeaderFile
+
+#include <string>
+#include <algorithm>
+#include <vtkObject.h>
+#include <vtkProperty.h>
+
+class vtkDataSetMapper;
+class vtkUnstructuredGrid;
+
+class VISU_PipeLine : public vtkObject{
+protected:
+ VISU_PipeLine();
+ VISU_PipeLine(const VISU_PipeLine&);
+public:
+ vtkTypeMacro(VISU_PipeLine,vtkObject);
+ virtual ~VISU_PipeLine();
+ virtual void ShallowCopy(VISU_PipeLine *thePipeLine);
+
+public:
+ typedef vtkUnstructuredGrid TInput;
+ virtual void SetInput(TInput* theInput);
+ virtual TInput* GetInput() { return myInput;}
+
+ typedef vtkDataSetMapper TMapper;
+ virtual TMapper* GetMapper();
+
+ virtual void Init() = 0;
+ virtual void Update();
+
+ static size_t CheckAvailableMemory(const size_t& theSize);
+ static size_t GetAvailableMemory(size_t theSize = 16*1024*1024,
+ size_t theMinSize = 1024*1024);
+protected:
+ virtual void Build() = 0;
+
+ TInput *myInput;
+ TMapper *myMapper;
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#include "VISU_PipeLineUtils.hxx"
+
+void VISU::Mul(const float A[3], float b, float C[3]){ // A*b;
+ for(int i = 0; i < 3; i++) C[i] = A[i]*b;
+}
+
+void VISU::Sub(const float A[3], const float B[3], float C[3]){ //A-B
+ for(int i = 0; i < 3; i++) C[i] = A[i] - B[i];
+}
+
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_PipeLineUtils_HeaderFile
+#define VISU_PipeLineUtils_HeaderFile
+
+#include "VISU_FieldTransform.hxx"
+#include "VISU_LookupTable.hxx"
+#include "VISU_Extractor.hxx"
+
+#include <vtkProperty.h>
+#include <vtkObjectFactory.h>
+#include <vtkDataSetMapper.h>
+#include <vtkUnstructuredGrid.h>
+
+#include <vtkCellDataToPointData.h>
+#include <vtkCellCenters.h>
+#include <vtkPointData.h>
+#include <vtkCellData.h>
+#include <vtkPolyData.h>
+
+#include <vtkMath.h>
+
+namespace VISU{
+ void Mul(const float A[3], float b, float C[3]); // C = A * b
+ void Sub(const float A[3], const float B[3], float C[3]); // C = A - B
+
+ template<class TItem> void CellDataToPoint(TItem* theTItem, vtkDataSet* theDataSet,
+ VISU_FieldTransform *theFieldTransform)
+ {
+ if(theDataSet->GetCellData()->GetNumberOfArrays()){
+ vtkCellDataToPointData *aFilter = vtkCellDataToPointData::New();
+ aFilter->SetInput(theFieldTransform->GetUnstructuredGridOutput());
+ aFilter->PassCellDataOn();
+ theTItem->SetInput(aFilter->GetUnstructuredGridOutput());
+ aFilter->Register(theTItem);
+ aFilter->Delete();
+ }else
+ theTItem->SetInput(theFieldTransform->GetUnstructuredGridOutput());
+ }
+
+ template<class TItem> void ToCellCenters(TItem* theTItem, vtkDataSet* theDataSet,
+ VISU_FieldTransform *theFieldTransform)
+ {
+ if(theDataSet->GetCellData()->GetNumberOfArrays()){
+ vtkCellCenters *aCenters = vtkCellCenters::New(); // for vectors on cells
+ aCenters->SetInput(theFieldTransform->GetUnstructuredGridOutput());
+ aCenters->VertexCellsOn();
+ theTItem->SetInput(aCenters->GetOutput());
+ aCenters->Register(theTItem);
+ aCenters->Delete();
+ }else
+ theTItem->SetInput(theFieldTransform->GetUnstructuredGridOutput());
+ }
+}
+
+#endif
+
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#include "VISU_ScalarBarActor.hxx"
+
+#include <vtkPolyDataMapper2D.h>
+#include <vtkCellArray.h>
+#include <vtkCellData.h>
+#include <vtkObjectFactory.h>
+#include <vtkPolyData.h>
+#include <vtkPolyDataMapper2D.h>
+#include <vtkScalarsToColors.h>
+#include <vtkTextMapper.h>
+#include <vtkTextProperty.h>
+#include <vtkViewport.h>
+#include <vtkWindow.h>
+#include <vtkLogLookupTable.h>
+
+using namespace std;
+
+vtkCxxRevisionMacro(VISU_ScalarBarActor, "$Revision$");
+
+vtkCxxSetObjectMacro(VISU_ScalarBarActor,LookupTable,VISU_LookupTable);
+vtkCxxSetObjectMacro(VISU_ScalarBarActor,LabelTextProperty,vtkTextProperty);
+vtkCxxSetObjectMacro(VISU_ScalarBarActor,TitleTextProperty,vtkTextProperty);
+
+//------------------------------------------------------------------------------
+VISU_ScalarBarActor* VISU_ScalarBarActor::New(){
+ vtkObject* ret = vtkObjectFactory::CreateInstance("VISU_ScalarBarActor");
+ if(ret)
+ return (VISU_ScalarBarActor*)ret;
+ return new VISU_ScalarBarActor;
+}
+
+VISU_ScalarBarActor::VISU_ScalarBarActor()
+{
+ this->LookupTable = NULL;
+ this->Position2Coordinate->SetValue(0.17, 0.8);
+
+ this->PositionCoordinate->SetCoordinateSystemToNormalizedViewport();
+ this->PositionCoordinate->SetValue(0.82,0.1);
+
+ this->MaximumNumberOfColors = 64;
+ this->NumberOfLabels = 5;
+ this->NumberOfLabelsBuilt = 0;
+ this->Orientation = VTK_ORIENT_VERTICAL;
+ this->Title = NULL;
+
+ this->LabelTextProperty = vtkTextProperty::New();
+ this->LabelTextProperty->SetFontSize(12);
+ this->LabelTextProperty->SetBold(1);
+ this->LabelTextProperty->SetItalic(1);
+ this->LabelTextProperty->SetShadow(1);
+ this->LabelTextProperty->SetFontFamilyToArial();
+
+ this->TitleTextProperty = vtkTextProperty::New();
+ this->TitleTextProperty->ShallowCopy(this->LabelTextProperty);
+
+ this->LabelFormat = new char[8];
+ sprintf(this->LabelFormat,"%s","%-#6.3g");
+
+ this->TitleMapper = vtkTextMapper::New();
+ this->TitleActor = vtkActor2D::New();
+ this->TitleActor->SetMapper(this->TitleMapper);
+ this->TitleActor->GetPositionCoordinate()->
+ SetReferenceCoordinate(this->PositionCoordinate);
+
+ this->TextMappers = NULL;
+ this->TextActors = NULL;
+
+ this->ScalarBar = vtkPolyData::New();
+ this->ScalarBarMapper = vtkPolyDataMapper2D::New();
+ this->ScalarBarMapper->SetInput(this->ScalarBar);
+ this->ScalarBarActor = vtkActor2D::New();
+ this->ScalarBarActor->SetMapper(this->ScalarBarMapper);
+ this->ScalarBarActor->GetPositionCoordinate()->
+ SetReferenceCoordinate(this->PositionCoordinate);
+ this->LastOrigin[0] = 0;
+ this->LastOrigin[1] = 0;
+ this->LastSize[0] = 0;
+ this->LastSize[1] = 0;
+}
+
+void VISU_ScalarBarActor::ReleaseGraphicsResources(vtkWindow *win)
+{
+ this->TitleActor->ReleaseGraphicsResources(win);
+ if (this->TextMappers != NULL )
+ {
+ for (int i=0; i < this->NumberOfLabelsBuilt; i++)
+ {
+ this->TextActors[i]->ReleaseGraphicsResources(win);
+ }
+ }
+ this->ScalarBarActor->ReleaseGraphicsResources(win);
+}
+
+VISU_ScalarBarActor::~VISU_ScalarBarActor()
+{
+ if (this->LabelFormat)
+ {
+ delete [] this->LabelFormat;
+ this->LabelFormat = NULL;
+ }
+
+ this->TitleMapper->Delete();
+ this->TitleActor->Delete();
+
+ if (this->TextMappers != NULL )
+ {
+ for (int i=0; i < this->NumberOfLabelsBuilt; i++)
+ {
+ this->TextMappers[i]->Delete();
+ this->TextActors[i]->Delete();
+ }
+ delete [] this->TextMappers;
+ delete [] this->TextActors;
+ }
+
+ this->ScalarBar->Delete();
+ this->ScalarBarMapper->Delete();
+ this->ScalarBarActor->Delete();
+
+ if (this->Title)
+ {
+ delete [] this->Title;
+ this->Title = NULL;
+ }
+
+ this->SetLookupTable(NULL);
+ this->SetLabelTextProperty(NULL);
+ this->SetTitleTextProperty(NULL);
+}
+
+int VISU_ScalarBarActor::RenderOverlay(vtkViewport *viewport)
+{
+ int renderedSomething = 0;
+ int i;
+
+ // Everything is built, just have to render
+ if (this->Title != NULL)
+ {
+ renderedSomething += this->TitleActor->RenderOverlay(viewport);
+ }
+ this->ScalarBarActor->RenderOverlay(viewport);
+ if( this->TextActors == NULL)
+ {
+ vtkWarningMacro(<<"Need a mapper to render a scalar bar");
+ return renderedSomething;
+ }
+
+ for (i=0; i<this->NumberOfLabels; i++)
+ {
+ renderedSomething += this->TextActors[i]->RenderOverlay(viewport);
+ }
+
+ renderedSomething = (renderedSomething > 0)?(1):(0);
+
+ return renderedSomething;
+}
+
+int VISU_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
+{
+ int renderedSomething = 0;
+ int i;
+ int size[2];
+
+ if (!this->LookupTable)
+ {
+ vtkWarningMacro(<<"Need a mapper to render a scalar bar");
+ return 0;
+ }
+
+ if (!this->TitleTextProperty)
+ {
+ vtkErrorMacro(<<"Need title text property to render a scalar bar");
+ return 0;
+ }
+
+ if (!this->LabelTextProperty)
+ {
+ vtkErrorMacro(<<"Need label text property to render a scalar bar");
+ return 0;
+ }
+
+ // Check to see whether we have to rebuild everything
+ int positionsHaveChanged = 0;
+ if (viewport->GetMTime() > this->BuildTime ||
+ (viewport->GetVTKWindow() &&
+ viewport->GetVTKWindow()->GetMTime() > this->BuildTime))
+ {
+ // if the viewport has changed we may - or may not need
+ // to rebuild, it depends on if the projected coords chage
+ int *barOrigin;
+ barOrigin = this->PositionCoordinate->GetComputedViewportValue(viewport);
+ size[0] =
+ this->Position2Coordinate->GetComputedViewportValue(viewport)[0] -
+ barOrigin[0];
+ size[1] =
+ this->Position2Coordinate->GetComputedViewportValue(viewport)[1] -
+ barOrigin[1];
+ if (this->LastSize[0] != size[0] ||
+ this->LastSize[1] != size[1] ||
+ this->LastOrigin[0] != barOrigin[0] ||
+ this->LastOrigin[1] != barOrigin[1])
+ {
+ positionsHaveChanged = 1;
+ }
+ }
+
+ // Check to see whether we have to rebuild everything
+ if (positionsHaveChanged ||
+ this->GetMTime() > this->BuildTime ||
+ this->LookupTable->GetMTime() > this->BuildTime ||
+ this->LabelTextProperty->GetMTime() > this->BuildTime ||
+ this->TitleTextProperty->GetMTime() > this->BuildTime)
+ {
+
+ // Delete previously constructed objects
+ //
+ if (this->TextMappers != NULL )
+ {
+ for (i=0; i < this->NumberOfLabelsBuilt; i++)
+ {
+ this->TextMappers[i]->Delete();
+ this->TextActors[i]->Delete();
+ }
+ delete [] this->TextMappers;
+ delete [] this->TextActors;
+ }
+
+ // Build scalar bar object; determine its type
+ //
+ VISU_LookupTable *lut = this->LookupTable; //SALOME specific
+ int isLogTable = lut->GetScale() == VTK_SCALE_LOG10;
+
+ // we hard code how many steps to display
+ int numColors = this->MaximumNumberOfColors;
+ float *range = lut->GetRange();
+
+ int numPts = 2*(numColors + 1);
+ vtkPoints *pts = vtkPoints::New();
+ pts->SetNumberOfPoints(numPts);
+ vtkCellArray *polys = vtkCellArray::New();
+ polys->Allocate(polys->EstimateSize(numColors,4));
+ vtkUnsignedCharArray *colors = vtkUnsignedCharArray::New();
+ colors->SetNumberOfComponents(3);
+ colors->SetNumberOfTuples(numColors);
+
+ this->ScalarBarActor->SetProperty(this->GetProperty());
+ this->ScalarBar->Initialize();
+ this->ScalarBar->SetPoints(pts);
+ this->ScalarBar->SetPolys(polys);
+ this->ScalarBar->GetCellData()->SetScalars(colors);
+ pts->Delete(); polys->Delete(); colors->Delete();
+
+ // get the viewport size in display coordinates
+ int *barOrigin, barWidth, barHeight;
+ barOrigin = this->PositionCoordinate->GetComputedViewportValue(viewport);
+ size[0] =
+ this->Position2Coordinate->GetComputedViewportValue(viewport)[0] -
+ barOrigin[0];
+ size[1] =
+ this->Position2Coordinate->GetComputedViewportValue(viewport)[1] -
+ barOrigin[1];
+ this->LastOrigin[0] = barOrigin[0];
+ this->LastOrigin[1] = barOrigin[1];
+ this->LastSize[0] = size[0];
+ this->LastSize[1] = size[1];
+
+ // Update all the composing objects
+ this->TitleActor->SetProperty(this->GetProperty());
+ this->TitleMapper->SetInput(this->Title);
+ if (this->TitleTextProperty->GetMTime() > this->BuildTime)
+ {
+ // Shallow copy here so that the size of the title prop is not affected
+ // by the automatic adjustment of its text mapper's size (i.e. its
+ // mapper's text property is identical except for the font size
+ // which will be modified later). This allows text actors to
+ // share the same text property, and in that case specifically allows
+ // the title and label text prop to be the same.
+ this->TitleMapper->GetTextProperty()->ShallowCopy(this->TitleTextProperty);
+ this->TitleMapper->GetTextProperty()->SetJustificationToCentered();
+ }
+
+ // find the best size for the title font
+ int titleSize[2];
+ this->SizeTitle(titleSize, size, viewport);
+
+ // find the best size for the ticks
+ int labelSize[2];
+ this->AllocateAndSizeLabels(labelSize, size, viewport,range);
+ this->NumberOfLabelsBuilt = this->NumberOfLabels;
+
+ // generate points
+ float x[3]; x[2] = 0.0;
+ float delta, val;
+ if ( this->Orientation == VTK_ORIENT_VERTICAL )
+ {
+ barWidth = size[0] - 4 - labelSize[0];
+ barHeight = (int)(0.86*size[1]);
+ delta=(float)barHeight/numColors;
+ for (i=0; i<numPts/2; i++)
+ {
+ x[0] = 0;
+ x[1] = i*delta;
+ pts->SetPoint(2*i,x);
+ x[0] = barWidth;
+ pts->SetPoint(2*i+1,x);
+ }
+ }
+ else
+ {
+ barWidth = size[0];
+ barHeight = (int)(0.4*size[1]);
+ delta=(float)barWidth/numColors;
+ for (i=0; i<numPts/2; i++)
+ {
+ x[0] = i*delta;
+ x[1] = barHeight;
+ pts->SetPoint(2*i,x);
+ x[1] = 0;
+ pts->SetPoint(2*i+1,x);
+ }
+ }
+
+ //polygons & cell colors
+ unsigned char *rgba, *rgb;
+ vtkIdType ptIds[4];
+ for (i=0; i<numColors; i++)
+ {
+ ptIds[0] = 2*i;
+ ptIds[1] = ptIds[0] + 1;
+ ptIds[2] = ptIds[1] + 2;
+ ptIds[3] = ptIds[0] + 2;
+ polys->InsertNextCell(4,ptIds);
+
+ if ( isLogTable ){ //SALOME specific
+ float rgbval = log10(range[0]) +
+ i*(log10(range[1])-log10(range[0]))/(numColors -1);
+ rgba = lut->MapValue(rgbval);
+ }else{
+ rgba = lut->MapValue(range[0] + (range[1] - range[0])*
+ ((float)i /(numColors-1.0)));
+ }
+
+ rgb = colors->GetPointer(3*i); //write into array directly
+ rgb[0] = rgba[0];
+ rgb[1] = rgba[1];
+ rgb[2] = rgba[2];
+ }
+
+ // Now position everything properly
+ //
+ if (this->Orientation == VTK_ORIENT_VERTICAL)
+ {
+ int sizeTextData[2];
+
+ // center the title
+ this->TitleActor->SetPosition(size[0]/2, 0.9*size[1]);
+
+ for (i=0; i < this->NumberOfLabels; i++)
+ {
+ val = (float)i/(this->NumberOfLabels-1) *barHeight;
+ this->TextMappers[i]->GetSize(viewport,sizeTextData);
+ this->TextMappers[i]->GetTextProperty()->SetJustificationToLeft();
+ this->TextActors[i]->SetPosition(barWidth+3,
+ val - sizeTextData[1]/2);
+ }
+ }
+ else
+ {
+ this->TitleActor->SetPosition(size[0]/2,
+ barHeight + labelSize[1] + 0.1*size[1]);
+ for (i=0; i < this->NumberOfLabels; i++)
+ {
+ this->TextMappers[i]->GetTextProperty()->SetJustificationToCentered();
+ val = (float)i/(this->NumberOfLabels-1) * barWidth;
+ this->TextActors[i]->SetPosition(val, barHeight + 0.05*size[1]);
+ }
+ }
+
+ this->BuildTime.Modified();
+ }
+
+ // Everything is built, just have to render
+ if (this->Title != NULL)
+ {
+ renderedSomething += this->TitleActor->RenderOpaqueGeometry(viewport);
+ }
+ this->ScalarBarActor->RenderOpaqueGeometry(viewport);
+ for (i=0; i<this->NumberOfLabels; i++)
+ {
+ renderedSomething += this->TextActors[i]->RenderOpaqueGeometry(viewport);
+ }
+
+ renderedSomething = (renderedSomething > 0)?(1):(0);
+
+ return renderedSomething;
+}
+
+void VISU_ScalarBarActor::PrintSelf(ostream& os, vtkIndent indent)
+{
+ this->Superclass::PrintSelf(os,indent);
+
+ if ( this->LookupTable )
+ {
+ os << indent << "Lookup Table:\n";
+ this->LookupTable->PrintSelf(os,indent.GetNextIndent());
+ }
+ else
+ {
+ os << indent << "Lookup Table: (none)\n";
+ }
+
+ if (this->TitleTextProperty)
+ {
+ os << indent << "Title Text Property:\n";
+ this->TitleTextProperty->PrintSelf(os,indent.GetNextIndent());
+ }
+ else
+ {
+ os << indent << "Title Text Property: (none)\n";
+ }
+
+ if (this->LabelTextProperty)
+ {
+ os << indent << "Label Text Property:\n";
+ this->LabelTextProperty->PrintSelf(os,indent.GetNextIndent());
+ }
+ else
+ {
+ os << indent << "Label Text Property: (none)\n";
+ }
+
+ os << indent << "Title: " << (this->Title ? this->Title : "(none)") << "\n";
+ os << indent << "Maximum Number Of Colors: "
+ << this->MaximumNumberOfColors << "\n";
+ os << indent << "Number Of Labels: " << this->NumberOfLabels << "\n";
+ os << indent << "Number Of Labels Built: " << this->NumberOfLabelsBuilt << "\n";
+
+ os << indent << "Orientation: ";
+ if ( this->Orientation == VTK_ORIENT_HORIZONTAL )
+ {
+ os << "Horizontal\n";
+ }
+ else
+ {
+ os << "Vertical\n";
+ }
+
+ os << indent << "Label Format: " << this->LabelFormat << "\n";
+}
+
+void VISU_ScalarBarActor::ShallowCopy(vtkProp *prop)
+{
+ VISU_ScalarBarActor *a = VISU_ScalarBarActor::SafeDownCast(prop);
+ if ( a != NULL )
+ {
+ this->SetPosition2(a->GetPosition2());
+ this->SetLookupTable(a->GetLookupTable());
+ this->SetMaximumNumberOfColors(a->GetMaximumNumberOfColors());
+ this->SetOrientation(a->GetOrientation());
+ this->SetLabelTextProperty(a->GetLabelTextProperty());
+ this->SetTitleTextProperty(a->GetTitleTextProperty());
+ this->SetLabelFormat(a->GetLabelFormat());
+ this->SetTitle(a->GetTitle());
+ this->GetPositionCoordinate()->SetCoordinateSystem(
+ a->GetPositionCoordinate()->GetCoordinateSystem());
+ this->GetPositionCoordinate()->SetValue(
+ a->GetPositionCoordinate()->GetValue());
+ this->GetPosition2Coordinate()->SetCoordinateSystem(
+ a->GetPosition2Coordinate()->GetCoordinateSystem());
+ this->GetPosition2Coordinate()->SetValue(
+ a->GetPosition2Coordinate()->GetValue());
+ }
+
+ // Now do superclass
+ this->vtkActor2D::ShallowCopy(prop);
+}
+
+void VISU_ScalarBarActor::AllocateAndSizeLabels(int *labelSize, int *size,
+ vtkViewport *viewport,
+ float *range)
+{
+ labelSize[0] = labelSize[1] = 0;
+
+ this->TextMappers = new vtkTextMapper * [this->NumberOfLabels];
+ this->TextActors = new vtkActor2D * [this->NumberOfLabels];
+
+ char string[512];
+
+ float val;
+ int i;
+
+ // TODO: this should be optimized, maybe by keeping a list of
+ // allocated mappers, in order to avoid creation/destruction of
+ // their underlying text properties (i.e. each time a mapper is
+ // created, text properties are created and shallow-assigned a font size
+ // which value might be "far" from the target font size).
+
+ VISU_LookupTable *lut = this->LookupTable; //SALOME specific
+ int isLogTable = lut->GetScale() == VTK_SCALE_LOG10;
+
+ for (i=0; i < this->NumberOfLabels; i++)
+ {
+ this->TextMappers[i] = vtkTextMapper::New();
+
+ if(isLogTable && 0 < i && i < this->NumberOfLabels - 1){ // SALOME specific
+ float lval = log10(range[0]) + (float)i/(this->NumberOfLabels-1) *
+ (log10(range[1])-log10(range[0]));
+ val = pow(10,lval);
+ }else{
+ val = range[0] + (float)i/(this->NumberOfLabels-1) * (range[1]-range[0]);
+ }
+ sprintf(string, this->LabelFormat, val);
+ this->TextMappers[i]->SetInput(string);
+
+ // Shallow copy here so that the size of the label prop is not affected
+ // by the automatic adjustment of its text mapper's size (i.e. its
+ // mapper's text property is identical except for the font size
+ // which will be modified later). This allows text actors to
+ // share the same text property, and in that case specifically allows
+ // the title and label text prop to be the same.
+ this->TextMappers[i]->GetTextProperty()->ShallowCopy(
+ this->LabelTextProperty);
+
+ this->TextActors[i] = vtkActor2D::New();
+ this->TextActors[i]->SetMapper(this->TextMappers[i]);
+ this->TextActors[i]->SetProperty(this->GetProperty());
+ this->TextActors[i]->GetPositionCoordinate()->
+ SetReferenceCoordinate(this->PositionCoordinate);
+ }
+
+ if (this->NumberOfLabels)
+ {
+ int targetWidth, targetHeight;
+
+ if ( this->Orientation == VTK_ORIENT_VERTICAL )
+ {
+ targetWidth = (int)(0.6*size[0]);
+ targetHeight = (int)(0.86*size[1]/this->NumberOfLabels);
+ }
+ else
+ {
+ targetWidth = (int)(size[0]*0.8/this->NumberOfLabels);
+ targetHeight = (int)(0.25*size[1]);
+ }
+
+ vtkTextMapper::SetMultipleConstrainedFontSize(viewport,
+ targetWidth,
+ targetHeight,
+ this->TextMappers,
+ this->NumberOfLabels,
+ labelSize);
+ }
+}
+
+void VISU_ScalarBarActor::SizeTitle(int *titleSize, int *size,
+ vtkViewport *viewport)
+{
+ titleSize[0] = titleSize[1] = 0;
+
+ if (this->Title == NULL || !strlen(this->Title))
+ {
+ return;
+ }
+
+ int targetWidth, targetHeight;
+
+ targetWidth = size[0];
+ if ( this->Orientation == VTK_ORIENT_VERTICAL )
+ {
+ targetHeight = (int)(0.1*size[1]);
+ }
+ else
+ {
+ targetHeight = (int)(0.25*size[1]);
+ }
+
+ this->TitleMapper->SetConstrainedFontSize(
+ viewport, targetWidth, targetHeight);
+
+ this->TitleMapper->GetSize(viewport, titleSize);
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_ScalarBarActor_HeaderFile
+#define VISU_ScalarBarActor_HeaderFile
+
+#include "VISU_LookupTable.hxx"
+
+#include <vtkActor2D.h>
+
+class vtkPolyData;
+class vtkPolyDataMapper2D;
+class vtkScalarsToColors;
+class vtkTextMapper;
+class vtkTextProperty;
+
+#ifndef VTK_ORIENT_HORIZONTAL
+#define VTK_ORIENT_HORIZONTAL 0
+#endif
+
+#ifndef VTK_ORIENT_VERTICAL
+#define VTK_ORIENT_VERTICAL 1
+#endif
+
+class VISU_ScalarBarActor : public vtkActor2D
+{
+public:
+ vtkTypeRevisionMacro(VISU_ScalarBarActor,vtkActor2D);
+ void PrintSelf(ostream& os, vtkIndent indent);
+
+ // Description:
+ // Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label
+ // format, no title, and vertical orientation. The initial scalar bar
+ // size is (0.05 x 0.8) of the viewport size.
+ static VISU_ScalarBarActor *New();
+
+ // Description:
+ // Draw the scalar bar and annotation text to the screen.
+ int RenderOpaqueGeometry(vtkViewport* viewport);
+ int RenderTranslucentGeometry(vtkViewport*) { return 0; };
+ int RenderOverlay(vtkViewport* viewport);
+
+ // Description:
+ // Release any graphics resources that are being consumed by this actor.
+ // The parameter window could be used to determine which graphic
+ // resources to release.
+ virtual void ReleaseGraphicsResources(vtkWindow *);
+
+ // Description:
+ // Set/Get the vtkLookupTable to use. The lookup table specifies the number
+ // of colors to use in the table (if not overridden), as well as the scalar
+ // range.
+ virtual void SetLookupTable(VISU_LookupTable*);
+ vtkGetObjectMacro(LookupTable,VISU_LookupTable);
+
+ // Description:
+ // Set/Get the maximum number of scalar bar segments to show. This may
+ // differ from the number of colors in the lookup table, in which case
+ // the colors are samples from the lookup table.
+ vtkSetClampMacro(MaximumNumberOfColors, int, 2, VTK_LARGE_INTEGER);
+ vtkGetMacro(MaximumNumberOfColors, int);
+
+ // Description:
+ // Set/Get the number of annotation labels to show.
+ vtkSetClampMacro(NumberOfLabels, int, 0, 64);
+ vtkGetMacro(NumberOfLabels, int);
+
+ // Description:
+ // Control the orientation of the scalar bar.
+ vtkSetClampMacro(Orientation,int,VTK_ORIENT_HORIZONTAL, VTK_ORIENT_VERTICAL);
+ vtkGetMacro(Orientation, int);
+ void SetOrientationToHorizontal()
+ {this->SetOrientation(VTK_ORIENT_HORIZONTAL);};
+ void SetOrientationToVertical() {this->SetOrientation(VTK_ORIENT_VERTICAL);};
+
+ // Description:
+ // Set/Get the title text property.
+ virtual void SetTitleTextProperty(vtkTextProperty *p);
+ vtkGetObjectMacro(TitleTextProperty,vtkTextProperty);
+
+ // Description:
+ // Set/Get the labels text property.
+ virtual void SetLabelTextProperty(vtkTextProperty *p);
+ vtkGetObjectMacro(LabelTextProperty,vtkTextProperty);
+
+ // Description:
+ // Set/Get the format with which to print the labels on the scalar
+ // bar.
+ vtkSetStringMacro(LabelFormat);
+ vtkGetStringMacro(LabelFormat);
+
+ // Description:
+ // Set/Get the title of the scalar bar actor,
+ vtkSetStringMacro(Title);
+ vtkGetStringMacro(Title);
+
+ // Description:
+ // Shallow copy of a scalar bar actor. Overloads the virtual vtkProp method.
+ void ShallowCopy(vtkProp *prop);
+
+protected:
+ VISU_ScalarBarActor();
+ ~VISU_ScalarBarActor();
+
+ VISU_LookupTable *LookupTable;
+ vtkTextProperty *TitleTextProperty;
+ vtkTextProperty *LabelTextProperty;
+
+ int MaximumNumberOfColors;
+ int NumberOfLabels;
+ int NumberOfLabelsBuilt;
+ int Orientation;
+ char *Title;
+ char *LabelFormat;
+
+ vtkTextMapper **TextMappers;
+ virtual void AllocateAndSizeLabels(int *labelSize, int *size,
+ vtkViewport *viewport, float *range);
+
+private:
+ vtkTextMapper *TitleMapper;
+ vtkActor2D *TitleActor;
+
+ vtkActor2D **TextActors;
+
+ vtkPolyData *ScalarBar;
+ vtkPolyDataMapper2D *ScalarBarMapper;
+ vtkActor2D *ScalarBarActor;
+
+ vtkTimeStamp BuildTime;
+ int LastSize[2];
+ int LastOrigin[2];
+
+ void SizeTitle(int *titleSize, int *size, vtkViewport *viewport);
+
+private:
+ VISU_ScalarBarActor(const VISU_ScalarBarActor&); // Not implemented.
+ void operator=(const VISU_ScalarBarActor&); // Not implemented.
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File: VISU_PipeLine.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_ScalarMapPL.hxx"
+#include "VISU_PipeLineUtils.hxx"
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+vtkStandardNewMacro(VISU_ScalarMapPL);
+
+
+VISU_ScalarMapPL::VISU_ScalarMapPL(){
+ myFieldTransform = VISU_FieldTransform::New();
+
+ myMapperTable = VISU_LookupTable::New();
+ myMapperTable->SetScale(VTK_SCALE_LINEAR);
+ myMapperTable->SetHueRange(0.667,0.0);
+
+ myBarTable = VISU_LookupTable::New();
+ myBarTable->SetScale(VTK_SCALE_LINEAR);
+ myBarTable->SetHueRange(0.667,0.0);
+
+ myExtractor = VISU_Extractor::New();
+}
+
+
+VISU_ScalarMapPL::~VISU_ScalarMapPL(){
+ myFieldTransform->Delete();
+ myMapperTable->Delete();;
+ myBarTable->Delete();
+ myExtractor->Delete();
+}
+
+
+void VISU_ScalarMapPL::ShallowCopy(VISU_PipeLine *thePipeLine){
+ VISU_PipeLine::ShallowCopy(thePipeLine);
+ if(VISU_ScalarMapPL *aPipeLine = dynamic_cast<VISU_ScalarMapPL*>(thePipeLine)){
+ SetScalarRange(aPipeLine->GetScalarRange());
+ SetScalarMode(aPipeLine->GetScalarMode());
+ SetNbColors(aPipeLine->GetNbColors());
+ SetScaling(aPipeLine->GetScaling());
+ //Update();
+ }
+}
+
+
+int VISU_ScalarMapPL::GetScalarMode(){
+ return myExtractor->GetScalarMode();
+}
+void VISU_ScalarMapPL::SetScalarMode(int theScalarMode){
+ myExtractor->SetScalarMode(theScalarMode);
+ Modified();
+}
+
+
+int VISU_ScalarMapPL::GetScaling() {
+ return myBarTable->GetScale();
+}
+void VISU_ScalarMapPL::SetScaling(int theScaling) {
+ myBarTable->SetScale(theScaling);
+ if(theScaling == VTK_SCALE_LOG10)
+ myFieldTransform->SetScalarTransform(&(VISU_FieldTransform::Log10));
+ else
+ myFieldTransform->SetScalarTransform(&(VISU_FieldTransform::Ident));
+ Modified();
+}
+
+
+float* VISU_ScalarMapPL::GetScalarRange() {
+ return myFieldTransform->GetScalarRange();
+}
+void VISU_ScalarMapPL::SetScalarRange(float theRange[2]){
+ myFieldTransform->SetScalarRange(theRange);
+ myBarTable->SetRange(theRange);
+ Modified();
+}
+void VISU_ScalarMapPL::SetScalarMin(float theValue){
+ float aScalarRange[2] = {theValue, GetScalarRange()[1]};
+ SetScalarRange(aScalarRange);
+}
+void VISU_ScalarMapPL::SetScalarMax(float theValue){
+ float aScalarRange[2] = {GetScalarRange()[0], theValue};
+ SetScalarRange(aScalarRange);
+}
+
+
+void VISU_ScalarMapPL::SetNbColors(int theNbColors) {
+ myMapperTable->SetNumberOfColors(theNbColors);
+ myBarTable->SetNumberOfColors(theNbColors);
+ Modified();
+}
+int VISU_ScalarMapPL::GetNbColors() {
+ return myMapperTable->GetNumberOfColors();
+}
+
+
+VISU_ScalarMapPL::THook* VISU_ScalarMapPL::DoHook(){
+ myMapper->SetColorModeToMapScalars();
+ myMapper->ScalarVisibilityOn();
+ return myFieldTransform->GetUnstructuredGridOutput();
+}
+
+
+void VISU_ScalarMapPL::Init(){
+ //SetSourceRange();
+}
+
+
+void VISU_ScalarMapPL::Build() {
+ myExtractor->SetInput(myInput);
+ myFieldTransform->SetInput(myExtractor->GetOutput());
+ myMapper->SetInput(DoHook());
+}
+
+
+void VISU_ScalarMapPL::Update() {
+ float *aRange = myFieldTransform->GetScalarRange();
+ float aScalarRange[2] = {aRange[0], aRange[1]};
+ if(myBarTable->GetScale() == VTK_SCALE_LOG10)
+ VISU_LookupTable::ComputeLogRange(aRange,aScalarRange);
+ myMapperTable->SetRange(aScalarRange);
+ myMapperTable->SetMapScale(1.0);
+
+ myMapperTable->Build();
+ myBarTable->Build();
+
+ myMapper->SetLookupTable(myMapperTable);
+ myMapper->SetScalarRange(aScalarRange);
+
+ myFieldTransform->Update();
+
+ VISU_PipeLine::Update();
+}
+
+
+void VISU_ScalarMapPL::SetMapScale(float theMapScale){
+ myMapperTable->SetMapScale(theMapScale);
+ myMapperTable->Build();
+}
+float VISU_ScalarMapPL::GetMapScale(){
+ return myMapperTable->GetMapScale();
+}
+
+
+void VISU_ScalarMapPL::GetSourceRange(float theRange[2]){
+ myExtractor->Update();
+ myExtractor->GetOutput()->GetScalarRange(theRange);
+}
+
+void VISU_ScalarMapPL::SetSourceRange(){
+ float aRange[2];
+ GetSourceRange(aRange);
+ SetScalarRange(aRange);
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_ScalrMapPL_HeaderFile
+#define VISU_ScalrMapPL_HeaderFile
+
+#include "VISU_PipeLine.hxx"
+#include "VISU_ScalarBarActor.hxx"
+
+class vtkDataSet;
+
+class VISU_Extractor;
+class VISU_FieldTransform;
+
+class VISU_ScalarMapPL : public VISU_PipeLine{
+protected:
+ VISU_ScalarMapPL();
+ VISU_ScalarMapPL(const VISU_ScalarMapPL&);
+public:
+ vtkTypeMacro(VISU_ScalarMapPL,VISU_PipeLine);
+ static VISU_ScalarMapPL* New();
+ virtual ~VISU_ScalarMapPL();
+ virtual void ShallowCopy(VISU_PipeLine *thePipeLine);
+
+ virtual int GetScalarMode();
+ virtual void SetScalarMode(int theScalarMode = 0);
+
+ virtual int GetScaling();
+ virtual void SetScaling(int theScaling = VTK_SCALE_LINEAR);
+
+ virtual float* GetScalarRange();
+ virtual void SetScalarRange(float theRange[2]);
+ virtual void SetScalarMin(float theValue);
+ virtual void SetScalarMax(float theValue);
+
+ virtual void SetNbColors(int theNbColors = 16);
+ virtual int GetNbColors();
+
+public:
+ virtual void Init();
+ virtual void Build();
+ virtual void Update();
+
+ virtual VISU_LookupTable *GetMapperTable(){ return myMapperTable;}
+ virtual VISU_LookupTable *GetBarTable(){ return myBarTable;}
+
+ virtual void SetMapScale(float theMapScale = 1.0);
+ virtual float GetMapScale();
+
+ virtual void GetSourceRange(float theRange[2]);
+ virtual void SetSourceRange();
+
+protected:
+ typedef vtkDataSet THook;
+ virtual THook* DoHook();
+
+ VISU_LookupTable *myMapperTable, *myBarTable;
+ VISU_FieldTransform *myFieldTransform;
+ VISU_Extractor* myExtractor;
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_StreamLinesPL.hxx"
+#include "VISU_PipeLineUtils.hxx"
+#include "VISU_UsedPointsFilter.hxx"
+#include "SALOME_GeometryFilter.h"
+
+#include <vtkPointSet.h>
+#include <vtkStreamLine.h>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+static float EPS = 1.0e-20;
+int VISU_StreamLinesPL::myMaxIncrementMemorySize = 64;
+
+void SetStreamerSource(vtkStreamer *theStreamer, vtkPointSet* theDataSet, float thePercents){
+ theDataSet->Update();
+ VISU_UsedPointsFilter* anUsedPointsFilter = VISU_UsedPointsFilter::New();
+ anUsedPointsFilter->SetInput(theDataSet);
+ anUsedPointsFilter->SetPercentsOfUsedPoints(thePercents);
+ theStreamer->SetSource(anUsedPointsFilter->GetOutput());
+ anUsedPointsFilter->Register(theStreamer);
+ anUsedPointsFilter->Delete();
+}
+
+
+vtkStandardNewMacro(VISU_StreamLinesPL);
+
+VISU_StreamLinesPL::VISU_StreamLinesPL(){
+ myStream = vtkStreamLine::New();
+ myGeomFilter = SALOME_GeometryFilter::New();
+ mySource = NULL;
+}
+
+VISU_StreamLinesPL::~VISU_StreamLinesPL(){
+ myStream->Delete();
+ myGeomFilter->Delete();
+ SetSource(NULL);
+}
+
+void VISU_StreamLinesPL::ShallowCopy(VISU_PipeLine *thePipeLine){
+ VISU_DeformedShapePL::ShallowCopy(thePipeLine);
+ if(VISU_StreamLinesPL *aPipeLine = dynamic_cast<VISU_StreamLinesPL*>(thePipeLine)){
+
+ //Order of setting of the values are important
+ SetUsedPoints(aPipeLine->GetUsedPoints());
+ SetSource(aPipeLine->GetSource());
+
+ SetDirection(aPipeLine->GetDirection());
+
+ //Order of setting of the values are important
+ SetIntegrationStep(aPipeLine->GetIntegrationStep());
+ SetPropagationTime(aPipeLine->GetPropagationTime());
+ SetStepLength(aPipeLine->GetStepLength());
+ }
+}
+
+void VISU_StreamLinesPL::SetSource(vtkPointSet* theSource){
+ if (mySource != NULL) mySource->UnRegister(this);
+ mySource = theSource;
+ if (mySource != NULL) mySource->Register(this);
+ if(myInput && myInput->GetCellData()->GetNumberOfArrays()){
+ vtkCellDataToPointData *aFilter = vtkCellDataToPointData::New();
+ aFilter->SetInput(myFieldTransform->GetUnstructuredGridOutput());
+ aFilter->PassCellDataOn();
+ myStream->SetInput(aFilter->GetOutput());
+ aFilter->Register(myStream);
+ aFilter->Delete();
+ vtkCellCenters *centers = vtkCellCenters::New(); // for vectors on cells
+ centers->SetInput(myFieldTransform->GetUnstructuredGridOutput());
+ centers->VertexCellsOn();
+ mySource = mySource? mySource: centers->GetOutput();
+ SetStreamerSource(myStream,mySource,myPercents);
+ centers->Register(myStream);
+ centers->Delete();
+ }else{
+ myStream->SetInput(myFieldTransform->GetUnstructuredGridOutput());
+ mySource = mySource? mySource: myFieldTransform->GetUnstructuredGridOutput();
+ SetStreamerSource(myStream,mySource,myPercents);
+ }
+ myStream->Modified();
+ Modified();
+}
+
+
+float VISU_StreamLinesPL::GetMaxIntegrationStep(vtkPointSet* theDataSet) {
+ if(!theDataSet) return 0.0;
+ theDataSet->Update();
+ float* aBounds = theDataSet->GetBounds();
+ float aMaxSizeY = aBounds[3] - aBounds[2];
+ float aMaxSizeZ = aBounds[5] - aBounds[4];
+ float aMinMax = aBounds[1] - aBounds[0];
+ if (aMinMax < EPS || (aMaxSizeY < aMinMax && aMaxSizeY > EPS)) aMinMax = aMaxSizeY;
+ if (aMinMax < EPS || (aMaxSizeZ < aMinMax && aMaxSizeZ > EPS)) aMinMax = aMaxSizeZ;
+ return aMinMax / 2.0;
+}
+
+float VISU_StreamLinesPL::GetMinIntegrationStep(vtkPointSet* theDataSet) {
+ if(!theDataSet) return 0.0;
+ float aVolume = 1.0, tmp;
+ int degree = 0;
+ theDataSet->Update();
+ float* aBounds = theDataSet->GetBounds();
+ for(int i = 0, j = 0; i < 3; ++i, j = 2*i){
+ float tmp = aBounds[j+1] - aBounds[j];
+ if (tmp > EPS ) {
+ aVolume *= tmp;
+ degree += 1;
+ }
+ }
+ if (degree < 1) return 0.0; // absolutely empty object
+ unsigned long aSize = 1024*theDataSet->GetActualMemorySize();
+ // we have to use no more, than myMaxIncrementMemorySize*aSize amount of memory
+ unsigned long aRealSize = GetAvailableMemory(myMaxIncrementMemorySize*aSize);
+ if(MYDEBUG) cout<<"GetMinIntegrationStep - GetActualMemorysize() = "<<aRealSize<<"; "<<aSize<<endl;
+ float anAverageVolume = aVolume / aRealSize;
+ float aStep = pow(double(anAverageVolume), double(1.0/double(degree)));
+ return aStep;
+}
+
+float VISU_StreamLinesPL::GetBasePropagationTime(vtkPointSet* theDataSet) {
+ if(!theDataSet) return 0.0;
+ theDataSet->Update();
+ float* aScalarRange = theDataSet->GetScalarRange();
+ return theDataSet->GetLength()/fabs(aScalarRange[1] + aScalarRange[0])*2.0;
+}
+
+
+int VISU_StreamLinesPL::GetDirection(){
+ return myStream->GetIntegrationDirection();
+}
+void VISU_StreamLinesPL::SetDirection(int theDirection){
+ myStream->SetIntegrationDirection(theDirection);
+ Modified();
+}
+
+
+float VISU_StreamLinesPL::GetPropagationTime() {
+ return myStream->GetMaximumPropagationTime();
+}
+void VISU_StreamLinesPL::SetPropagationTime(float theTime) {
+ if(myStream->GetMaximumPropagationTime() == theTime) return;
+ myStream->SetMaximumPropagationTime(theTime);
+ Modified();
+}
+
+
+float VISU_StreamLinesPL::GetIntegrationStep(){
+ return myStream->GetIntegrationStepLength();
+}
+float VISU_StreamLinesPL::SetIntegrationStep(float theStep){
+ if(myStream->GetIntegrationStepLength() == theStep) return theStep;
+ myExtractor->Update();
+ vtkPointSet* aDataSet = GetSource();
+ aDataSet->Update();
+ float anIntegrationStep = theStep;
+ float aMinIntegrationStep = GetMinIntegrationStep(aDataSet);
+ float aMaxIntegrationStep = GetMaxIntegrationStep(aDataSet);
+ if(aMinIntegrationStep < anIntegrationStep && anIntegrationStep < aMaxIntegrationStep){
+ myStream->SetIntegrationStepLength(theStep);
+ Modified();
+ }else{
+ anIntegrationStep = aMaxIntegrationStep / 10.0;
+ float aMinMax = aDataSet->GetLength()/myInput->GetNumberOfPoints();
+ if(aMinMax > anIntegrationStep)
+ anIntegrationStep = (anIntegrationStep*9.0+aMinMax)/10.0;
+ if(aMinIntegrationStep > anIntegrationStep)
+ anIntegrationStep = aMinIntegrationStep;
+ }
+ return anIntegrationStep;
+}
+
+
+float VISU_StreamLinesPL::GetStepLength() {
+ return myStream->GetStepLength();
+}
+float VISU_StreamLinesPL::GetMinStepLength(float theIntegrationStep){
+ return theIntegrationStep*2.0;
+}
+float VISU_StreamLinesPL::GetMaxStepLength(float thePropagationTime){
+ return thePropagationTime/100.0;
+}
+float VISU_StreamLinesPL::CorrectStepLength(float theStep, float theIntegrationStep, float thePropagationTime){
+ float aMinStep = GetMinStepLength(theIntegrationStep);
+ if(theStep < aMinStep) theStep = aMinStep;
+ float aMaxStep = GetMaxStepLength(thePropagationTime);
+ if(theStep > aMaxStep) theStep = aMaxStep;
+ return theStep;
+}
+float VISU_StreamLinesPL::SetStepLength(float theStep){
+ if(myStream->GetStepLength() == theStep) return theStep;
+ float aStepLength = CorrectStepLength(theStep,GetIntegrationStep(),GetPropagationTime());
+ if(aStepLength == theStep){
+ myStream->SetStepLength(theStep);
+ Modified();
+ }
+ return aStepLength;
+}
+
+
+void VISU_StreamLinesPL::Init(){
+ VISU_ScalarMapPL::Init();
+
+ SetDirection(VTK_INTEGRATE_BOTH_DIRECTIONS);
+ vtkPointSet* aDataSet = myExtractor->GetOutput();
+ //Order of setting of the values are important
+ myPercents = 0.3;
+ SetSource(NULL);
+
+ SetIntegrationStep(SetIntegrationStep(GetMaxIntegrationStep(aDataSet)/10.0));
+ SetPropagationTime(GetBasePropagationTime(aDataSet));
+ SetStepLength(SetStepLength(GetPropagationTime()/20.));
+}
+
+VISU_ScalarMapPL::THook* VISU_StreamLinesPL::DoHook(){
+ SetSource(NULL);
+ myInput->Update();
+ float *aBounds = myInput->GetBounds();
+ myGeomFilter->SetExtent(aBounds);
+ myGeomFilter->ExtentClippingOn();
+ myGeomFilter->SetInput(myStream->GetOutput());
+ return myGeomFilter->GetOutput();
+}
+
+void VISU_StreamLinesPL::Update(){
+ VISU_ScalarMapPL::Update();
+}
+
+void VISU_StreamLinesPL::SetMapScale(float theMapScale){
+ VISU_ScalarMapPL::SetMapScale(theMapScale);
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_StreamLinesPL_HeaderFile
+#define VISU_StreamLinesPL_HeaderFile
+
+#include "VISU_DeformedShapePL.hxx"
+#include <vtkStreamLine.h>
+
+class vtkPointSet;
+class SALOME_GeometryFilter;
+
+class VISU_StreamLinesPL : public VISU_DeformedShapePL{
+protected:
+ VISU_StreamLinesPL();
+ VISU_StreamLinesPL(const VISU_StreamLinesPL&);
+public:
+ vtkTypeMacro(VISU_StreamLinesPL,VISU_DeformedShapePL);
+ static VISU_StreamLinesPL* New();
+ virtual ~VISU_StreamLinesPL();
+ virtual void ShallowCopy(VISU_PipeLine *thePipeLine);
+
+ virtual int GetDirection();
+ virtual void SetDirection(int theDirection);
+
+ virtual float GetStepLength();
+ virtual float SetStepLength(float theStep);
+
+ virtual float GetPropagationTime();
+ virtual void SetPropagationTime(float theTime);
+
+ virtual float GetIntegrationStep();
+ virtual float SetIntegrationStep(float theStep);
+
+ virtual void SetSource(vtkPointSet* theSource);
+ virtual vtkPointSet* GetSource() {return mySource;}
+
+ virtual void SetUsedPoints(float thePercents) { myPercents = thePercents;}
+ virtual float GetUsedPoints() { return myPercents;}
+
+ virtual float GetMaxIntegrationStep(){ return GetMaxIntegrationStep(GetSource());}
+ virtual float GetMinIntegrationStep(){ return GetMinIntegrationStep(GetSource());}
+ virtual float GetBasePropagationTime(){ return GetBasePropagationTime(GetSource());};
+
+public:
+ virtual THook* DoHook();
+ virtual void Init();
+ virtual void Update();
+ virtual void SetMapScale(float theMapScale = 1.0);
+
+public:
+ static int myMaxIncrementMemorySize;
+
+ static float GetMinStepLength(float theIntegrationStep);
+ static float GetMaxStepLength(float thePropagationTime);
+ static float CorrectStepLength(float theStep, float theIntegrationStep, float thePropagationTime);
+
+ static float GetMaxIntegrationStep(vtkPointSet* theDataSet);
+ static float GetMinIntegrationStep(vtkPointSet* theDataSet);
+ static float GetBasePropagationTime(vtkPointSet* theDataSet);
+
+protected:
+ vtkStreamLine* myStream;
+ vtkPointSet* mySource;
+ SALOME_GeometryFilter *myGeomFilter;
+ float myPercents;
+};
+
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_StreamLinesPL.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_UsedPointsFilter.hxx"
+
+#include <vtkObjectFactory.h>
+#include <vtkPointSet.h>
+#include <vtkPointData.h>
+#include <vtkCellData.h>
+#include <vtkPoints.h>
+#include <vtkIdList.h>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+vtkStandardNewMacro(VISU_UsedPointsFilter);
+
+VISU_UsedPointsFilter::VISU_UsedPointsFilter(){
+ PercentsOfUsedPoints = 0.1;
+}
+
+VISU_UsedPointsFilter::~VISU_UsedPointsFilter(){}
+
+void VISU_UsedPointsFilter::Execute(){
+ vtkPointSet *anInput = this->GetInput(), *anOutput = this->GetOutput();
+ anOutput->GetPointData()->CopyAllOff();
+ anOutput->GetCellData()->CopyAllOff();
+ vtkPoints* aPoints = vtkPoints::New();
+ vtkIdType aCellSize = anInput->GetMaxCellSize();
+ vtkIdList *anIdList = vtkIdList::New();
+ vtkIdType iEnd = anInput->GetNumberOfPoints();
+ for(vtkIdType i = 0; i < iEnd; i++){
+ anInput->GetPointCells(i,anIdList);
+ if(anIdList->GetNumberOfIds() > 0)
+ aPoints->InsertNextPoint(anInput->GetPoint(i));
+ }
+ static float EPS = 1E-5;
+ if(PercentsOfUsedPoints < EPS){
+ anOutput->SetPoints(aPoints);
+ }else{
+ vtkPoints* aNewPoints = vtkPoints::New();
+ iEnd = aPoints->GetNumberOfPoints();
+ vtkIdType anOffset = vtkIdType(1.0/PercentsOfUsedPoints);
+ if(anOffset < 1) anOffset = 1;
+ for(vtkIdType i = 0; i < iEnd; i += anOffset)
+ aNewPoints->InsertNextPoint(aPoints->GetPoint(i));
+ anOutput->SetPoints(aNewPoints);
+ aNewPoints->Delete();
+ }
+ aPoints->Delete();
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_UsedPointsFilter.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_UsedPointsFilter_HeaderFile
+#define VISU_UsedPointsFilter_HeaderFile
+
+#include <vtkPointSetToPointSetFilter.h>
+
+class VISU_UsedPointsFilter : public vtkPointSetToPointSetFilter{
+protected:
+ VISU_UsedPointsFilter();
+ VISU_UsedPointsFilter(const VISU_UsedPointsFilter&);
+
+ virtual void Execute();
+ float PercentsOfUsedPoints;
+
+public:
+ vtkTypeMacro(VISU_UsedPointsFilter,vtkPointSetToPointSetFilter);
+ static VISU_UsedPointsFilter* New();
+ virtual ~VISU_UsedPointsFilter();
+
+ vtkSetMacro(PercentsOfUsedPoints,float);
+ vtkGetMacro(PercentsOfUsedPoints,float);
+};
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.cxx
+// Author: Alexey PETROV
+// Module : VISU
+
+
+#include "VISU_VectorsPL.hxx"
+#include "VISU_PipeLineUtils.hxx"
+#include "SALOME_TransformFilter.h"
+#include "SALOME_Transform.h"
+
+#include <vtkGlyph3D.h>
+#include <vtkConeSource.h>
+#include <vtkLineSource.h>
+#include <vtkGlyphSource2D.h>
+
+vtkStandardNewMacro(VISU_VectorsPL);
+
+VISU_VectorsPL::VISU_VectorsPL(){
+ myGlyph = vtkGlyph3D::New();
+ myTransformFilter = SALOME_TransformFilter::New();
+}
+
+VISU_VectorsPL::~VISU_VectorsPL(){
+ myGlyph->Delete();
+ myTransformFilter->Delete();
+}
+
+void VISU_VectorsPL::ShallowCopy(VISU_PipeLine *thePipeLine){
+ VISU_DeformedShapePL::ShallowCopy(thePipeLine);
+ if(VISU_VectorsPL *aPipeLine = dynamic_cast<VISU_VectorsPL*>(thePipeLine)){
+ SetGlyphType(aPipeLine->GetGlyphType());
+ SetGlyphPos(aPipeLine->GetGlyphPos());
+ }
+}
+
+
+void VISU_VectorsPL::SetTransform(SALOME_Transform* theTransform){
+ myFieldTransform->SetSpaceTransform(theTransform);
+ myTransformFilter->SetTransform(theTransform);
+ myTransformFilter->Modified();
+}
+SALOME_Transform* VISU_VectorsPL::GetTransform(){
+ return myFieldTransform->GetSpaceTransform();
+}
+
+
+void VISU_VectorsPL::SetScale(float theScale) {
+ if(myScaleFactor == theScale) return;
+ myScaleFactor = theScale;
+ myGlyph->SetScaleFactor(myScaleFactor);
+ Modified();
+}
+float VISU_VectorsPL::GetScale() {
+ return myGlyph->GetScaleFactor();
+}
+
+
+void VISU_VectorsPL::Init(){
+ VISU_DeformedShapePL::Init();
+
+ myTypeGlyph = ARROW;
+ myPosGlyph = TAIL;
+}
+
+
+VISU_ScalarMapPL::THook* VISU_VectorsPL::DoHook(){
+ VISU::ToCellCenters(myTransformFilter,myInput,myFieldTransform);
+ myGlyph->SetInput(myTransformFilter->GetOutput());
+ myGlyph->SetVectorModeToUseVector();
+ myGlyph->SetScaleModeToScaleByVector();
+ myGlyph->SetColorModeToColorByScalar();
+ return myGlyph->GetOutput();
+}
+
+
+void VISU_VectorsPL::Update(){
+ switch (myTypeGlyph) {
+ case ARROW: {
+ vtkGlyphSource2D *aGlyphSource = vtkGlyphSource2D::New();
+ aGlyphSource->SetGlyphTypeToArrow();
+ aGlyphSource->SetFilled(0);
+ if(myPosGlyph == TAIL)
+ aGlyphSource->SetCenter(0.5, 0.0, 0.0);
+ else if(myPosGlyph == HEAD)
+ aGlyphSource->SetCenter(-0.5, 0.0, 0.0);
+ myGlyph->SetSource(aGlyphSource->GetOutput());
+ aGlyphSource->Register(myGlyph);
+ aGlyphSource->Delete();
+ }
+ break;
+ case CONE2:
+ case CONE6: {
+ vtkConeSource *aGlyphSource = vtkConeSource::New(); //by default
+ if (myTypeGlyph == CONE2)
+ aGlyphSource->SetResolution(3);
+ else
+ aGlyphSource->SetResolution(7);
+ aGlyphSource->SetHeight(1.0);
+ aGlyphSource->SetRadius(.1);
+
+ if(myPosGlyph == TAIL)
+ aGlyphSource->SetCenter(0.5, 0.0, 0.0);
+ else if(myPosGlyph == HEAD)
+ aGlyphSource->SetCenter(-0.5, 0.0, 0.0);
+
+ myGlyph->SetSource(aGlyphSource->GetOutput());
+ aGlyphSource->Register(myGlyph);
+ aGlyphSource->Delete();
+ }
+ break;
+ case NONE:
+ default: {
+ vtkLineSource *aGlyphSource = vtkLineSource::New();
+ myGlyph->SetSource(aGlyphSource->GetOutput());
+ aGlyphSource->Register(myGlyph);
+ aGlyphSource->Delete();
+ }
+ }
+
+ VISU_DeformedShapePL::Update();
+}
+
+
+void VISU_VectorsPL::SetMapScale(float theMapScale){
+ VISU_ScalarMapPL::SetMapScale(theMapScale);
+
+ myGlyph->SetScaleFactor(myScaleFactor*theMapScale);
+ myGlyph->Modified();
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File: VISU_PipeLine.hxx
+// Author: Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_VectorsPL_HeaderFile
+#define VISU_VectorsPL_HeaderFile
+
+#include "VISU_DeformedShapePL.hxx"
+
+class SALOME_TransformFilter;
+class SALOME_Transform;
+class vtkGlyph3D;
+
+class VISU_VectorsPL : public VISU_DeformedShapePL{
+protected:
+ VISU_VectorsPL();
+ VISU_VectorsPL(const VISU_VectorsPL&);
+public:
+ vtkTypeMacro(VISU_VectorsPL,VISU_DeformedShapePL);
+ static VISU_VectorsPL* New();
+ virtual ~VISU_VectorsPL();
+ virtual void ShallowCopy(VISU_PipeLine *thePipeLine);
+
+ virtual void SetScale(float theScale);
+ virtual float GetScale();
+
+ enum GlyphType{ ARROW, CONE2, CONE6, NONE};
+ virtual void SetGlyphType(GlyphType theType) { myTypeGlyph = theType;}
+ virtual GlyphType GetGlyphType() { return myTypeGlyph;}
+
+ enum GlyphPos{ CENTER, TAIL,HEAD};
+ virtual void SetGlyphPos(GlyphPos thePos) { myPosGlyph = thePos;}
+ virtual GlyphPos GetGlyphPos() { return myPosGlyph;}
+
+public:
+ virtual THook* DoHook();
+ virtual void Init();
+ virtual void Update();
+
+ virtual void SetTransform(SALOME_Transform* theTransform);
+ virtual SALOME_Transform* GetTransform();
+
+ virtual void SetMapScale(float theMapScale = 1.0);
+
+protected:
+ GlyphType myTypeGlyph;
+ GlyphPos myPosGlyph;
+ vtkGlyph3D *myGlyph;
+ SALOME_TransformFilter *myTransformFilter;
+};
+
+
+#endif
VisuGUI_NonIsometricDlg.cxx \
VisuGUI_StreamLinesDlg.cxx \
VisuGUI_TimeAnimation.cxx \
- VisuGUI_CutLinesDlg.cxx
+ VisuGUI_CutLinesDlg.cxx \
+ VisuGUI_FileDlg.cxx
LIB_MOC = \
VisuGUI.h \
VisuGUI_NonIsometricDlg.h \
VisuGUI_StreamLinesDlg.h \
VisuGUI_TimeAnimation.h \
- VisuGUI_CutLinesDlg.h
+ VisuGUI_CutLinesDlg.h \
+ VisuGUI_FileDlg.h
LIB_CLIENT_IDL = SALOME_Exception.idl \
VISU_Gen.idl \
CPPFLAGS += -ftemplate-depth-32 $(QT_INCLUDES) $(VTK_INCLUDES) $(OCC_INCLUDES) $(PYTHON_INCLUDES) $(MED2_INCLUDES) $(HDF5_INCLUDES) $(QWT_INCLUDES)
CXXFLAGS += -ftemplate-depth-32 $(OCC_CXXFLAGS)
-LDFLAGS += $(OCC_LIBS) $(MED2_LIBS) $(HDF5_LIBS) $(VTK_LIBS) $(QWT_LIBS) -lSalomeGUI -lSalomeNS \
- -lVisuObject -lVisuEngine -lmed -lVTKViewer
+LDFLAGS += $(MED2_LIBS) $(HDF5_LIBS) $(VTK_LIBS) $(QWT_LIBS) -lSalomeGUI -lSalomeNS -lVisuObject -lVisuEngine -lmed -lVTKViewer
@CONCLUDE@
// Module : VISU
// $Header$
-using namespace std;
#include "VisuGUI.h"
+
+#include "VISU_Gen_i.hh"
+#include "VISU_Result_i.hh"
+#include "VISU_PrsObject_i.hh"
+#include "VISU_ViewManager_i.hh"
+
+#include "VISU_PipeLine.hxx"
+
+#include "VISU_Prs3d_i.hh"
+#include "VISU_Mesh_i.hh"
+#include "VISU_ScalarMap_i.hh"
+#include "VISU_IsoSurfaces_i.hh"
+#include "VISU_DeformedShape_i.hh"
+#include "VISU_CutPlanes_i.hh"
+#include "VISU_CutLines_i.hh"
+#include "VISU_Vectors_i.hh"
+#include "VISU_StreamLines_i.hh"
+#include "VISU_Table_i.hh"
+
+#include "VISU_Actor.h"
+#include "VISU_MeshAct.h"
+
#include "VisuGUI_PhaseDlg.h"
#include "VisuGUI_MagnitudeDlg.h"
#include "VisuGUI_PhaseMagnitudeDlg.h"
#include "VisuGUI_SelVectCompDlg.h"
#include "VisuGUI_NonIsometricDlg.h"
-#include "VISU_Gen_i.hh"
-#include "VISU_Result_i.hh"
-#include "VISU_Extractor.hxx"
-#include "VISU_Table_i.hh"
-#include "VISU_ViewManager_i.hh"
-#include "VISU_LookupTable.hxx"
-#include "VISU_ScalarBarActor.hxx"
-
#include "SALOMEGUI_ImportOperation.h"
#include "SALOMEGUI_QtCatchCorbaException.hxx"
#include "utilities.h"
#include "Plot2d_SetupPlot2dDlg.h"
#include "Plot2d_ViewFrame.h"
#include "VTKViewer_ViewFrame.h"
+#include "VisuGUI_FileDlg.h"
// QT Includes
#define INCLUDE_MENUITEM_DEF
#endif
#include <Utils_Timer.hxx>
-#ifdef DEBUG
+using namespace std;
+
+#ifdef _DEBUG_
static int MYDEBUG = 0;
static int MYDEBUGWITHFILES = 0;
#else
return VISU::VISU_Gen_i::GetVisuGenImpl();
}
+static int ComputeVisiblePropBounds(VTKViewer_ViewFrame* theViewFrame, float allBounds[6],
+ const char* theActorClassName = "VISU_Actor")
+{
+ vtkRenderer *aRen = theViewFrame->getRenderer();
+ vtkActorCollection *anActColl = aRen->GetActors();
+ vtkProp *prop;
+ float *bounds;
+ int nothingVisible=1;
+
+ allBounds[0] = allBounds[2] = allBounds[4] = VTK_LARGE_FLOAT;
+ allBounds[1] = allBounds[3] = allBounds[5] = -VTK_LARGE_FLOAT;
+ // loop through all props
+ for (anActColl->InitTraversal(); (prop = anActColl->GetNextProp()); ){
+ // if it's invisible, or has no geometry, we can skip the rest
+ if ( prop->GetVisibility() && prop->IsA(theActorClassName)){
+ bounds = prop->GetBounds();
+ // make sure we haven't got bogus bounds
+ if ( bounds != NULL &&
+ bounds[0] > -VTK_LARGE_FLOAT && bounds[1] < VTK_LARGE_FLOAT &&
+ bounds[2] > -VTK_LARGE_FLOAT && bounds[3] < VTK_LARGE_FLOAT &&
+ bounds[4] > -VTK_LARGE_FLOAT && bounds[5] < VTK_LARGE_FLOAT )
+ {
+ nothingVisible = 0;
+ if (bounds[0] < allBounds[0]) allBounds[0] = bounds[0];
+ if (bounds[1] > allBounds[1]) allBounds[1] = bounds[1];
+ if (bounds[2] < allBounds[2]) allBounds[2] = bounds[2];
+ if (bounds[3] > allBounds[3]) allBounds[3] = bounds[3];
+ if (bounds[4] < allBounds[4]) allBounds[4] = bounds[4];
+ if (bounds[5] > allBounds[5]) allBounds[5] = bounds[5];
+ }//not bogus
+ }
+ }
+ return nothingVisible;
+}
+
+VisuGUI::CameraOrient VisuGUI::SetFitAll(VTKViewer_ViewFrame* theViewFrame){
+ static float PRECISION = 0.000001;
+ static float DEVIATION = 600;
+ float XYZ_Bnd[6];
+ if(ComputeVisiblePropBounds(theViewFrame,XYZ_Bnd)) return e3D;
+
+ float absX = XYZ_Bnd[1]-XYZ_Bnd[0];
+
+ float absY = XYZ_Bnd[3]-XYZ_Bnd[2];
+
+ float absZ = XYZ_Bnd[5]-XYZ_Bnd[4];
+
+ CameraOrient aCameraOrient = e3D;
+ if(absX <= PRECISION) aCameraOrient = eFront;
+ else {if(absY <= PRECISION) aCameraOrient = eLeft;
+ else {if(absZ <= PRECISION) aCameraOrient = eTop;}}
+
+ float dev_abs_XY = absX / absY;
+ float dev_abs_YZ = absY / absZ;
+ float dev_abs_XZ = absX / absZ;
+ if(dev_abs_XY >= DEVIATION || 1./dev_abs_YZ >= DEVIATION) aCameraOrient = eLeft;
+ else{if(1./dev_abs_XY >= DEVIATION || 1./dev_abs_XZ >= DEVIATION) aCameraOrient = eFront;
+ else {if(dev_abs_XZ >= DEVIATION || dev_abs_YZ >= DEVIATION) aCameraOrient = eTop;}}
+
+ switch(aCameraOrient){
+ case eFront: theViewFrame->onViewFront(); break;
+ case eLeft: theViewFrame->onViewLeft(); break;
+ case eTop: theViewFrame->onViewTop(); break;
+ case e3D: theViewFrame->onViewReset(); break;
+ }
+ theViewFrame->getRenderer()->ResetCameraClippingRange();
+ theViewFrame->onViewFitAll();
+}
+
QAD_Desktop* VisuGUI::GetDesktop(){
return QAD_Application::getDesktop() ;
}
VisuGUI::VisuGUI(){}
-
-VisuGUI* VisuGUI::GetOrCreateVisuGUI( QAD_Desktop* desktop ){
- if(!visuGUI){
- static VisuGUI VISUGUI;
- visuGUI = &VISUGUI;
- }
- return visuGUI;
-}
-
-/* ********************************************************************************* */
-/* Function to return VisuGUI object */
-/* ********************************************************************************* */
-VisuGUI* VisuGUI::GetVisuGUI( )
-{
- return VisuGUI::GetOrCreateVisuGUI(QAD_Application::getDesktop());
-}
-
/* ==================================================================================== */
/* ==================================================================================== */
/* ONGUI EVENT */
static int checkLock(const SALOMEDS::Study_var& theStudy) {
if (isStudyLocked(theStudy)) {
QAD_MessageBox::warn1 ( (QWidget*)QAD_Application::getDesktop(),
- QObject::tr("WARNING"),
+ QObject::tr("WRN_WARNING"),
QObject::tr("WRN_STUDY_LOCKED"),
QObject::tr("BUT_OK") );
return true;
bool VisuGUI::OnGUIEvent(int theCommandID, QAD_Desktop* parent)
{
try{
- VisuGUI::GetOrCreateVisuGUI(parent);
- QString VisuInputDir = getVisuInputDir();
- QString VisuOutputDir = getVisuOutputDir();
- vtkRenderer *theRenderer = GetRenderer();
-
- SALOMEDS::Study_var aStudy = GetActiveStudy()->getStudyDocument(); //Document OCAF de l'etude active
- SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
- SALOMEDS::GenericAttribute_var anAttr;
- SALOMEDS::AttributeName_var aName;
- SALOMEDS::AttributeIOR_var anIOR;
-
- switch (theCommandID)
- {
- /* ======================================================================================== */
- /* Define Selection Mode */
- /* ======================================================================================== */
+ QString VisuInputDir = getVisuInputDir();
+ QString VisuOutputDir = getVisuOutputDir();
+ vtkRenderer *theRenderer = GetRenderer();
+
+ SALOMEDS::Study_var aStudy = GetActiveStudy()->getStudyDocument(); //Document OCAF de l'etude active
+ SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
+ SALOMEDS::GenericAttribute_var anAttr;
+ SALOMEDS::AttributeName_var aName;
+ SALOMEDS::AttributeIOR_var anIOR;
+
+ switch (theCommandID){
+ /* ======================================================================================== */
+ /* Define Selection Mode */
+ /* ======================================================================================== */
case 101:
case 102:
case 103:
case 8041 : // Object representation : Wireframe
case 9041 : // Object representation : Wireframe
- visuGUI->ChangeRepresentation(WIREFRAME);
+ visuGUI->ChangeRepresentation(VISU::WIREFRAME);
break;
case 8042 : // Object representation : Surface
case 9042 : // Object representation : Surface
- visuGUI->ChangeRepresentation(SURFACE);
+ visuGUI->ChangeRepresentation(VISU::SHADED);
break;
case 8043 : // Object representation : Points
case 9043 : // Object representation : Points
- visuGUI->ChangeRepresentation(POINTS);
+ visuGUI->ChangeRepresentation(VISU::POINT);
break;
case 8044 : // Object representation : Shrink/Unshrink
case 9044 : // Object representation : Shrink/Unshrink
- visuGUI->ChangeRepresentation(SHRINK);
+ visuGUI->ChangeRepresentation(VISU::SHRINK);
break;
case 8051 : // Change object color
SetSweepingPreferences();
}
break;
-
+
+/* ======================================================================================== */
+/* Preferences for Full loading */
+/* ======================================================================================== */
+ case 53:
+ case 54:
+ {
+ QMenuData* pp;
+ QMenuItem* item = parent->menuBar()->findItem(theCommandID,&pp);
+ bool check = !pp->isItemChecked(theCommandID);
+ pp->setItemChecked(theCommandID,check);
+ switch(theCommandID){
+ case 53:
+ QAD_CONFIG->addSetting( "Visu:BuildResult", check );
+ break;
+ case 54:
+ QAD_CONFIG->addSetting( "Visu:BuildDefaultPrs3d", check );
+ break;
+ }
+ }
+ break;
case 113: // Load MED using MED component
{
}
-/* ********************************************************************************* */
-/* Function to find Actor in Viewer */
-/* ********************************************************************************* */
-
-
-VISU_Actor *VisuGUI::GetActor(int* theSelectionType){
- VISU::Prs3d_i* aPrs3d = GetSelectedPrs3d();
- if (!aPrs3d) return NULL;
-
- VTKViewer_ViewFrame* vf = VisuGUI::GetVtkViewFrame();
- if(!vf) return NULL;
-
- if(theSelectionType){
- QAD_Study *aStudy = QAD_Application::getDesktop()->getActiveStudy();
- SALOME_Selection *aSel = SALOME_Selection::Selection(aStudy->getSelection());
- *theSelectionType = aSel->SelectionMode();
- }
-
- return GetActor(aPrs3d,vf);
-}
-
/* ********************************************************************************** */
/* Function ShowTrihedron */
/* ********************************************************************************** */
/* ********************************************************************************** */
VisuGUI::~VisuGUI(){
- MESSAGE("VisuGUI::~VisuGUI");
+ if(MYDEBUG) MESSAGE("VisuGUI::~VisuGUI");
}
/* ********************************************************************************** */
/* ********************************************************************************** */
void VisuGUI::ChangeViewer(int theType){
- VTKViewer_ViewFrame* vf = GetVtkViewFrame();
- if (!vf) return;
-
- vtkActor *anActor;
- vtkRenderer *aRen = vf->getRenderer();
- vtkActorCollection *anActColl = aRen->GetActors();
- for(anActColl->InitTraversal(); (anActor = anActColl->GetNextActor()) != NULL; ){
- if(anActor->IsA("VISU_Actor")){
- VISU_Actor* anVISUActor = VISU_Actor::SafeDownCast(anActor);
- if(anVISUActor->GetVisibility() > 0)
- if(theType > 0)
- anVISUActor->SetRepresentation(theType);
- else if(theType == -1)
- anVISUActor->VisibilityOff();
- else
- anVISUActor->VisibilityOn();
+ if(vtkRenderer *aRen = GetRenderer()){
+ vtkActor *anActor;
+ vtkActorCollection *anActColl = aRen->GetActors();
+ for(anActColl->InitTraversal(); (anActor = anActColl->GetNextActor()) != NULL; ){
+ if(anActor->GetVisibility() > 0)
+ if(VISU_Actor* anVISUActor = VISU_Actor::SafeDownCast(anActor)){
+ anVISUActor = anVISUActor->GetParent();
+ if(theType >= 0)
+ anVISUActor->SetRepresentation(theType);
+ else
+ anVISUActor->VisibilityOff();
+ }
}
+ RepaintCurrentView();
}
}
-
// -----------------------------------------------------------------------------------------
// EVENTS
// -----------------------------------------------------------------------------------------
bool VisuGUI::OnMousePress (QMouseEvent* pe, QAD_Desktop* parent, QAD_StudyFrame* studyFrame)
{
- VisuGUI::GetOrCreateVisuGUI(parent);
return true;
}
bool VisuGUI::OnMouseMove (QMouseEvent* pe, QAD_Desktop* parent, QAD_StudyFrame* studyFrame)
{
- VisuGUI::GetOrCreateVisuGUI(parent);
return true;
}
bool VisuGUI::OnKeyPress (QKeyEvent* pe, QAD_Desktop* parent, QAD_StudyFrame* studyFrame)
{
- VisuGUI::GetOrCreateVisuGUI(parent);
if (GetActiveStudy()->getActiveStudyFrame()->getTypeView() != VIEW_VTK) // true = Viewer OCC
return false;
- MESSAGE ( "VisuGUI::onKeyPress : " << pe->key() )
+ if(MYDEBUG) MESSAGE( "VisuGUI::onKeyPress : " << pe->key() )
switch ( pe->key() )
{
case Key_Escape :
{
- MESSAGE("--> Key : Escape")
+ if(MYDEBUG) MESSAGE("--> Key : Escape")
return true;
}
default :
//=====================================================================================
bool VisuGUI::setSettings(QAD_Desktop* parent)
{
- VisuGUI::GetOrCreateVisuGUI(parent);
+ int anId = 53;
+ QMenuData* pp;
+ QMenuItem* item = parent->menuBar()->findItem(anId,&pp);
+ QString aValue = QAD_CONFIG->getSetting("Visu:BuildResult");
+
+ if(aValue.isEmpty()? 0 : aValue.toInt())
+ pp->setItemChecked(anId, true);
+
+ anId = 54;
+ item = parent->menuBar()->findItem(anId,&pp);
+ aValue = QAD_CONFIG->getSetting("Visu:BuildDefaultPrs3d");
+
+ if(aValue.isEmpty()? 0 : aValue.toInt())
+ pp->setItemChecked(anId, true);
+
return true;
}
// purpose :
//=====================================================================================
void VisuGUI::DisplayPrs() {
- MESSAGE("VisuGUI::DisplayPrs");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayPrs");
Handle(SALOME_InteractiveObject) anIO;
CORBA::Object_var anObject = GetSelectedObj(&anIO);
if ( !CORBA::is_nil( anObject ) ) {
// is it Prs3d object ?
VISU::Prs3d_i* aPrsObject = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(anObject));
if(aPrsObject){
- MESSAGE("VisuGUI::DisplayPrs : Prs3d object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayPrs : Prs3d object");
UpdateViewer(aPrsObject);
if (VTKViewer_ViewFrame* vf = GetVtkViewFrame()) {
vf->getRenderer()->ResetCameraClippingRange();
// is it Curve ?
VISU::Curve_i* aCurve = dynamic_cast<VISU::Curve_i*>(VISU::GetServant(anObject));
if(aCurve){
- MESSAGE("VisuGUI::DisplayPrs : Curve object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayPrs : Curve object");
PlotCurve(aCurve, VISU::eDisplay );
return;
}
// is it Container ?
VISU::Container_i* aContainer = dynamic_cast<VISU::Container_i*>(VISU::GetServant(anObject));
if(aContainer){
- MESSAGE("VisuGUI::DisplayPrs : Container object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayPrs : Container object");
PlotContainer(aContainer, VISU::eDisplay );
return;
}
// is it Table ?
VISU::Table_i* aTable = dynamic_cast<VISU::Table_i*>(VISU::GetServant(anObject));
if(aTable){
- MESSAGE("VisuGUI::DisplayPrs : Table object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayPrs : Table object");
PlotTable(aTable, VISU::eDisplay );
return;
}
// purpose :
//=====================================================================================
void VisuGUI::DisplayOnlyPrs() {
- MESSAGE("VisuGUI::DisplayOnlyPrs");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyPrs");
CORBA::Object_var anObject = GetSelectedObj();
if ( !CORBA::is_nil( anObject ) ) {
// is it Prs3d object ?
PortableServer::Servant aServant = VISU::GetServant(anObject);
if(VISU::Prs3d_i* aPrsObject = dynamic_cast<VISU::Prs3d_i*>(aServant)){
- MESSAGE("VisuGUI::DisplayOnlyPrs : Prs3d object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyPrs : Prs3d object");
UpdateViewer(aPrsObject, true);
VTKViewer_ViewFrame* vf = GetVtkViewFrame();
if (vf) {
vf->Repaint();
}
}else if(VISU::Curve_i* aCurve = dynamic_cast<VISU::Curve_i*>(aServant)){
- MESSAGE("VisuGUI::DisplayOnlyPrs : Curve object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyPrs : Curve object");
PlotCurve(aCurve, VISU::eDisplayOnly );
}else if(VISU::Container_i* aContainer = dynamic_cast<VISU::Container_i*>(aServant)){
- MESSAGE("VisuGUI::DisplayOnlyPrs : Container object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyPrs : Container object");
PlotContainer(aContainer, VISU::eDisplayOnly );
}else if(VISU::Table_i* aTable = dynamic_cast<VISU::Table_i*>(aServant)){
- MESSAGE("VisuGUI::DisplayOnlyPrs : Table object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyPrs : Table object");
PlotTable(aTable, VISU::eDisplayOnly );
}
}
// purpose :
//=====================================================================================
void VisuGUI::ErasePrs() {
- MESSAGE("VisuGUI::ErasePrs");
+ if(MYDEBUG) MESSAGE("VisuGUI::ErasePrs");
CORBA::Object_var anObject = GetSelectedObj();
if ( !CORBA::is_nil( anObject ) ) {
// is it Prs3d object ?
VISU::Prs3d_i* aPrsObject = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(anObject));
if(aPrsObject){
- MESSAGE("VisuGUI::ErasePrs : Prs3d object");
+ if(MYDEBUG) MESSAGE("VisuGUI::ErasePrs : Prs3d object");
ErasePrs(aPrsObject);
VTKViewer_ViewFrame* vf = GetVtkViewFrame();
if (vf) {
// is it Curve ?
VISU::Curve_i* aCurve = dynamic_cast<VISU::Curve_i*>(VISU::GetServant(anObject));
if(aCurve){
- MESSAGE("VisuGUI::ErasePrs : Curve object");
+ if(MYDEBUG) MESSAGE("VisuGUI::ErasePrs : Curve object");
PlotCurve(aCurve, VISU::eErase );
}
// is it Container ?
VISU::Container_i* aContainer = dynamic_cast<VISU::Container_i*>(VISU::GetServant(anObject));
if(aContainer){
- MESSAGE("VisuGUI::ErasePrs : Container object");
+ if(MYDEBUG) MESSAGE("VisuGUI::ErasePrs : Container object");
PlotContainer(aContainer, VISU::eErase );
}
// is it Table ?
VISU::Table_i* aTable = dynamic_cast<VISU::Table_i*>(VISU::GetServant(anObject));
if(aTable){
- MESSAGE("VisuGUI::ErasePrs : Table object");
+ if(MYDEBUG) MESSAGE("VisuGUI::ErasePrs : Table object");
PlotTable(aTable, VISU::eErase );
}
}
//=====================================================================================
void VisuGUI::DisplayManyPrs()
{
- MESSAGE("VisuGUI::DisplayManyPrs");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayManyPrs");
SALOME_Selection* Sel = SALOME_Selection::Selection(QAD_Application::getDesktop()->getActiveStudy()->getSelection());
SALOME_ListIteratorOfListIO It( Sel->StoredIObjects() );
for ( ; It.More(); It.Next() ) {
// is it Prs3d object ?
VISU::Prs3d_i* aPrsObject = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(aCORBAObject));
if(aPrsObject){
- MESSAGE("VisuGUI::DisplayManyPrs : Prs3d object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayManyPrs : Prs3d object");
UpdateViewer(aPrsObject);
VTKViewer_ViewFrame* vf = GetVtkViewFrame();
if (vf) {
// is it Curve ?
VISU::Curve_i* aCurve = dynamic_cast<VISU::Curve_i*>(VISU::GetServant(aCORBAObject));
if(aCurve){
- MESSAGE("VisuGUI::DisplayManyPrs: Curve object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayManyPrs: Curve object");
PlotCurve(aCurve, VISU::eDisplay );
continue;
}
// is it Container ?
VISU::Container_i* aContainer = dynamic_cast<VISU::Container_i*>(VISU::GetServant(aCORBAObject));
if(aContainer){
- MESSAGE("VisuGUI::DisplayManyPrs : Container object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayManyPrs : Container object");
PlotContainer(aContainer, VISU::eDisplay );
continue;
}
// is it Table ?
VISU::Table_i* aTable = dynamic_cast<VISU::Table_i*>(VISU::GetServant(aCORBAObject));
if(aTable){
- MESSAGE("VisuGUI::DisplayManyPrs : Table object");
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayManyPrs : Table object");
PlotTable(aTable, VISU::eDisplay );
continue;
}
}
}
+//=====================================================================================
+// function : DisplayOnlyManyPrs()
+// purpose :
+//=====================================================================================
+void VisuGUI::DisplayOnlyManyPrs() {
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyManyPrs");
+ SALOME_Selection* Sel = SALOME_Selection::Selection(QAD_Application::getDesktop()->getActiveStudy()->getSelection());
+ SALOME_ListIteratorOfListIO It( Sel->StoredIObjects() );
+ bool aFirstElem = true;
+ for ( ; It.More(); It.Next() ) {
+ Handle(SALOME_InteractiveObject)& anIO = It.Value();
+ if ( anIO->hasEntry() ) {
+ SALOMEDS::Study_var aStudy = QAD_Application::getDesktop()->getActiveStudy()->getStudyDocument();
+ SALOMEDS::SObject_var aSObject = aStudy->FindObjectID( anIO->getEntry() );
+ VISU::Storable::TRestoringMap pMap;
+ if( !aSObject->_is_nil() ) {
+ CORBA::Object_var aCORBAObject = VISU::SObjectToObject(aSObject);
+ if ( !CORBA::is_nil( aCORBAObject ) ) {
+ // is it Prs3d object ?
+ VISU::Prs3d_i* aPrsObject = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(aCORBAObject));
+ if(aPrsObject){
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyManyPrs : Prs3d object");
+ UpdateViewer(aPrsObject, aFirstElem);
+ if (aFirstElem) aFirstElem = false;
+ VTKViewer_ViewFrame* vf = GetVtkViewFrame();
+ if (vf) {
+ vf->getRenderer()->ResetCameraClippingRange();
+ vf->Repaint();
+ vf->highlight(anIO, 1);
+ }
+ continue;
+ }
+ // is it Curve ?
+ VISU::Curve_i* aCurve = dynamic_cast<VISU::Curve_i*>(VISU::GetServant(aCORBAObject));
+ if(aCurve){
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyManyPrs: Curve object");
+ if (aFirstElem) {
+ PlotCurve(aCurve, VISU::eDisplayOnly );
+ aFirstElem = false;
+ }
+ else PlotCurve(aCurve, VISU::eDisplay );
+ continue;
+ }
+ // is it Container ?
+ VISU::Container_i* aContainer = dynamic_cast<VISU::Container_i*>(VISU::GetServant(aCORBAObject));
+ if(aContainer){
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyManyPrs : Container object");
+ if (aFirstElem) {
+ PlotContainer(aContainer, VISU::eDisplayOnly );
+ aFirstElem = false;
+ }
+ else PlotContainer(aContainer, VISU::eDisplay );
+ continue;
+ }
+ // is it Table ?
+ VISU::Table_i* aTable = dynamic_cast<VISU::Table_i*>(VISU::GetServant(aCORBAObject));
+ if(aTable){
+ if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyManyPrs : Table object");
+ if (aFirstElem) {
+ PlotTable(aTable, VISU::eDisplayOnly );
+ aFirstElem = false;
+ }
+ else PlotTable(aTable, VISU::eDisplay );
+ continue;
+ }
+ }
+ }
+ }
+ }
+}
+
+
//=====================================================================================
// function : EraseManyPrs()
// purpose :
//=====================================================================================
void VisuGUI::EraseManyPrs()
{
- MESSAGE("VisuGUI::EraseManyPrs");
+ if(MYDEBUG) MESSAGE("VisuGUI::EraseManyPrs");
SALOME_Selection* Sel = SALOME_Selection::Selection(QAD_Application::getDesktop()->getActiveStudy()->getSelection());
SALOME_ListIO LIO; LIO = Sel->StoredIObjects();
SALOME_ListIteratorOfListIO It( LIO );
// is it Prs3d object ?
VISU::Prs3d_i* aPrsObject = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(aCORBAObject));
if(aPrsObject){
- MESSAGE("VisuGUI::EraseManyPrs : Prs3d object");
+ if(MYDEBUG) MESSAGE("VisuGUI::EraseManyPrs : Prs3d object");
ErasePrs(aPrsObject);
VTKViewer_ViewFrame* vf = GetVtkViewFrame();
if (vf) {
// is it Curve ?
VISU::Curve_i* aCurve = dynamic_cast<VISU::Curve_i*>(VISU::GetServant(aCORBAObject));
if(aCurve){
- MESSAGE("VisuGUI::EraseManyPrs : Curve object");
+ if(MYDEBUG) MESSAGE("VisuGUI::EraseManyPrs : Curve object");
PlotCurve(aCurve, VISU::eErase );
continue;
}
// is it Container ?
VISU::Container_i* aContainer = dynamic_cast<VISU::Container_i*>(VISU::GetServant(aCORBAObject));
if(aContainer){
- MESSAGE("VisuGUI::EraseManyPrs : Container object");
+ if(MYDEBUG) MESSAGE("VisuGUI::EraseManyPrs : Container object");
PlotContainer(aContainer, VISU::eErase );
continue;
}
// is it Table ?
VISU::Table_i* aTable = dynamic_cast<VISU::Table_i*>(VISU::GetServant(aCORBAObject));
if(aTable){
- MESSAGE("VisuGUI::EraseManyPrs : Table object");
+ if(MYDEBUG) MESSAGE("VisuGUI::EraseManyPrs : Table object");
PlotTable(aTable, VISU::eErase );
continue;
}
//=====================================================================================
void VisuGUI::RecreateActor(VISU::Prs3d_i* thePrs) {
QApplication::setOverrideCursor(Qt::waitCursor);
- thePrs->Update();
- for(int i = 0, nbFrames = GetActiveStudy()->getStudyFramesCount(); i < nbFrames; i++)
- if(QAD_StudyFrame* aFrame = GetActiveStudy()->getStudyFrame(i)){
- QAD_ViewFrame* aVFrame = aFrame->getRightFrame()->getViewFrame();
- if(VTKViewer_ViewFrame* aViewFrame = dynamic_cast<VTKViewer_ViewFrame*>(aVFrame))
- if(VISU_Actor* anActor = GetActor(thePrs,aViewFrame))
- thePrs->UpdateActor(anActor);
- }
+ try{
+ thePrs->Update();
+ for(int i = 0, nbFrames = GetActiveStudy()->getStudyFramesCount(); i < nbFrames; i++)
+ if(QAD_StudyFrame* aFrame = GetActiveStudy()->getStudyFrame(i)){
+ QAD_ViewFrame* aVFrame = aFrame->getRightFrame()->getViewFrame();
+ if(VTKViewer_ViewFrame* aViewFrame = dynamic_cast<VTKViewer_ViewFrame*>(aVFrame))
+ if(VISU_Actor* anActor = GetActor(thePrs,aViewFrame))
+ thePrs->UpdateActor(anActor);
+ }
+ }catch(std::runtime_error& ex){
+ QAD_MessageBox::warn1 ( QAD_Application::getDesktop(), tr ("VISU_WARNING"),
+ tr ("ERR_CANT_BUILD_PRESENTATION"),
+ tr ("VISU_BUT_OK") );
+ }
QApplication::restoreOverrideCursor();
}
PrsName* aPrsObject = dynamic_cast<PrsName*>(aPrs3d); \
if (aPrsObject) { \
DlgName* aDlg = new DlgName(); \
- aDlg->initFromPrsObject(aPrsObject); \
+ aDlg->initFromPrsObject(aPrsObject); \
if ( aDlg->exec() ) { \
aDlg->storeToPrsObject(aPrsObject); \
RecreateActor(aPrsObject); \
/*RepaintCurrentView();*/ \
- VTKViewer_ViewFrame* vf = GetVtkViewFrame(); \
- if (vf) { \
+ if (VTKViewer_ViewFrame* vf = GetVtkViewFrame()) { \
if ( vf->getRenderer()->GetActors()->GetNumberOfItems () > 0 ) { \
vf->getRenderer()->ResetCameraClippingRange(); \
vf->onViewFitAll(); \
} \
}
-
void VisuGUI::EditPrs() {
VISU::Prs3d_i* aPrs3d = GetSelectedPrs3d();
case VISU::TSTREAMLINES:
EDITPRS(VISU::StreamLines_i, VisuGUI_StreamLinesDlg);
+ default:
+ return;
}
+
+ Handle(SALOME_InteractiveObject) anIO;
+ CORBA::Object_var anObject = GetSelectedObj(&anIO);
+ if ( !CORBA::is_nil( anObject ) )
+ if (VTKViewer_ViewFrame* vf = GetVtkViewFrame())
+ vf->highlight(anIO, 1);
}
VTKViewer_ViewFrame* vf = GetVtkViewFrame();
if (vf)
- vf->Repaint();
+ {
+ vf->Repaint();
+
+ Handle(SALOME_InteractiveObject) anIO;
+ CORBA::Object_var anObject = GetSelectedObj(&anIO);
+ if ( !CORBA::is_nil( anObject ) )
+ vf->highlight(anIO, 1);
+ }
if (aDlg->isToSave())
aDlg->storeToResources();
tr ("VISU_BUT_OK"));
return;
}
-
VISU::Storable::TRestoringMap aMap;
SALOMEDS::GenericAttribute_var anAttr;
if(aSObject->FindAttribute(anAttr, "AttributeComment")) {
Utils_Timer timer;
timer.Start();
#endif
+ VISU::Result_i* pResult = dynamic_cast<VISU::Result_i*>(VISU::GetServant(aResult.in()));
if(aComment == "ENTITY"){
VISU::Entity anEntity = (VISU::Entity)VISU::Storable::FindValue(aMap,"myId").toInt();
- aMesh = GetVisuGen()->MeshOnEntity(aResult,aMeshName.c_str(),anEntity);
+ if(VISU::Mesh_i::IsPossible(pResult,aMeshName.c_str(),anEntity))
+ aMesh = GetVisuGen()->MeshOnEntity(aResult,aMeshName.c_str(),anEntity);
}else if(aComment == "FAMILY"){
VISU::Entity anEntity = (VISU::Entity)VISU::Storable::FindValue(aMap,"myEntityId").toInt();
string aFamilyName = VISU::Storable::FindValue(aMap,"myName").latin1();
- aMesh = GetVisuGen()->FamilyMeshOnEntity(aResult,aMeshName.c_str(),anEntity,aFamilyName.c_str());
+ if(VISU::Mesh_i::IsPossible(pResult,aMeshName.c_str(),anEntity,aFamilyName.c_str()))
+ aMesh = GetVisuGen()->FamilyMeshOnEntity(aResult,aMeshName.c_str(),anEntity,aFamilyName.c_str());
}else if(aComment == "GROUP"){
string aGroupName = VISU::Storable::FindValue(aMap,"myName").latin1();
- aMesh = GetVisuGen()->GroupMesh(aResult,aMeshName.c_str(),aGroupName.c_str());
+ if(VISU::Mesh_i::IsPossible(pResult,aMeshName.c_str(),aGroupName.c_str()))
+ aMesh = GetVisuGen()->GroupMesh(aResult,aMeshName.c_str(),aGroupName.c_str());
}
#ifdef CHECKTIME
timer.Stop();
- MESSAGE("VisuGUI::CreateMesh() - CREATE MESH");
+ cout<<"VisuGUI::CreateMesh() - CREATE MESH\n";
timer.Show();
#endif
}
if(VTKViewer_ViewFrame* vf = GetVtkViewFrame()){
- VISU_Actor *anActor = pPresent->CreateActor();
- if (! anActor ) {
- QAD_MessageBox::warn1 ( QAD_Application::getDesktop(), tr ("VISU_WARNING"),
- tr ("ERR_CANT_CREATE_ACTOR"),
- tr ("VISU_BUT_OK") );
- return;
- }
+ try{
+ VISU_Actor *anActor = pPresent->CreateActor();
#ifdef CHECKTIME
- Utils_Timer timer;
- timer.Start();
+ Utils_Timer timer;
+ timer.Start();
#endif
- vf->AddActor(anActor);
- vf->getRenderer()->ResetCameraClippingRange();
- vf->onViewFitAll();
+ vf->AddActor(anActor);
+ SetFitAll(vf);
#ifdef CHECKTIME
- timer.Stop();
- MESSAGE("VisuGUI::CreateMesh() - DISPLAY MESH");
- timer.Show();
+ timer.Stop();
+ cout<<"VisuGUI::CreateMesh() - DISPLAY MESH\n";
+ timer.Show();
#endif
+ //GetActiveStudy()->updateObjBrowser(); //not necessary
+ GetDesktop()->putInfo("Ready");
+ }catch(std::runtime_error& exc){
+ QAD_MessageBox::warn1 ( QAD_Application::getDesktop(), tr ("VISU_WARNING"),
+ tr ("ERR_CANT_CREATE_ACTOR"),
+ tr ("VISU_BUT_OK") );
+ }
}
- //GetActiveStudy()->updateObjBrowser(); //not necessary
- GetDesktop()->putInfo("Ready");
}
//=====================================================================================
// function : CreateManyMesh()
// purpose :
//=====================================================================================
-void VisuGUI::CreateManyMesh()
-{
+void VisuGUI::CreateManyMesh(){
if (checkLock(GetStudyDocument())) return;
SALOME_Selection* Sel = SALOME_Selection::Selection(GetActiveStudy()->getSelection());
SALOME_ListIteratorOfListIO It( Sel->StoredIObjects() );
for ( ; It.More(); It.Next() ) {
- SALOMEDS::SObject_var aSObject = GetActiveStudy()->getStudyDocument()->FindObjectID( It.Value()->getEntry() );
-
- SALOMEDS::SObject_var aSObj = aSObject->GetFather();
- aSObj = aSObj->GetFather();
- aSObj = aSObj->GetFather();
- CORBA::Object_var anObject = VISU::SObjectToObject(aSObj);
- if(CORBA::is_nil(anObject)) {
+ SALOMEDS::SObject_var aSObject = GetStudyDocument()->FindObjectID(It.Value()->getEntry());
+ SALOMEDS::SObject_var aSObj = aSObject->GetFather();
aSObj = aSObj->GetFather();
- anObject = VISU::SObjectToObject(aSObj);
- if(CORBA::is_nil(anObject)) return;
- }
- VISU::Result_var aResult = VISU::Result::_narrow(anObject);
- if(CORBA::is_nil(aResult)) return;
-
- VISU::Storable::TRestoringMap aMap;
- SALOMEDS::GenericAttribute_var anAttr;
- if(aSObject->FindAttribute(anAttr, "AttributeComment")) {
- SALOMEDS::AttributeComment_var aComment = SALOMEDS::AttributeComment::_narrow(anAttr);
- string aComm = aComment->Value();
- QString strIn(aComm.c_str());
- VISU::Storable::StrToMap(strIn,aMap);
- }
- bool isExist;
- string aComment = VISU::Storable::FindValue(aMap,"myComment",&isExist).latin1();
- if(!isExist) return;
- CORBA::Object_var aMesh;
- string aMeshName = VISU::Storable::FindValue(aMap,"myMeshName").latin1();
- if(aComment == "ENTITY"){
- VISU::Entity anEntity = (VISU::Entity)VISU::Storable::FindValue(aMap,"myId").toInt();
- aMesh = GetVisuGen()->MeshOnEntity(aResult,aMeshName.c_str(),anEntity);
- }else if(aComment == "FAMILY"){
- VISU::Entity anEntity = (VISU::Entity)VISU::Storable::FindValue(aMap,"myEntityId").toInt();
- string aFamilyName = VISU::Storable::FindValue(aMap,"myName").latin1();
- aMesh = GetVisuGen()->FamilyMeshOnEntity(aResult,aMeshName.c_str(),anEntity,aFamilyName.c_str());
- }else if(aComment == "GROUP"){
- string aGroupName = VISU::Storable::FindValue(aMap,"myName").latin1();
- aMesh = GetVisuGen()->GroupMesh(aResult,aMeshName.c_str(),aGroupName.c_str());
- }
- QApplication::restoreOverrideCursor();
- if(CORBA::is_nil(aMesh)) return;
-
- VISU::Mesh_i* pPresent = dynamic_cast<VISU::Mesh_i*>(VISU::GetServant(aMesh));
- VISU_Actor *anActor = pPresent->CreateActor();
- if (! anActor ) return;
- if(VTKViewer_ViewFrame* vf = GetVtkViewFrame()){
- vf->AddActor(anActor);
- vf->getRenderer()->ResetCameraClippingRange();
- vf->onViewFitAll();
- }
+ aSObj = aSObj->GetFather();
+ CORBA::Object_var anObject = VISU::SObjectToObject(aSObj);
+ if(CORBA::is_nil(anObject)) {
+ aSObj = aSObj->GetFather();
+ anObject = VISU::SObjectToObject(aSObj);
+ if(CORBA::is_nil(anObject)) return;
+ }
+ VISU::Result_var aResult = VISU::Result::_narrow(anObject);
+ if(CORBA::is_nil(aResult)) return;
+
+ VISU::Storable::TRestoringMap aMap;
+ SALOMEDS::GenericAttribute_var anAttr;
+ if(aSObject->FindAttribute(anAttr, "AttributeComment")) {
+ SALOMEDS::AttributeComment_var aComment = SALOMEDS::AttributeComment::_narrow(anAttr);
+ string aComm = aComment->Value();
+ QString strIn(aComm.c_str());
+ VISU::Storable::StrToMap(strIn,aMap);
+ }
+ bool isExist;
+ string aComment = VISU::Storable::FindValue(aMap,"myComment",&isExist).latin1();
+ if(!isExist) return;
+ CORBA::Object_var aMesh;
+ string aMeshName = VISU::Storable::FindValue(aMap,"myMeshName").latin1();
+ if(aComment == "ENTITY"){
+ VISU::Entity anEntity = (VISU::Entity)VISU::Storable::FindValue(aMap,"myId").toInt();
+ aMesh = GetVisuGen()->MeshOnEntity(aResult,aMeshName.c_str(),anEntity);
+ }else if(aComment == "FAMILY"){
+ VISU::Entity anEntity = (VISU::Entity)VISU::Storable::FindValue(aMap,"myEntityId").toInt();
+ string aFamilyName = VISU::Storable::FindValue(aMap,"myName").latin1();
+ aMesh = GetVisuGen()->FamilyMeshOnEntity(aResult,aMeshName.c_str(),anEntity,aFamilyName.c_str());
+ }else if(aComment == "GROUP"){
+ string aGroupName = VISU::Storable::FindValue(aMap,"myName").latin1();
+ aMesh = GetVisuGen()->GroupMesh(aResult,aMeshName.c_str(),aGroupName.c_str());
+ }
+ QApplication::restoreOverrideCursor();
+ if(CORBA::is_nil(aMesh)) return;
+
+ VISU::Mesh_i* pPresent = dynamic_cast<VISU::Mesh_i*>(VISU::GetServant(aMesh));
+ try{
+ VISU_Actor *anActor = pPresent->CreateActor();
+ if(VTKViewer_ViewFrame* vf = GetVtkViewFrame()){
+ vf->AddActor(anActor);
+ SetFitAll(vf);
+ }
+ GetDesktop()->putInfo("Ready");
+ }catch(std::runtime_error& exc){
+ }
}
- GetDesktop()->putInfo("Ready");
}
//=====================================================================================
//=====================================================================================
static void ShrinkMesh(VISU_Actor *theActor){
- if(theActor->isShrunk())
- theActor->unShrink();
+ if(theActor->IsShrunk())
+ theActor->UnShrink();
else
- theActor->setShrink(0.8);
+ theActor->SetShrink(0.8);
}
-void VisuGUI::ChangeRepresentation(RepresentType theType) {
- if(VISU::Prs3d_i* aPrsObject = GetSelectedPrs3d()){
+void VisuGUI::ChangeRepresentation(VISU::PresentationType theType) {
+ if(VISU::Prs3d_i* aPrsObject = GetSelectedPrs3d())
if(VISU_Actor* anActor = GetActor(aPrsObject)){
switch (theType) {
- case POINTS:
- case WIREFRAME:
- case SURFACE:
- anActor->SetRepresentation(theType);
- break;
- case SHRINK:
+ case VISU::SHRINK:
ShrinkMesh(anActor);
break;
+ default:
+ if(VISU::Mesh_i* aMesh = dynamic_cast<VISU::Mesh_i*>(aPrsObject)){
+ aMesh->SetPresentationType(theType);
+ RecreateActor(aMesh);
+ }else
+ anActor->SetRepresentation(theType);
}
if (VTKViewer_ViewFrame* vf = GetVtkViewFrame())
vf->Repaint();
}
- }
}
-void VisuGUI::MakeWireframe() {
- ChangeRepresentation(WIREFRAME);
+
+void VisuGUI::MakeSurfaceframe() {
+ ChangeRepresentation(VISU::SURFACEFRAME);
}
+void VisuGUI::MakeInsideframe() {
+ ChangeRepresentation(VISU::INSIDEFRAME);
+}
-void VisuGUI::MakeSurface() {
- ChangeRepresentation(SURFACE);
+void VisuGUI::MakeWireframe() {
+ ChangeRepresentation(VISU::WIREFRAME);
}
+void VisuGUI::MakeSurface() {
+ ChangeRepresentation(VISU::SHADED);
+}
void VisuGUI::MakePoints() {
- ChangeRepresentation(POINTS);
+ ChangeRepresentation(VISU::POINT);
}
-
void VisuGUI::MakeShrink() {
- ChangeRepresentation(SHRINK);
+ ChangeRepresentation(VISU::SHRINK);
}
VISU::Prs3d_i* VisuGUI::GetSelectedPrs3d(Handle(SALOME_InteractiveObject)* theIO) {
CORBA::Object_var anObject = GetSelectedObj(theIO);
if(CORBA::is_nil(anObject)) return NULL;
- return dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(anObject));
+ PortableServer::Servant aServant = VISU::GetServant(anObject);
+ if(!aServant) return NULL;
+ return dynamic_cast<VISU::Prs3d_i*>(aServant);
}
void VisuGUI::ChageColor() {
NewColor(anActor);
}
-void VisuGUI::ChangeOutlineColor() {
+void VisuGUI::ChangeWireframeColor() {
VISU::Prs3d_i* aPrsObject = GetSelectedPrs3d();
if(!aPrsObject) return;
- VISUMesh_Actor* anActor = dynamic_cast<VISUMesh_Actor*>(GetActor(aPrsObject));
+ VISU_MeshAct* anActor = dynamic_cast<VISU_MeshAct*>(GetActor(aPrsObject));
if (!anActor) return;
- NewOutlineColor(anActor);
+ NewWireframeColor(anActor);
}
}
void VisuGUI::PlotTable( VISU::Table_i* table, int theDisplaying )
{
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
if ( table && GetActiveStudy()->getActiveStudyFrame()->getTypeView() == VIEW_PLOT2D ) {
Plot2d_ViewFrame* aPlot = (Plot2d_ViewFrame*)GetActiveStudy()->getActiveStudyFrame()->getRightFrame()->getViewFrame();
if ( theDisplaying == VISU::eDisplayOnly )
}
void VisuGUI::PlotCurve( VISU::Curve_i* theCurve, int theDisplaying )
{
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
if ( theCurve && GetActiveStudy()->getActiveStudyFrame()->getTypeView() == VIEW_PLOT2D ) {
Plot2d_ViewFrame* aPlot = (Plot2d_ViewFrame*)GetActiveStudy()->getActiveStudyFrame()->getRightFrame()->getViewFrame();
// if ( theDisplaying == VISU::eDisplayOnly )
}
void VisuGUI::PlotContainer( VISU::Container_i* container, int theDisplaying )
{
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
if ( container && GetActiveStudy()->getActiveStudyFrame()->getTypeView() == VIEW_PLOT2D ) {
Plot2d_ViewFrame* aPlot = (Plot2d_ViewFrame*)GetActiveStudy()->getActiveStudyFrame()->getRightFrame()->getViewFrame();
if ( theDisplaying == VISU::eDisplayOnly )
Slot : opens Table view : for Table object or SObject with table attribute selected
*/
void VisuGUI::ShowTable() {
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
if( Sel->IObjectCount() !=1 )
return;
Slot : opens Table view : for Table object or SObject with table attribute selected
*/
void VisuGUI::CreateTable() {
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
SALOME_Selection* aSel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
if( aSel->IObjectCount() !=1 )
return;
Opens dialog box for curves creation. Acts only for selected SObject with table attribute.
*/
void VisuGUI::PlotData() {
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
if( Sel->IObjectCount() !=1 )
return;
Slot : Opens "Setup curve" dialog to set curve properties : for Curve object selected
*/
void VisuGUI::CurveProperties() {
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
if( Sel->IObjectCount() !=1 )
return;
Slot : Clears container contents : for Container object selected
*/
void VisuGUI::ClearContainer() {
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
if( Sel->IObjectCount() !=1 )
return;
void VisuGUI::SaveViewParams()
{
if (checkLock(GetStudyDocument())) return;
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
if ( Sel->IObjectCount() > 1 || GetActiveStudy()->getActiveStudyFrame()->getTypeView() != VIEW_VTK )
return;
void VisuGUI::RestoreViewParams()
{
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
if ( Sel->IObjectCount() > 1 || GetActiveStudy()->getActiveStudyFrame()->getTypeView() != VIEW_VTK )
return;
void VisuGUI::ImportMedField() {
if (checkLock(GetStudyDocument())) return;
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
QApplication::setOverrideCursor( Qt::waitCursor );
GetActiveStudy()->updateObjBrowser( true );
QApplication::restoreOverrideCursor();
}
-/*
-void VisuGUI::ImportMedMesh() {
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
- SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
- if ( Sel->IObjectCount() != 1 )
- return;
- string aComment;
- Handle(SALOME_InteractiveObject) anIO;
- CORBA::Object_var anObject = GetSelectedObj( aComment,anIO, GetActiveStudy());
- if ( !CORBA::is_nil( anObject ) ) {
- SALOME_MED::MESH_ptr aMesh = SALOME_MED::MESH::_narrow( anObject );
- if( !CORBA::is_nil( aMesh ) ) {
- GetVisuGen->ImportMedMesh( aMesh );
- GetActiveStudy()->updateObjBrowser( true );
- }
- SALOME_MED::SUPPORT_ptr aSupport = SALOME_MED::SUPPORT::_narrow( anObject );
- if( !CORBA::is_nil( aSupport ) ) {
- GetVisuGen->ImportMedSupport( aSupport );
- GetActiveStudy()->updateObjBrowser( true );
- }
- }
-}
-*/
+
//=====================================================================================
// functions : Rename()
// purpose :
//=====================================================================================
void VisuGUI::Rename() {
if (checkLock(GetStudyDocument())) return;
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
if ( Sel->IObjectCount() != 1 )
return;
}
}
+//=====================================================================================
+// functions : RenameTable()
+// purpose :
+//=====================================================================================
+void VisuGUI::RenameTable() {
+ if (checkLock(GetStudyDocument())) return;
+ SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
+ if ( Sel->IObjectCount() != 1 )
+ return;
+ SALOMEDS::SObject_var aSObj = GetStudyDocument()->FindObjectID( Sel->firstIObject()->getEntry() );
+ if( aSObj->_is_nil() ) return;
+
+ VISU::Table_i* table = 0;
+ CORBA::Object_var anObject = GetSelectedObj();
+ if ( !CORBA::is_nil( anObject )) {
+ VISU::Base_var aVisuObj = VISU::Base::_narrow(anObject);
+ if (!CORBA::is_nil(aVisuObj) && aVisuObj->GetType() == VISU::TTABLE) {
+ // Table object
+ CORBA::Object_ptr aTable = VISU::Table::_narrow( anObject );
+ if( !CORBA::is_nil( aTable ) ) {
+ table = dynamic_cast<VISU::Table_i*>( VISU::GetServant( aTable ) );
+ }
+ }
+ }
+
+ //TEST DU PARENT == VISU
+ SALOMEDS::GenericAttribute_var anAttr;
+ SALOMEDS::AttributeName_var aName;
+ if ( aSObj->FindAttribute(anAttr, "AttributeName") ) {
+ aName = SALOMEDS::AttributeName::_narrow( anAttr );
+ QString Name = SALOMEGUI_NameDlg::getName( QAD_Application::getDesktop(), aName->Value() );
+ if ( !Name.isEmpty() ) {
+ QApplication::setOverrideCursor( Qt::waitCursor );
+ if ( table )
+ table->SetName( Name.latin1() );
+ GetActiveStudy()->renameIObject( Sel->firstIObject(), Name );
+ QApplication::restoreOverrideCursor();
+
+ //int TypeMode; bool InViewer;
+ //VISU_Actor *ActorTmp = ActorSelected(parent,InViewer,&TypeMode);
+ //ActorTmp->setName((Standard_CString)Name.latin1());
+ }
+ }
+}
+
+
+
+//=====================================================================================
+// functions : RenameContainer()
+// purpose :
+//=====================================================================================
+void VisuGUI::RenameContainer() {
+ if (checkLock(GetStudyDocument())) return;
+ SALOME_Selection* Sel = SALOME_Selection::Selection( GetActiveStudy()->getSelection() );
+ if ( Sel->IObjectCount() != 1 )
+ return;
+ SALOMEDS::SObject_var aSObj = GetStudyDocument()->FindObjectID( Sel->firstIObject()->getEntry() );
+ if( aSObj->_is_nil() ) return;
+
+ VISU::Container_i* container = 0;
+ CORBA::Object_var anObject = GetSelectedObj();
+ if ( !CORBA::is_nil( anObject )) {
+ VISU::Base_var aVisuObj = VISU::Base::_narrow(anObject);
+ if (!CORBA::is_nil(aVisuObj) && aVisuObj->GetType() == VISU::TCONTAINER) {
+ // Curve object
+ CORBA::Object_ptr aContainer = VISU::Container::_narrow( anObject );
+ if( !CORBA::is_nil( aContainer ) ) {
+ container = dynamic_cast<VISU::Container_i*>( VISU::GetServant( aContainer ) );
+ }
+ }
+ }
+
+ //TEST DU PARENT == VISU
+ SALOMEDS::GenericAttribute_var anAttr;
+ SALOMEDS::AttributeName_var aName;
+ if ( aSObj->FindAttribute(anAttr, "AttributeName") ) {
+ aName = SALOMEDS::AttributeName::_narrow( anAttr );
+ QString Name = SALOMEGUI_NameDlg::getName( QAD_Application::getDesktop(), aName->Value() );
+ if ( !Name.isEmpty() ) {
+ QApplication::setOverrideCursor( Qt::waitCursor );
+ if ( container )
+ container->SetName( Name.latin1() );
+ GetActiveStudy()->renameIObject( Sel->firstIObject(), Name );
+ QApplication::restoreOverrideCursor();
+
+ //int TypeMode; bool InViewer;
+ //VISU_Actor *ActorTmp = ActorSelected(parent,InViewer,&TypeMode);
+ //ActorTmp->setName((Standard_CString)Name.latin1());
+ }
+ }
+}
+
+
//=====================================================================================
// function : CopyPresentation()
// purpose :
//=====================================================================================
void VisuGUI::InfoOnPoint(){
- SALOME_Selection *aSel = SALOME_Selection::Selection(GetActiveStudy()->getSelection());
- int aTypeMode = aSel->SelectionMode();
- if ( aTypeMode == SelectionPoint ){
- if(VISU::Prs3d_i* aPrs3d = GetSelectedPrs3d()){
- vtkDataSet* aDataSet = aPrs3d->GetMapper()->GetInput();
- VisuGUI_Selection::PickingPoint( GetActiveStudy(), aDataSet);
- }
- }else
- QAD_MessageBox::warn1( GetDesktop(),
- tr ("WARNING"),
- tr ("ERR_WRONG_SELECTION_MODE"),
- tr ("VISU_BUT_OK") );
+ GetInfo(SelectionPoint,&(VisuGUI_Selection::PickingPoint));
}
//=====================================================================================
// purpose :
//=====================================================================================
void VisuGUI::InfoOnCell(){
+ GetInfo(SelectionCell,&(VisuGUI_Selection::PickingCell));
+}
+
+void VisuGUI::GetInfo(int theSelectionMode, TGetInfoFun theGetInfoFun){
SALOME_Selection *aSel = SALOME_Selection::Selection(GetActiveStudy()->getSelection());
- int aTypeMode = aSel->SelectionMode();
- if( aTypeMode == SelectionCell){
- if(VISU::Prs3d_i* aPrs3d = GetSelectedPrs3d()){
- vtkDataSet* aDataSet = aPrs3d->GetMapper()->GetInput();
- VisuGUI_Selection::PickingCell( GetActiveStudy(), aDataSet);
+ if ( aSel->SelectionMode() == theSelectionMode ){
+ Handle(SALOME_InteractiveObject) anIO;
+ if(VISU::Prs3d_i* aPrs3d = GetSelectedPrs3d(&anIO)){
+ TColStd_MapOfInteger aMapIndex;
+ aSel->GetIndex(anIO,aMapIndex);
+ TColStd_MapIteratorOfMapOfInteger anIter(aMapIndex);
+ if(anIter.More()){
+ vtkDataSet* aDataSet = aPrs3d->GetPipeLine()->GetMapper()->GetInput();
+ (*theGetInfoFun)(GetActiveStudy(), aDataSet, anIter.Key());
+ return;
+ }
}
+ QAD_MessageBox::warn1(QAD_Application::getDesktop(),
+ tr ("VISU_WARNING"),
+ tr ("WRN_NO_AVAILABLE_DATA"),
+ tr ("VISU_BUT_OK"));
}else
QAD_MessageBox::warn1( GetDesktop(),
tr ("WARNING"),
// purpose :
//=====================================================================================
void VisuGUI::SelectPoint(){
- SALOME_Selection *aSel = SALOME_Selection::Selection(GetActiveStudy()->getSelection());
- if ( aSel->SelectionMode() != SelectionPoint ) {
- QAD_MessageBox::warn1( GetDesktop(),
- tr ("WARNING"),
- tr ("ERR_WRONG_SELECTION_MODE"),
- tr ("VISU_BUT_OK") );
- return;
- }
- Handle(SALOME_InteractiveObject) anIO;
- if(VISU::Prs3d_i* aPrs3d = GetSelectedPrs3d(&anIO)){
- bool ok = FALSE;
- int anId = SALOMEGUI_SetValueDlg::getInteger( tr("Point selection"),
- tr("Point number:" ),
- 0,
- &ok,
- GetDesktop());
- vtkDataSet *aDataSet = aPrs3d->GetMapper()->GetInput();
- int aMaxId = aDataSet->GetNumberOfPoints();
- if (ok && 0 < anId && anId <= aMaxId )
- VisuGUI_Selection::Highlight( GetActiveStudy(), anIO, anId );
- }
+ Select(SelectionPoint,&vtkDataSet::GetNumberOfPoints,"Point selection","Point number:");
}
//=====================================================================================
// purpose :
//=====================================================================================
void VisuGUI::SelectCell(){
+ Select(SelectionCell,&vtkDataSet::GetNumberOfCells,"Cell selection","Cell number:");
+}
+
+void VisuGUI::Select(int theSelectionMode, TSelectFun theSelectFun,
+ const char* theTitle, const char* theRequest)
+{
SALOME_Selection *aSel = SALOME_Selection::Selection(GetActiveStudy()->getSelection());
- if ( aSel->SelectionMode() != SelectionCell) {
+ if(aSel->SelectionMode() == theSelectionMode){
+ Handle(SALOME_InteractiveObject) anIO;
+ if(VISU::Prs3d_i* aPrs3d = GetSelectedPrs3d(&anIO)){
+ bool ok = FALSE;
+ int anIndex = 0;
+ TColStd_MapOfInteger aMapIndex;
+ aSel->GetIndex(anIO,aMapIndex);
+ TColStd_MapIteratorOfMapOfInteger anIter(aMapIndex);
+ if(anIter.More()) anIndex = anIter.Key();
+ int anId = SALOMEGUI_SetValueDlg::getInteger( tr(theTitle),
+ tr(theRequest),
+ anIndex,
+ &ok,
+ GetDesktop());
+ if(!ok) return;
+ vtkDataSet* aDataSet = aPrs3d->GetPipeLine()->GetMapper()->GetInput();
+ int aMaxId = (aDataSet->*theSelectFun)();
+ if(0 <= anId && anId < aMaxId){
+ VisuGUI_Selection::Highlight( GetActiveStudy(), anIO, anId );
+ return;
+ }
+ }
+ QAD_MessageBox::warn1(QAD_Application::getDesktop(),
+ tr ("VISU_WARNING"),
+ tr ("WRN_NO_AVAILABLE_DATA"),
+ tr ("VISU_BUT_OK"));
+ }else
QAD_MessageBox::warn1( GetDesktop(),
tr ("WARNING"),
tr ("ERR_WRONG_SELECTION_MODE"),
tr ("VISU_BUT_OK") );
- return;
- }
- Handle(SALOME_InteractiveObject) anIO;
- if(VISU::Prs3d_i* aPrs3d = GetSelectedPrs3d(&anIO)){
- bool ok = FALSE;
- int anId = SALOMEGUI_SetValueDlg::getInteger( tr("Cell selection"),
- tr("Cell number:" ),
- 0,
- &ok,
- GetDesktop());
- vtkDataSet *aDataSet = aPrs3d->GetMapper()->GetInput();
- int aMaxId = aDataSet->GetNumberOfCells();
- if (ok && 0 < anId && anId <= aMaxId )
- VisuGUI_Selection::Highlight( GetActiveStudy(), anIO, anId );
- }
}
//=====================================================================================
//=====================================================================================
void VisuGUI::DefinePopup( QString & theContext, QString & theParent, QString & theObject )
{
- VisuGUI::GetOrCreateVisuGUI(QAD_Application::getDesktop());
theObject = "";
theContext = "";
}
const QString & theParent, const QString & theObject)
{
int isViewer = (theParent.compare("ObjectBrowser") != 0), initId = isViewer? 800: 900;
- VisuGUI::GetOrCreateVisuGUI(parent);
QAD_ResourceMgr* rmgr = parent->createResourceManager();
bool isVTKViewer = (GetActiveStudy()->getActiveStudyFrame()->getTypeView() == VIEW_VTK);
thePopup->clear();
-
- SALOME_Selection* Sel = SALOME_Selection::Selection(GetActiveStudy()->getSelection());
- if ( Sel->IObjectCount() == 0 ) {
+ SALOME_Selection* aSelection = SALOME_Selection::Selection(GetActiveStudy()->getSelection());
+ if ( aSelection->IObjectCount() == 0 ) {
if ( theParent == "Viewer" && isVTKViewer)
// Available only for VTK viewer
thePopup->insertItem( "Save view parameters", visuGUI, SLOT( SaveViewParams() ) );
return false;
}
-
- if( Sel->IObjectCount() > 1 ) {
+ if( aSelection->IObjectCount() > 1 ) {
int selMode = checkHomoSelection();
- MESSAGE( "VisuGUI::CustomPopup: multiple selection : selMode = "<<selMode );
+ if(MYDEBUG) MESSAGE("VisuGUI::CustomPopup: multiple selection : selMode = "<<selMode );
if ( selMode == homoCurves ) {
if ( GetActiveStudy()->getActiveStudyFrame()->getTypeView() == VIEW_PLOT2D ) {
thePopup->insertItem( "Display", visuGUI, SLOT( DisplayManyPrs() ) );
thePopup->insertItem( "Erase", visuGUI, SLOT( EraseManyPrs () ) );
+ thePopup->insertItem( "Display Only", visuGUI, SLOT( DisplayOnlyManyPrs() ) );
}
}
else if ( selMode == homoPresentations ) {
}
return true;
}
-
VISU::Storable::TRestoringMap aMap;
- Handle(SALOME_InteractiveObject) anIO;
+ Handle(SALOME_InteractiveObject) anIO;
CORBA::Object_var anObject = GetSelectedObj(&anIO,GetActiveStudy(),&aMap);
if (!CORBA::is_nil(anObject)) {
SALOMEDS::SObject_var aSObject = GetStudyDocument()->FindObjectID(anIO->getEntry());
VISU::Base_var aVisuObj = VISU::Base::_narrow(anObject);
if (!CORBA::is_nil(aVisuObj)) {
VISU::VISUType aType = aVisuObj->GetType();
- MESSAGE("VisuGUI::CustomPopup - VISU object :: "<<aType);
+
if(MYDEBUG) MESSAGE("VisuGUI::CustomPopup - VISU object :: "<<aType);
switch (aType) {
case VISU::TVISUGEN:
thePopup->insertItem("Import From File", visuGUI, SLOT(ImportFromFile()));
break;
case VISU::TTABLE:
+ thePopup->insertItem( "Rename...", visuGUI, SLOT( RenameTable() ) );
thePopup->insertItem( "Show Table", visuGUI, SLOT( ShowTable() ) );
thePopup->insertItem( "Create Curves", visuGUI, SLOT( PlotData() ) );
if ( GetActiveStudy()->getActiveStudyFrame()->getTypeView() == VIEW_PLOT2D ) {
if( !CORBA::is_nil( aCnt ) ) {
VISU::Container_i* container = dynamic_cast<VISU::Container_i*>( VISU::GetServant( aCnt ) );
if ( container && container->GetNbCurves() > 0 ) {
- if ( !isStudyLocked( GetActiveStudy()->getStudyDocument() ) )
+ if ( !isStudyLocked( GetActiveStudy()->getStudyDocument() ) ) {
+ thePopup->insertItem( "Rename...", visuGUI, SLOT( RenameContainer() ) );
thePopup->insertItem( "Clear", visuGUI, SLOT( ClearContainer() ) );
+ }
if ( GetActiveStudy()->getActiveStudyFrame()->getTypeView() == VIEW_PLOT2D ) {
thePopup->insertItem( "Display", visuGUI, SLOT( DisplayPrs() ) );
thePopup->insertItem( "Erase", visuGUI, SLOT( ErasePrs () ) );
{
VISU::Prs3d_i* aPrsObject = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(anObject));
if (aPrsObject) {
- VISU_Actor* anVISUActor = visuGUI->GetActor(aPrsObject);
if (isVTKViewer) {
// Add Presentation menu
- if ((aType != VISU::TSTREAMLINES) && anVISUActor) {
+ if (VISU_Actor* anVISUActor = visuGUI->GetActor(aPrsObject)){
QPopupMenu* aPresMenu = new QPopupMenu(GetDesktop());
int aRepresent = anVISUActor->GetRepresentation();
switch(aRepresent){
- case 0: //POINTS
+ case VISU::POINT :
aPresMenu->insertItem("Wireframe", visuGUI, SLOT(MakeWireframe()));
aPresMenu->insertItem("Surface", visuGUI, SLOT(MakeSurface()));
+ if (aType == VISU::TMESH || aType == VISU::TSCALARMAP || aType == VISU::TDEFORMEDSHAPE)
+ aPresMenu->insertItem("Insideframe", visuGUI, SLOT(MakeInsideframe()));
+ if (aType == VISU::TMESH)
+ aPresMenu->insertItem("Surfaceframe", visuGUI, SLOT(MakeSurfaceframe()));
break;
- case 1: //WIREFRAME
+ case VISU::WIREFRAME :
+ aPresMenu->insertItem("Points", visuGUI, SLOT(MakePoints()));
aPresMenu->insertItem("Surface", visuGUI, SLOT(MakeSurface()));
+ if (aType == VISU::TMESH || aType == VISU::TSCALARMAP || aType == VISU::TDEFORMEDSHAPE)
+ aPresMenu->insertItem("Insideframe", visuGUI, SLOT(MakeInsideframe()));
+ if (aType == VISU::TMESH)
+ aPresMenu->insertItem("Surfaceframe", visuGUI, SLOT(MakeSurfaceframe()));
+ break;
+ case VISU::SHADED :
aPresMenu->insertItem("Points", visuGUI, SLOT(MakePoints()));
+ aPresMenu->insertItem("Wireframe", visuGUI, SLOT(MakeWireframe()));
+ if (aType == VISU::TMESH || aType == VISU::TSCALARMAP || aType == VISU::TDEFORMEDSHAPE)
+ aPresMenu->insertItem("Insideframe", visuGUI, SLOT(MakeInsideframe()));
+ if (aType == VISU::TMESH)
+ aPresMenu->insertItem("Surfaceframe", visuGUI, SLOT(MakeSurfaceframe()));
break;
- case 2: //SURFACE
+ case VISU::INSIDEFRAME :
+ aPresMenu->insertItem("Points", visuGUI, SLOT(MakePoints()));
+ aPresMenu->insertItem("Surface", visuGUI, SLOT(MakeSurface()));
aPresMenu->insertItem("Wireframe", visuGUI, SLOT(MakeWireframe()));
+ if (aType == VISU::TMESH)
+ aPresMenu->insertItem("Surfaceframe", visuGUI, SLOT(MakeSurfaceframe()));
+ break;
+ case VISU::SURFACEFRAME :
aPresMenu->insertItem("Points", visuGUI, SLOT(MakePoints()));
+ aPresMenu->insertItem("Surface", visuGUI, SLOT(MakeSurface()));
+ aPresMenu->insertItem("Wireframe", visuGUI, SLOT(MakeWireframe()));
+ aPresMenu->insertItem("Insideframe", visuGUI, SLOT(MakeInsideframe()));
break;
}
- if (anVISUActor->GetShrinkable()) {
- if (anVISUActor->isShrunk())
- aPresMenu->insertItem("Unshrink", visuGUI, SLOT(MakeShrink()));
- else
- aPresMenu->insertItem("Shrink", visuGUI, SLOT(MakeShrink()));
+ if(anVISUActor->GetShrinkable())
+ if(aType != VISU::TVECTORS && aType != VISU::TSTREAMLINES){
+ if (anVISUActor->IsShrunk())
+ aPresMenu->insertItem("Unshrink", visuGUI, SLOT(MakeShrink()));
+ else
+ aPresMenu->insertItem("Shrink", visuGUI, SLOT(MakeShrink()));
+ }
+ thePopup->insertItem("Representation", aPresMenu);
+
+ // Add Properties
+ QPopupMenu* aPropMenu = new QPopupMenu(GetDesktop());
+ if(aType == VISU::TMESH){
+ if(aRepresent == VISU::SURFACEFRAME){
+ aPropMenu->insertItem("Cell Color", visuGUI, SLOT(ChageColor()));
+ aPropMenu->insertItem("Edge Color", visuGUI, SLOT(ChangeWireframeColor()));
+ }else
+ aPropMenu->insertItem("Color", visuGUI, SLOT(ChageColor()));
+ }else if(aType == VISU::TDEFORMEDSHAPE)
+ aPropMenu->insertItem("Color", visuGUI, SLOT(ChageColor()));
+
+ if (aType != VISU::TVECTORS && aType != VISU::TSTREAMLINES)
+ aPropMenu->insertItem("Opacity", visuGUI, SLOT(ChangeOpacity()));
+ if (aType != VISU::TVECTORS){
+ aPropMenu->insertItem("Line width", visuGUI, SLOT(ChangeLines()));
+ thePopup->insertItem("Properties", aPropMenu);
}
- thePopup->insertItem("Representation", aPresMenu);
+ thePopup->insertSeparator();
}
-
- // Add Properties
- QPopupMenu* aPropMenu = new QPopupMenu(GetDesktop());
- if ((aType == VISU::TMESH) ||
- (aType == VISU::TDEFORMEDSHAPE) ||
- (aType == VISU::TVECTORS) ||
- (aType == VISU::TSTREAMLINES))
- aPropMenu->insertItem("Color", visuGUI, SLOT(ChageColor()));
- if (aType == VISU::TMESH)
- aPropMenu->insertItem("Outline Color", visuGUI, SLOT(ChangeOutlineColor()));
-
- if ((aType != VISU::TVECTORS) && (aType != VISU::TSTREAMLINES))
- aPropMenu->insertItem("Opacity", visuGUI, SLOT(ChangeOpacity()));
- aPropMenu->insertItem("Line width", visuGUI, SLOT(ChangeLines()));
- thePopup->insertItem("Properties", aPropMenu);
-
- thePopup->insertSeparator();
}
thePopup->insertItem("Rename...", visuGUI, SLOT(Rename()));
if (aType != VISU::TMESH) {
thePopup->insertItem("Edit...", visuGUI, SLOT(EditPrs()));
thePopup->insertItem("Edit Scalar Bar...", visuGUI, SLOT(EditScalarBar()));
- if ((aType != VISU::TVECTORS) && (aType != VISU::TSTREAMLINES)
- && (aType != VISU::TCUTLINES) && isVTKViewer)
- thePopup->insertItem("Sweep", visuGUI, SLOT(Sweep()));
-
if (aType == VISU::TCUTLINES)
thePopup->insertItem( "Create Table", visuGUI, SLOT( CreateTable() ) );
+
+ thePopup->insertItem("Sweep", visuGUI, SLOT(Sweep()));
+
}
if (isVTKViewer) {
if ( theParent == "Viewer" &&
aType == VISU::TSCALARMAP ||
aType == VISU::TDEFORMEDSHAPE ) ) {
thePopup->insertSeparator();
- if ( Sel->SelectionMode() == SelectionPoint ) {
- thePopup->insertItem("Results at Point", visuGUI, SLOT(InfoOnPoint()));
+ TColStd_MapOfInteger aMapIndex;
+ aSelection->GetIndex(anIO,aMapIndex);
+ if ( aSelection->SelectionMode() == SelectionPoint ) {
+ if(aMapIndex.Extent() == 1)
+ thePopup->insertItem("Results at Point", visuGUI, SLOT(InfoOnPoint()));
thePopup->insertItem("Select a Point", visuGUI, SLOT(SelectPoint()));
}
- else if ( Sel->SelectionMode() == SelectionCell) {
- thePopup->insertItem("Results on Cell", visuGUI, SLOT(InfoOnCell()));
+ else if ( aSelection->SelectionMode() == SelectionCell) {
+ if(aMapIndex.Extent() == 1)
+ thePopup->insertItem("Results on Cell", visuGUI, SLOT(InfoOnCell()));
thePopup->insertItem("Select a Cell", visuGUI, SLOT(SelectCell()));
}
}
thePopup->insertSeparator();
- if (visuGUI->IsDisplayed(aPrsObject) )
+
+ if (visuGUI->IsDisplayed(aPrsObject) ){
thePopup->insertItem("Erase", visuGUI, SLOT(ErasePrs()));
+ }
else
thePopup->insertItem("Display", visuGUI, SLOT(DisplayPrs()));
}
return false;
}
+
else {
- // possibly this is the MED field/mesh and suppot objects
+ // possibly this is the MED field/mesh and support objects
SALOME_MED::MED_ptr aMED = SALOME_MED::MED::_narrow( anObject );
if(!CORBA::is_nil(aMED))
thePopup->insertItem( "Import Structure", visuGUI, SLOT( ImportMedField() ) );
BEGIN_OF("VisuGUI::BuildPresentation");
if (theIO.IsNull()) {
- MESSAGE("VisuGUI::BuildPresentation(): null SALOME_InteractiveObject passed");
+ if(MYDEBUG) MESSAGE("VisuGUI::BuildPresentation(): null SALOME_InteractiveObject passed");
return;
}
- /* Create or retrieve an object VisuGUI */
-
- VisuGUI::GetOrCreateVisuGUI(QAD_Application::getDesktop());
-
SALOMEDS::Study_var aStudy = GetActiveStudy()->getStudyDocument();
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
SALOMEDS::SObject_var aSObj = aStudy -> FindObjectID ( theIO->getEntry() );
SCRUTE(aSObj);
if (aSObj -> _is_nil() ) {
- MESSAGE("No SObject for interacative object is found");
+ if(MYDEBUG) MESSAGE("No SObject for interacative object is found");
return;
}
CORBA::Object_var anObject = VISU::SObjectToObject(aSObj);
if(!CORBA::is_nil(anObject)) {
-
VISU::Prs3d_i* aPrsObject = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(anObject));
if ( !aPrsObject ) {
- MESSAGE("The object is not VISU::Prs3d_i");
+ if(MYDEBUG) MESSAGE("The object is not VISU::Prs3d_i");
return;
}
VISU_Actor *SelectedActor = visuGUI->GetActor(aPrsObject);
- if ( ! SelectedActor )
- SelectedActor = aPrsObject -> CreateActor();
- SCRUTE(SelectedActor);
- if ( SelectedActor == NULL ) {
- MESSAGE("VisuGUI::BuildPresentation(): actor doesn't exist in Render");
- return;
- }
- VTKViewer_ViewFrame* vf = GetVtkViewFrame();
- vf->AddActor(SelectedActor);
- }
- else {
- MESSAGE("CORBA::is_nil(anObject) = true");
- }
+ if(!SelectedActor)
+ try{
+ SelectedActor = aPrsObject -> CreateActor();
+ if(VTKViewer_ViewFrame* vf = GetVtkViewFrame())
+ vf->AddActor(SelectedActor);
+ }catch(std::runtime_error& exc){
+ }
+ }else
+ if(MYDEBUG) MESSAGE("CORBA::is_nil(anObject) = true");
END_OF("VisuGUI::BuildPresentation");
-
}
extern "C"
bool OnGUIEvent(int theCommandID, QAD_Desktop* parent)
{
- //MESSAGE("VisuGUI::OnGUIEvent "<< theCommandID);
+ //if(MYDEBUG) MESSAGE("VisuGUI::OnGUIEvent "<< theCommandID);
return VisuGUI::OnGUIEvent(theCommandID, parent);
}
bool OnKeyPress (QKeyEvent* pe, QAD_Desktop* parent, QAD_StudyFrame* studyFrame)
{
- MESSAGE("VisuGUI::OnKeyPress ");
+ if(MYDEBUG) MESSAGE("VisuGUI::OnKeyPress ");
return VisuGUI::OnKeyPress (pe, parent, studyFrame);
}
bool OnMousePress (QMouseEvent* pe, QAD_Desktop* parent, QAD_StudyFrame* studyFrame)
{
- //MESSAGE("VisuGUI::OnMousePress ");
+ //if(MYDEBUG) MESSAGE("VisuGUI::OnMousePress ");
return VisuGUI::OnMousePress (pe, parent, studyFrame);
}
bool OnMouseMove (QMouseEvent* pe, QAD_Desktop* parent, QAD_StudyFrame* studyFrame)
{
- //MESSAGE("VisuGUI::OnMouseMove ");
+ //if(MYDEBUG) MESSAGE("VisuGUI::OnMouseMove ");
return VisuGUI::OnMouseMove (pe, parent, studyFrame);
}
//
void VisuGUI::NewColor(VISU_Actor *theActor){
- if(VISU::Prs3d_i* aPrs3d = theActor->getPrs3d()){
- SALOMEDS::Color anOldColor = aPrs3d->GetColor(), aNewColor;
+ if(VISU::Prs3d_i* aPrs3d = theActor->GetPrs3d()){
+ VISU::Mesh_i* aMesh = dynamic_cast<VISU::Mesh_i*>(aPrs3d);
+ VISU::DeformedShape_i* aDeformedShape = dynamic_cast<VISU::DeformedShape_i*>(aPrs3d);
+ SALOMEDS::Color anOldColor, aNewColor;
+ int aRepresent = theActor->GetRepresentation();
+ if(aMesh)
+ switch(aRepresent){
+ case VISU::POINT :
+ anOldColor = aMesh->GetNodeColor();
+ break;
+ case VISU::WIREFRAME :
+ case VISU::INSIDEFRAME :
+ anOldColor = aMesh->GetLinkColor();
+ break;
+ case VISU::SHADED :
+ case VISU::SURFACEFRAME :
+ anOldColor = aMesh->GetCellColor();
+ break;
+ }
+ else if(aDeformedShape)
+ anOldColor = aDeformedShape->GetColor();
+ else
+ return;
QColor aColor = QColor(int(255*anOldColor.R),int(255*anOldColor.G),int(255*anOldColor.B));
QColor aColorNew = QColorDialog::getColor(aColor, GetDesktop());
if(aColorNew.isValid()){
aNewColor.R = aColorNew.red()/255.;
aNewColor.G = aColorNew.green()/255.;
aNewColor.B = aColorNew.blue()/255.;
- aPrs3d->SetColor(aNewColor);
- aPrs3d->Update();
- for(int i = 0, nbFrames = GetActiveStudy()->getStudyFramesCount(); i < nbFrames; i++)
- if(QAD_StudyFrame* aFrame = GetActiveStudy()->getStudyFrame(i)){
- QAD_ViewFrame* aVFrame = aFrame->getRightFrame()->getViewFrame();
- if(VTKViewer_ViewFrame* aViewFrame = dynamic_cast<VTKViewer_ViewFrame*>(aVFrame))
- if(VISU_Actor* anActor = GetActor(aPrs3d,aViewFrame))
- aPrs3d->UpdateActor(anActor);
+ if(aMesh)
+ switch(aRepresent){
+ case VISU::POINT :
+ aMesh->SetNodeColor(aNewColor);
+ break;
+ case VISU::WIREFRAME :
+ case VISU::INSIDEFRAME :
+ aMesh->SetLinkColor(aNewColor);
+ break;
+ case VISU::SHADED :
+ case VISU::SURFACEFRAME :
+ aMesh->SetCellColor(aNewColor);
+ break;
}
+ else
+ aDeformedShape->SetColor(aNewColor);
+ RecreateActor(aPrs3d);
}
}
}
-void VisuGUI::NewOutlineColor(VISUMesh_Actor *theActor){
- if(VISU::Mesh_i* aPrs3d = dynamic_cast<VISU::Mesh_i*>(theActor->getPrs3d())){
- SALOMEDS::Color anOldColor = aPrs3d->GetColor(), aNewColor;
- QColor aColor = QColor(int(255*anOldColor.R),int(255*anOldColor.G),int(255*anOldColor.B));
- QColor aColorNew = QColorDialog::getColor(aColor, GetDesktop());
- if(aColorNew.isValid()){
- aNewColor.R = aColorNew.red()/255.;
- aNewColor.G = aColorNew.green()/255.;
- aNewColor.B = aColorNew.blue()/255.;
- aPrs3d->SetLinkColor(aNewColor);
- for(int i = 0, nbFrames = GetActiveStudy()->getStudyFramesCount(); i < nbFrames; i++)
- if(QAD_StudyFrame* aFrame = GetActiveStudy()->getStudyFrame(i)){
- QAD_ViewFrame* aVFrame = aFrame->getRightFrame()->getViewFrame();
- if(VTKViewer_ViewFrame* aViewFrame = dynamic_cast<VTKViewer_ViewFrame*>(aVFrame))
- if(VISU_Actor* anActor = GetActor(aPrs3d,aViewFrame))
- aPrs3d->UpdateActor(anActor);
- }
+void VisuGUI::NewWireframeColor(VISU_MeshAct *theActor){
+ if(VISU::Prs3d_i* aPrs3d = theActor->GetPrs3d()){
+ if(VISU::Mesh_i* aMesh = dynamic_cast<VISU::Mesh_i*>(aPrs3d)){
+ SALOMEDS::Color anOldColor = aMesh->GetLinkColor(), aNewColor;
+ QColor aColor = QColor(int(255*anOldColor.R),int(255*anOldColor.G),int(255*anOldColor.B));
+ QColor aColorNew = QColorDialog::getColor(aColor, GetDesktop());
+ if(aColorNew.isValid()){
+ aNewColor.R = aColorNew.red()/255.;
+ aNewColor.G = aColorNew.green()/255.;
+ aNewColor.B = aColorNew.blue()/255.;
+ aMesh->SetLinkColor(aNewColor);
+ VisuGUI::RecreateActor(aMesh);
+ }
}
}
}
/* ======================================================================================== */
VISU::Result_i* VisuGUI::CreatePresent(SALOMEDS::SObject_var theField, VISU::Result_var& theResult){
if(MYDEBUG) MESSAGE("VisuGUI::CreatePresent");
- VisuGUI::GetOrCreateVisuGUI( QAD_Application::getDesktop() );
SALOMEDS::SObject_var aSObj = theField->GetFather();
if (CORBA::is_nil(aSObj)) return NULL;
aSObj = aSObj->GetFather(); if (CORBA::is_nil(aSObj)) return NULL;
#define CREATEPRS(PRSTYPE, FNAME, FCREATE) \
PRSTYPE* FNAME(SALOMEDS::SObject_var theField, \
const char* theMeshName, VISU::Entity theEntity, \
- const char* theFieldName, double theTimeId) {\
+ const char* theFieldName, int theTimeId) {\
VISU::Result_var aResult; \
VISU::Result_i* pResult = CreatePresent(theField,aResult); \
if(pResult != NULL){ \
QString aTimeStampId = VISU::Storable::FindValue(aMap,"myTimeStampId",&isExist).latin1(); \
Utils_Timer timer; \
if(MYCHECKTIME) timer.Start(); \
- TYPE* pPresent = FCREATE(theField,aMeshName,(VISU::Entity)anEntity.toInt(),aFieldName,aTimeStampId.toDouble()); \
+ TYPE* pPresent = FCREATE(theField,aMeshName,(VISU::Entity)anEntity.toInt(),aFieldName,aTimeStampId.toInt()); \
if(MYCHECKTIME) { \
timer.Stop(); \
- MESSAGE("BUILDPRS(TYPE, FCREATE, FNAME, DLGNAME) - CREATE PRSOBJECT"); \
+ cout<<"BUILDPRS(TYPE, FCREATE, FNAME, DLGNAME) - CREATE PRSOBJECT\n"; \
timer.Show(); \
} \
if (pPresent) { \
- DLGNAME* aDlg = new DLGNAME(); \
- aDlg->initFromPrsObject(pPresent); \
- if (aDlg->exec()) { \
- aDlg->storeToPrsObject(pPresent); \
- } else { \
- DeletePresentation(pPresent); \
+ QString aValue = QAD_CONFIG->getSetting("Visu:BuildDefaultPrs3d"); \
+ if(aValue.isEmpty() || (!aValue.isEmpty() && !aValue.toInt())){ \
+ DLGNAME* aDlg = new DLGNAME(); \
+ aDlg->initFromPrsObject(pPresent); \
+ if (aDlg->exec()) { \
+ aDlg->storeToPrsObject(pPresent); \
+ } else { \
+ DeletePresentation(pPresent); \
+ delete aDlg; \
+ return false; \
+ } \
delete aDlg; \
- return false; \
} \
- delete aDlg; \
CreateActor(pPresent); \
return true; \
} \
flt.append( "Files (*.xls *.txt *.tab)" );
flt.append( "All Files (*.*)" );
QString aDir = getVisuInputDir();
- QString aFile = QAD_FileDlg::getFileName(QAD_Application::getDesktop(),
+ QFileInfo aFileInfo = QAD_FileDlg::getFileName(QAD_Application::getDesktop(),
aDir,flt,tr("Import From File"),true);
- if(!aFile.isEmpty()){
- QAD_Application::getDesktop()->putInfo( "Importing From File " + aFile + "..." );
- aDir = QAD_Tools::getDirFromPath(aFile);
+
+ if(aFileInfo.exists()){
+ QAD_Application::getDesktop()->putInfo( "Importing From File " + aFileInfo.filePath() + "..." );
+ aDir = QAD_Tools::getDirFromPath(aFileInfo.filePath());
QAD_CONFIG->addSetting("Visu:InputDir",aDir);
- QApplication::setOverrideCursor( Qt::waitCursor );
- QAD_PyInterp* myPyInterp = GetActiveStudy()->get_PyInterp();
- myPyInterp->run("import VisuGUI");
- myPyInterp->run("reload(VisuGUI)");
- myPyInterp->run("VisuGUI.AddTablesInStudyFromFile('"+aFile+"')");
- // VISU::Result_var aResult = myComponent->ImportFile(aFile.latin1());
- // if(aResult->_is_nil())
- // QAD_MessageBox::warn1 ( QAD_Application::getDesktop(), tr ("VISU_WARNING"),
- // tr ("There is an error in imported file"),
- // tr ("VISU_BUT_OK") );
- // else
- // QAD_Application::getDesktop()->putInfo(aFile+" imported.");
+ QAD_WaitCursor wc;
+
+ CORBA::Object_var anObject;
+#ifdef CHECKTIME
+ Utils_Timer timer;
+ timer.Start();
+#endif
+
+ anObject=GetVisuGen()->ImportTables(aFileInfo.filePath());
+
+#ifdef CHECKTIME
+ timer.Stop();
+ cout<<"VisuGUI::ImportTablesFromFile() - IMPORT FILE\n";
+ timer.Show();
+#endif
+
+ if(CORBA::is_nil(anObject)) {
+ wc.stop();
+ QAD_MessageBox::warn1 ( QAD_Application::getDesktop(), tr ("VISU_WARNING"),
+ tr ("ERR_ERROR_IN_THE_FILE"),
+ tr ("VISU_BUT_OK") );
+ wc.start();
+ }
+ else {
+ QAD_Application::getDesktop()->putInfo(aFileInfo.filePath()+" imported.");
+ }
GetActiveStudy()->updateObjBrowser(); //update Object browser
- QApplication::restoreOverrideCursor();
}
}
//flt.append( "Exportable Files (*.med *.dat)" );
//flt.append( "Dat Files (*.dat)" );
flt.append( "Med Files (*.med)" );
- flt.append( "Dat Files (*.xls)" );
QString aDir = getVisuInputDir();
- QFileInfo aFileInfo = QAD_FileDlg::getFileName(QAD_Application::getDesktop(),
- aDir,flt,tr("Import From File"),true);
+ QFileInfo aFileInfo = VisuGUI_FileDlg::getFileName(QAD_Application::getDesktop(),
+ aDir,flt,tr("Import From File"),true);
+
if(aFileInfo.exists()){
QAD_Application::getDesktop()->putInfo( "Importing From File " + aFileInfo.filePath() + "..." );
aDir = QAD_Tools::getDirFromPath(aFileInfo.filePath());
QAD_CONFIG->addSetting("Visu:InputDir",aDir);
QAD_WaitCursor wc;
-
- CORBA::Object_var anObject;
+
+ VISU::Result_var aResult;
+
#ifdef CHECKTIME
Utils_Timer timer;
timer.Start();
#endif
- if(aFileInfo.extension(false) == "med")
- anObject = GetVisuGen()->ImportFile(aFileInfo.filePath());
- else if(aFileInfo.extension(false) == "xls")
- anObject = GetVisuGen()->ImportTables(aFileInfo.filePath());
+ if(aFileInfo.extension(false) == "med"){
+ QString IsBuild = QAD_CONFIG->getSetting("Visu:BuildResult");
+ bool isBuild = (IsBuild.isEmpty()? 0 : IsBuild.toInt());
+
+ if (VisuGUI_FileDlg::IsBuild)
+ {
+ aResult = GetVisuGen()->ImportFile(aFileInfo.filePath());
+ if(!CORBA::is_nil(aResult.in())) aResult->BuildAll();
+ }
+ else
+ {
+ QAD_CONFIG->addSetting( "Visu:BuildResult", false );
+ aResult=GetVisuGen()->ImportFile( aFileInfo.filePath() );
+ QAD_CONFIG->addSetting( "Visu:BuildResult", isBuild );
+ }
+ }
+
#ifdef CHECKTIME
timer.Stop();
- MESSAGE("VisuGUI::ImportFromFile() - IMPORT FILE");
+ cout<<"VisuGUI::ImportFromFile() - IMPORT FILE\n";
timer.Show();
#endif
- if(CORBA::is_nil(anObject)) {
+ if(CORBA::is_nil(aResult.in())) {
wc.stop();
QAD_MessageBox::warn1 ( QAD_Application::getDesktop(), tr ("VISU_WARNING"),
tr ("ERR_ERROR_IN_THE_FILE"),
if(MYDEBUG) MESSAGE("VisuGUI::TestObjectBrowser");
Handle(SALOME_InteractiveObject) anIO;
CORBA::Object_var anObject = GetSelectedObj(&anIO);
- if(anIO->hasEntry()){
+ if(!anIO.IsNull() && anIO->hasEntry()){
objVisu = GetStudyDocument()->FindObjectID(anIO->getEntry());
QString aValue = getValue(objVisu,"myType");
if((VISU::VISUType)aValue.toInt() == VISU::TTIMESTAMP) return true;
vtkActorCollection *anActColl = vf->getRenderer()->GetActors();
for(anActColl->InitTraversal(); (anActor = anActColl->GetNextActor()) != NULL;)
if(VISU_Actor* anVISUActor = dynamic_cast<VISU_Actor*>(anActor))
- if(thePrs == anVISUActor->getPrs3d())
+ if(thePrs == anVISUActor->GetPrs3d())
return anVISUActor->GetParent();
return NULL;
}
for(anActColl->InitTraversal(); (anActor = anActColl->GetNextActor()) != NULL; ){
if(anActor->IsA("VISU_Actor")){
anVISUActor = VISU_Actor::SafeDownCast(anActor);
- VISU::Prs3d_i* aPrs = anVISUActor->getPrs3d();
+ VISU::Prs3d_i* aPrs = anVISUActor->GetPrs3d();
if(aPrs == NULL) continue;
if (thePrs == aPrs) {
aResActor = anVISUActor->GetParent();
thePrs->UpdateActor(aResActor);
aResActor->VisibilityOn();
+
} else if (theDispOnly) {
- anVISUActor->VisibilityOff();
+ anVISUActor->GetParent()->VisibilityOff();
}
}
}
if (aResActor) return aResActor;
- anVISUActor = thePrs->CreateActor();
- MESSAGE("UpdateViewer - thePrs->CreateActor() = "<<anVISUActor);
- if ( anVISUActor ) {
+ try{
+ anVISUActor = thePrs->CreateActor();
vf->AddActor(anVISUActor);
- } else
+ }catch(std::runtime_error& exc){
QAD_MessageBox::warn1 ( QAD_Application::getDesktop(), tr ("VISU_WARNING"),
tr ("ERR_CANT_VISUALIZE_OBJECT"),
tr ("VISU_BUT_OK") );
+ anVISUActor = NULL;
+ }
return anVISUActor;
}
* Creates new actor of presentation
*/
void VisuGUI::CreateActor(VISU::Prs3d_i* thePrs) {
- if (!thePrs) return;
+ if (!thePrs) return;
QApplication::setOverrideCursor( Qt::waitCursor );
- VTKViewer_ViewFrame* vf = GetVtkViewFrame();
- if (vf) {
+ if(VTKViewer_ViewFrame* vf = GetVtkViewFrame()){
#ifdef CHECKTIME
- Utils_Timer timer;
- timer.Start();
+ Utils_Timer timer;
+ timer.Start();
#endif
- VISU_Actor* aActor = thePrs->CreateActor();
- if ( ! aActor ) {
+ try{
+ VISU_Actor* aActor = thePrs->CreateActor();
+ vf->AddActor(aActor);
+ }catch(std::runtime_error& exc){
QApplication::restoreOverrideCursor();
QAD_MessageBox::warn1 ( QAD_Application::getDesktop(), tr ("VISU_WARNING"),
- tr ("WRN_CANT_VISUALIZE_PRS"),
- tr ("VISU_BUT_OK") );
- return;
+ tr ("WRN_CANT_VISUALIZE_PRS"),
+ tr ("VISU_BUT_OK") );
}
- vf->AddActor(aActor);
#ifdef CHECKTIME
- timer.Stop();
- MESSAGE("VisuGUI::CreateActor(VISU::Prs3d_i* thePrs) - DISPLAY ACTOR");
- timer.Show();
+ timer.Stop();
+ cout<<"VisuGUI::CreateActor(VISU::Prs3d_i* thePrs) - DISPLAY ACTOR\n";
+ timer.Show();
#endif
}
QApplication::restoreOverrideCursor();
#include CORBA_SERVER_HEADER(SALOMEDS_Attributes)
#include "QAD_Desktop.h"
-#include "VISU_Actor.h"
-#include "VISU_PrsObject_i.hh"
-#include "VISU_Table_i.hh"
-#include "VISU_ViewManager_i.hh"
+class VTKViewer_ViewFrame;
+
+#include "VISUConfig.hh"
+class VISU_Actor;
+class VISU_MeshAct;
+class VISU_ScalarMapAct;
+
+#include <vtkDataSet.h>
+class vtkRenderer;
#include <TColStd_MapOfInteger.hxx>
#include <TColStd_MapIteratorOfMapOfInteger.hxx>
#include "SALOME_ListIteratorOfListIO.hxx"
-class vtkRenderer;
+namespace VISU{
+ class VISU_Gen_i;
-enum RepresentType { POINTS, WIREFRAME, SURFACE, SHRINK };
+ class Result_i;
+ class Prs3d_i;
+ class ScalarMap_i;
+ class DeformedShape_i;
+ class IsoSurfaces_i;
+ class CutPlanes_i;
+ class CutLines_i;
+ class Vectors_i;
+ class StreamLines_i;
+ class Table_i;
+ class Curve_i;
+ class Container_i;
+}
// ======================================================================
// CLASS VIUSGUI
// ======================================================================
//
+
class VisuGUI : public QObject{
Q_OBJECT;
public:
VisuGUI();
~VisuGUI();
-
+
static VISU::VISU_Gen_i* GetVisuGen();
static QAD_Desktop* GetDesktop();
static SALOMEDS::StudyBuilder_var NewBuilder();
static VISU::Storable::TRestoringMap getMapOfValue(SALOMEDS::SObject_var theSObject);
- static VisuGUI* GetOrCreateVisuGUI(QAD_Desktop* desktop);
- static VisuGUI* GetVisuGUI() ;
-
static VISU::Result_i* CreatePresent(SALOMEDS::SObject_var theField, VISU::Result_var& theResult);
+ enum CameraOrient {e3D, eFront, eLeft, eTop};
+ static CameraOrient SetFitAll( VTKViewer_ViewFrame* vf);
+
bool CreateScalarMap(SALOMEDS::SObject_var theField);
static VISU::ScalarMap_i* CreateScalarMapPrs(SALOMEDS::SObject_var theField,
const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theTimeId);
+ const char* theFieldName, int theTimeId);
bool CreateDeformedShape(SALOMEDS::SObject_var theField);
static VISU::DeformedShape_i* CreateDeformedShapePrs(SALOMEDS::SObject_var theField,
const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theTimeId);
+ const char* theFieldName, int theTimeId);
bool CreateVectors(SALOMEDS::SObject_var theField);
static VISU::Vectors_i* CreateVectorsPrs(SALOMEDS::SObject_var theField,
const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theTimeId);
+ const char* theFieldName, int theTimeId);
bool CreateIsoSurfaces(SALOMEDS::SObject_var theField);
static VISU::IsoSurfaces_i* CreateIsoSurfacesPrs(SALOMEDS::SObject_var theField,
const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theTimeId);
+ const char* theFieldName, int theTimeId);
bool CreateCutPlanes(SALOMEDS::SObject_var theField);
static VISU::CutPlanes_i* CreateCutPlanesPrs(SALOMEDS::SObject_var theField,
const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theTimeId);
+ const char* theFieldName, int theTimeId);
bool CreateCutLines(SALOMEDS::SObject_var theField);
static VISU::CutLines_i* CreateCutLinesPrs(SALOMEDS::SObject_var theField,
const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theTimeId);
+ const char* theFieldName, int theTimeId);
bool CreateStreamLines(SALOMEDS::SObject_var theField);
static VISU::StreamLines_i* CreateStreamLinesPrs(SALOMEDS::SObject_var theField,
const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theTimeId);
+ const char* theFieldName, int theTimeId);
bool TestObjectBrowser(SALOMEDS::SObject_var& objVisu);
+
+ typedef void (*TGetInfoFun)(QAD_Study *theActiveStudy, vtkDataSet *theDataSet, int theId);
+ void GetInfo(int theSelectionMode, TGetInfoFun theGetInfoFun);
+
+ typedef int (vtkDataSet::* TSelectFun)();
+ void Select(int theSelectionMode, TSelectFun theSelectFun,
+ const char* theTitle, const char* theRequest);
static void ShowTrihedron(bool Show);
static void ChangeViewer(int theType);
static void NewColor(VISU_Actor *Actor);
- static void NewOutlineColor(VISUMesh_Actor *Actor);
+ static void NewWireframeColor(VISU_MeshAct *Actor);
static void NewOpacity(VISU_Actor *Actor);
static void NewLinewidth(VISU_Actor *Actor);
void ErasePrs(VISU::Prs3d_i* thePrs);
static VISU::Prs3d_i* GetSelectedPrs3d(Handle(SALOME_InteractiveObject)* theIO = NULL);
- void RecreateActor(VISU::Prs3d_i* thePrs);
+ static void RecreateActor(VISU::Prs3d_i* thePrs);
static void CreateActor(VISU::Prs3d_i* thePrs);
- static VISU_Actor *GetActor(int* theSelectionType = NULL);
static VISU_Actor* GetActor(VISU::Prs3d_i* thePrs, VTKViewer_ViewFrame* theViewFrame = NULL);
- void VisuGUI::ChangeRepresentation(RepresentType theType);
+ void VisuGUI::ChangeRepresentation(VISU::PresentationType theType);
void DeletePresentation(VISU::Prs3d_i* thePrs);
void SetState(int aState );
void EditPrs();
void EditScalarBar();
void DisplayManyPrs();
+ void DisplayOnlyManyPrs();
void EraseManyPrs();
+ void MakeSurfaceframe();
+ void MakeInsideframe();
void MakeWireframe();
void MakeSurface();
void MakePoints();
void MakeShrink();
void ChageColor();
- void ChangeOutlineColor();
+ void ChangeWireframeColor();
void ChangeOpacity();
void ChangeLines();
void DeletePrs();
void Rename();
+ void RenameTable();
+ void RenameContainer();
void Sweep();
void TimeAnimation();
void InfoOnPoint();
void InfoOnCell();
+
void SelectPoint();
void SelectCell();
-
+
private :
QDialog* myActiveDialogBox;
int myState ;
// Module : VISU
#include "VisuGUI_CutLinesDlg.h"
-#include <qlayout.h>
-#include <qhbox.h>
-#include <qtabwidget.h>
+#include "VISU_CutLines_i.hh"
#include "QAD_Application.h"
#include "QAD_Desktop.h"
+#include <qlayout.h>
+#include <qhbox.h>
+#include <qtabwidget.h>
+#include <qhgroupbox.h>
+
+using namespace std;
VisuGUI_CutLinesDlg::VisuGUI_CutLinesDlg()
: QDialog( QAD_Application::getDesktop(), "VisuGUI_CutLinesDlg", true, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu )
{
setCaption( "Cut Lines Definition" );
setSizeGripEnabled( true );
-
+
QVBoxLayout* aMainLayout = new QVBoxLayout(this, 7, 6);
aMainLayout->setSpacing(5);
+ hasInit = false;
+
// Tab pane
QTabWidget* aTabPane = new QTabWidget(this);
// Plane of lines
QFrame* aPlanePane = new QFrame(this);
QVBoxLayout* aPlaneLayout = new QVBoxLayout( aPlanePane, 5, 6 );
- aPlaneLayout->addStretch();
-
+
mySelPlane = new QHButtonGroup( tr( "TXT_ORIENTATION" ), aPlanePane);
mySelPlane->setInsideSpacing( 5 );
mySelPlane->setInsideMargin( 5 );
- connect(mySelPlane, SIGNAL(clicked(int)), this, SLOT(onPlaneSelect(int)));
-
+
QRadioButton* aBxy = new QRadioButton( tr( "|| X-Y" ), mySelPlane); // 0
QRadioButton* aByz = new QRadioButton( tr( "|| Y-Z" ), mySelPlane); // 1
QRadioButton* aBzx = new QRadioButton( tr( "|| Z-X" ), mySelPlane); // 2
aBzx->setChecked(true);
aPlaneLayout->addWidget( mySelPlane );
- aPlaneLayout->addStretch();
-
+
QGroupBox* aRotBox = new QGroupBox( tr( "LBL_ROTATION" ), aPlanePane );
aRotBox->setColumnLayout(2, Qt::Horizontal );
myRotYSpn->setValue( 0 );
aPlaneLayout->addWidget( aRotBox );
- aPlaneLayout->addStretch();
+
+ QHGroupBox* aBaseBox = new QHGroupBox( tr( "Base plane position" ), aPlanePane );
+ myBasePlanePos = new QLineEdit (aBaseBox);
+ mydvalidator = new QDoubleValidator(this);
+ mydvalidator->setDecimals(32);
+ myBasePlanePos->setValidator(mydvalidator);
+
+ myCBSetDef = new QCheckBox(tr("Set default"),aBaseBox);
+
+ aPlaneLayout->addWidget( aBaseBox );
QHBox* aPosBox = new QHBox(aPlanePane);
aPosBox->setSpacing(5);
myPosSpn = new QAD_SpinBoxDbl( aPosBox, 0, 1, 0.1 );
myPosSpn->setValue( 0.5 );
aPlaneLayout->addWidget( aPosBox );
-
+ aPlaneLayout->addStretch();
aTabPane->addTab( aPlanePane, tr("LBL_LINES_PLANE") );
-
-
+
// Number of lines
QFrame* aLinesPane = new QFrame(this);
QVBoxLayout* aLinesLayout = new QVBoxLayout( aLinesPane, 5, 6 );
-
+
mySelPlane2 = new QHButtonGroup( tr( "TXT_ORIENTATION" ), aLinesPane);
mySelPlane2->setInsideSpacing( 5 );
mySelPlane2->setInsideMargin( 5 );
- connect(mySelPlane2, SIGNAL(clicked(int)), this, SLOT(onCutSelect(int)));
-
+
QRadioButton* aBxy2 = new QRadioButton( tr( "|| X-Y" ), mySelPlane2); // 0
QRadioButton* aByz2 = new QRadioButton( tr( "|| Y-Z" ), mySelPlane2); // 1
QRadioButton* aBzx2 = new QRadioButton( tr( "|| Z-X" ), mySelPlane2); // 2
aByz2->setChecked(true);
aLinesLayout->addWidget( mySelPlane2 );
- QHBox* aNbBox = new QHBox(aLinesPane);
- aNbBox->setSpacing(5);
- QLabel* aNbLbl = new QLabel( tr( "LBL_NB_PLANS" ), aNbBox );
- myNbSpn = new QAD_SpinBoxDbl( aNbBox, 1, 100, 1 );
- myNbSpn->setValue( 10 );
- aLinesLayout->addWidget( aNbBox );
-
QGroupBox* aRotBox2 = new QGroupBox( tr( "LBL_ROTATION" ), aLinesPane );
aRotBox2->setColumnLayout(2, Qt::Horizontal );
-
+
myRotXLbl2 = new QLabel( tr( "LBL_ROT_X" ), aRotBox2);
myRotXSpn2 = new QAD_SpinBoxDbl( aRotBox2, -45, 45, 5 );
myRotXSpn2->setValue( 0 );
myRotYLbl2 = new QLabel( tr( "LBL_ROT_Y" ), aRotBox2 );
myRotYSpn2 = new QAD_SpinBoxDbl( aRotBox2, -45, 45, 5 );
myRotYSpn2->setValue( 0 );
-
aLinesLayout->addWidget( aRotBox2 );
+ QHBox* aNbBox = new QHBox(aLinesPane);
+ aNbBox->setSpacing(5);
+ QLabel* aNbLbl = new QLabel( tr( "LBL_NB_PLANS" ), aNbBox );
+ myNbSpn = new QAD_SpinBoxDbl( aNbBox, 1, 100, 1 );
+ myNbSpn->setValue( 10 );
+
+ aLinesLayout->addWidget( aNbBox );
+
+ myPosTable = new QTable(aLinesPane, "Positions of cut planes" );
+ myPosTable->setMaximumHeight( 227 );
+ myPosTable->setMinimumWidth( 294 );
+ myPosTable->setNumCols(2);
+ myPosTable->setNumRows(0);
+
+ QHeader *th = myPosTable->horizontalHeader();
+ th->setLabel( 0, "Position" );
+ th->setLabel( 1, "Set default" );
+
+ aLinesLayout->addWidget( myPosTable );
+
QHBox* aPosBox2 = new QHBox(aLinesPane);
aPosBox2->setSpacing(5);
QLabel* aPosLbl2 = new QLabel( tr( "LBL_POS" ), aPosBox2 );
myPosSpn2 = new QAD_SpinBoxDbl( aPosBox2, 0, 1, 0.1 );
myPosSpn2->setValue( 0.5 );
aLinesLayout->addWidget( aPosBox2 );
+ aLinesLayout->addStretch();
aTabPane->addTab( aLinesPane, tr("LBL_LINES_CUT") );
aOkBtn->setAutoDefault( TRUE );
aOkBtn->setDefault( true );
aBtnLayout->addWidget(aOkBtn);
- connect(aOkBtn, SIGNAL(clicked()), this, SLOT(accept()));
-
+
aBtnLayout->addStretch();
QPushButton* aCloseBtn = new QPushButton(tr("BUT_CLOSE"), aBtnBox);
aBtnLayout->addWidget(aCloseBtn);
- connect(aCloseBtn, SIGNAL(clicked()), this, SLOT(reject()));
-
+
aMainLayout->addWidget(aBtnBox);
+
+ myCutLines = NULL;
+
+ // signals and slots connections
+ connect(mySelPlane, SIGNAL(clicked(int)), this, SLOT(onPlaneSelect(int)));
+ connect(myCBSetDef , SIGNAL( toggled(bool) ), this , SLOT( setBaseDefault() ) );
+ connect(myPosSpn , SIGNAL( valueChanged( double ) ), this , SLOT( setBaseDefault() ) );
+ connect(mySelPlane2, SIGNAL(clicked(int)), this, SLOT(onCutSelect(int)));
+ connect( myNbSpn, SIGNAL( valueChanged( double )), this, SLOT( DrawTable( ) ) );
+ connect( th, SIGNAL( clicked(int)), this, SLOT( setDefault(int) ) );
+ connect( myPosSpn2, SIGNAL( valueChanged( double )), this, SLOT( DrawTable( ) ) );
+
+ connect(aOkBtn, SIGNAL(clicked()), this, SLOT(accept()));
+ connect(aCloseBtn, SIGNAL(clicked()), this, SLOT(reject()));
+
+}
+
+/*!
+ Destructor
+*/
+VisuGUI_CutLinesDlg::~VisuGUI_CutLinesDlg()
+{
+ if(myCutLines) delete myCutLines;
}
//------------------------------------------------------------------------------
void VisuGUI_CutLinesDlg::initFromPrsObject(VISU::CutLines_i* thePrs) {
- switch (thePrs->GetOrientationType()) {
- case VISU::CutPlanes::XY:
- ((QRadioButton*)mySelPlane->find(0))->setChecked(true);
- onPlaneSelect(0);
- break;
- case VISU::CutPlanes::YZ:
- ((QRadioButton*)mySelPlane->find(1))->setChecked(true);
- onPlaneSelect(1);
- break;
- case VISU::CutPlanes::ZX:
- ((QRadioButton*)mySelPlane->find(2))->setChecked(true);
- onPlaneSelect(2);
- }
+
myRotXSpn->setValue(thePrs->GetRotateX()*180./PI);
myRotYSpn->setValue(thePrs->GetRotateY()*180./PI);
myPosSpn->setValue(thePrs->GetDisplacement());
-
+ setOrientation(thePrs->GetOrientationType());
+
myNbSpn->setValue( thePrs->GetNbLines() );
- switch (thePrs->GetOrientationType2()) {
- case VISU::CutPlanes::XY:
- ((QRadioButton*)mySelPlane2->find(0))->setChecked(true);
- break;
- case VISU::CutPlanes::YZ:
- ((QRadioButton*)mySelPlane2->find(1))->setChecked(true);
- break;
- case VISU::CutPlanes::ZX:
- ((QRadioButton*)mySelPlane2->find(2))->setChecked(true);
- }
myRotXSpn2->setValue(thePrs->GetRotateX2()*180./PI);
myRotYSpn2->setValue(thePrs->GetRotateY2()*180./PI);
myPosSpn2->setValue(thePrs->GetDisplacement2());
+ setOrientation2(thePrs->GetOrientationType2());
+
+ hasInit = true;
+ myCutLines = new VISU::CutLines_i(thePrs->GetResult(),false);
+ myCutLines->SameAs(thePrs);
+ myBasePlanePos->setText( QString::number(myCutLines->GetBasePlanePosition()) );
+ myCBSetDef->setChecked(thePrs->IsDefault());
+ DrawTable();
}
//------------------------------------------------------------------------------
void VisuGUI_CutLinesDlg::storeToPrsObject(VISU::CutLines_i* thePrs) {
- switch (mySelPlane->id(mySelPlane->selected())) {
- case 0:
- thePrs->SetOrientationType(VISU::CutPlanes::XY);
- break;
- case 1:
- thePrs->SetOrientationType(VISU::CutPlanes::YZ);
- break;
- case 2:
- thePrs->SetOrientationType(VISU::CutPlanes::ZX);
- }
+
+ thePrs->SetOrientationType(getOrientaion());
thePrs->SetRotateX(myRotXSpn->value()*PI/180.);
thePrs->SetRotateY(myRotYSpn->value()*PI/180.);
thePrs->SetDisplacement(myPosSpn->value());
-
thePrs->SetNbLines((int)myNbSpn->value());
- switch (mySelPlane2->id(mySelPlane2->selected())) {
- case 0:
- thePrs->SetOrientationType2(VISU::CutPlanes::XY);
- break;
- case 1:
- thePrs->SetOrientationType2(VISU::CutPlanes::YZ);
- break;
- case 2:
- thePrs->SetOrientationType2(VISU::CutPlanes::ZX);
- }
+
+ thePrs->SetOrientationType2(getOrientaion(false));
thePrs->SetRotateX2(myRotXSpn2->value()*PI/180.);
thePrs->SetRotateY2(myRotYSpn2->value()*PI/180.);
thePrs->SetDisplacement2(myPosSpn2->value());
+
+ if (!myCBSetDef->isChecked())
+ thePrs->SetBasePlanePosition(myBasePlanePos->text().toDouble());
+ else thePrs->SetDefault();
+
+ for (int i = 0; i < (int)myNbSpn->value(); ++i)
+ {
+ if (!((QCheckBox*)myPosTable->cellWidget( i, 1 ))->isChecked())
+ thePrs->SetLinePosition( i, ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->text().toDouble() );
+ else thePrs->SetDefaultPosition(i);
+ }
}
-
//------------------------------------------------------------------------------
void VisuGUI_CutLinesDlg::onPlaneSelect(int theId) {
for (int i = 0; i < mySelPlane2->count(); i++)
((QRadioButton*)mySelPlane2->find(0))->setChecked(true);
onCutSelect(0);
}
+ setBaseDefault();
}
-
//------------------------------------------------------------------------------
void VisuGUI_CutLinesDlg::onCutSelect(int theId) {
switch (theId) {
myRotXLbl2->setText( tr("LBL_ROT_Z"));
myRotYLbl2->setText( tr("LBL_ROT_X"));
}
+ DrawTable();
+}
+
+//------------------------------------------------------------------------------
+void VisuGUI_CutLinesDlg::setBaseDefault() {
+
+ if (!hasInit) return;
+
+ if ( myCBSetDef->isChecked() )
+ {
+ if (!myCutLines->IsDefault()) myCutLines->SetDefault();
+ myCutLines->SetOrientationType(getOrientaion());
+ myCutLines->SetDisplacement(myPosSpn->value());
+ myBasePlanePos->setText( QString::number(myCutLines->GetBasePlanePosition()) );
+ myBasePlanePos->setEnabled(false);
+ }
+ else myBasePlanePos->setEnabled(true);
+
+}
+
+//------------------------------------------------------------------------------
+void VisuGUI_CutLinesDlg::DrawTable()
+{
+ if (!hasInit) return;
+
+ int aNbRows = myPosTable->numRows();
+ int aNbPlanes = (int)myNbSpn->value();
+
+ if (aNbRows>0)
+ for (int i = 0; i < aNbRows; ++i)
+ {
+ if (!((QCheckBox*)myPosTable->cellWidget( i, 1 ))->isChecked())
+ myCutLines->SetLinePosition( i, ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->text().toDouble() );
+ }
+
+ myCutLines->SetNbLines(aNbPlanes);
+ myCutLines->SetDisplacement2(myPosSpn2->value());
+ myCutLines->SetOrientationType2(getOrientaion(false));
+
+ if (aNbRows < aNbPlanes)
+ {
+ if (aNbRows == 0) myPosTable->setNumRows(aNbPlanes);
+ else myPosTable->insertRows(aNbRows, aNbPlanes - aNbRows );
+
+ QHeader *vh = myPosTable->verticalHeader();
+ QString str;
+
+ for (int i = aNbRows; i < myPosTable->numRows(); ++i)
+ {
+ QLineEdit *editline = new QLineEdit( myPosTable );
+ editline->setValidator(mydvalidator);
+ myPosTable->setCellWidget( i, 0, editline );
+
+ QCheckBox *checkbox = new QCheckBox( myPosTable );
+ myPosTable->setCellWidget(i, 1, checkbox );
+ connect(checkbox , SIGNAL( clicked() ), this , SLOT( setDefault() ) );
+
+ str = str.setNum(i+1);
+ str.prepend ("Plane# ");
+ vh->setLabel( i, str );
+ }
+ }
+ else if (aNbRows > aNbPlanes)
+ for (int i = aNbRows-1; myPosTable->numRows() != aNbPlanes; --i )
+ myPosTable->removeRow(i);
+
+ for (int i = 0; i < myPosTable->numRows(); ++i)
+ {
+ ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->setText( QString::number(myCutLines->GetLinePosition(i)) );
+
+ if (myCutLines->IsDefaultPosition(i))
+ {
+ ((QCheckBox*)myPosTable->cellWidget( i, 1 ))->setChecked(true);
+ ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->setEnabled(false);
+ }
+ }
+}
+
+//------------------------------------------------------------------------------
+void VisuGUI_CutLinesDlg::setDefault(int all)
+{
+ if (all == 0) return;
+
+ if (all == 1)
+ for (int i = 0; i < (int)myNbSpn->value(); ++i)
+ ((QCheckBox*)myPosTable->cellWidget( i, 1 ))->setChecked(true);
+
+ for (int i = 0; i < (int)myNbSpn->value(); ++i)
+ {
+ if ( ((QCheckBox*)myPosTable->cellWidget( i, 1 ))->isChecked() )
+ {
+ myCutLines->SetDefaultPosition(i);
+ ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->setText( QString::number(myCutLines->GetLinePosition(i)) );
+ ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->setEnabled(false);
+ }
+ else ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->setEnabled(true);
+ }
+}
+
+//------------------------------------------------------------------------------
+VISU::CutPlanes::Orientation VisuGUI_CutLinesDlg::getOrientaion(bool IsBasePlane)
+{
+ QHButtonGroup* aBG;
+
+ if (IsBasePlane)
+ aBG = mySelPlane;
+ else
+ aBG = mySelPlane2;
+
+ VISU::CutPlanes::Orientation orient;
+ switch (aBG->id(aBG->selected())) {
+ case 0:
+ orient = VISU::CutPlanes::XY;
+ break;
+ case 1:
+ orient = VISU::CutPlanes::YZ;
+ break;
+ case 2:
+ orient = VISU::CutPlanes::ZX;
+ }
+ return orient;
+}
+
+//------------------------------------------------------------------------------
+void VisuGUI_CutLinesDlg::setOrientation( const VISU::CutPlanes::Orientation orient)
+{
+ switch (orient) {
+ case VISU::CutPlanes::XY:
+ ((QRadioButton*)mySelPlane->find(0))->setChecked(true);
+ onPlaneSelect(0);
+ break;
+ case VISU::CutPlanes::YZ:
+ ((QRadioButton*)mySelPlane->find(1))->setChecked(true);
+ onPlaneSelect(1);
+ break;
+ case VISU::CutPlanes::ZX:
+ ((QRadioButton*)mySelPlane->find(2))->setChecked(true);
+ onPlaneSelect(2);
+ }
+}
+
+//------------------------------------------------------------------------------
+void VisuGUI_CutLinesDlg::setOrientation2( const VISU::CutPlanes::Orientation orient )
+{
+ switch (orient) {
+ case VISU::CutPlanes::XY:
+ ((QRadioButton*)mySelPlane2->find(0))->setChecked(true);
+ onCutSelect(0);
+ break;
+ case VISU::CutPlanes::YZ:
+ ((QRadioButton*)mySelPlane2->find(1))->setChecked(true);
+ onCutSelect(1);
+ break;
+ case VISU::CutPlanes::ZX:
+ ((QRadioButton*)mySelPlane2->find(2))->setChecked(true);
+ onCutSelect(2);
+ }
}
#ifndef VISUGUI_CUTLINESDLG_H
#define VISUGUI_CUTLINESDLG_H
+#include "VisuGUI_ScalarBarDlg.h"
+
#include <qdialog.h>
#include <qhbuttongroup.h>
-#include "VISU_PrsObject_i.hh"
-#include "VisuGUI_ScalarBarDlg.h"
+#include <qlineedit.h>
+#include <qcheckbox.h>
+#include <qvalidator.h>
+#include <qtable.h>
+
+#include "SALOMEconfig.h"
+#include CORBA_CLIENT_HEADER(VISU_Gen)
+
+namespace VISU{
+ class CutLines_i;
+}
class VisuGUI_CutLinesDlg: public QDialog
{
public:
VisuGUI_CutLinesDlg();
- ~VisuGUI_CutLinesDlg() {};
+ ~VisuGUI_CutLinesDlg();
void initFromPrsObject(VISU::CutLines_i* thePrs);
void storeToPrsObject(VISU::CutLines_i* thePrs);
private slots:
void onPlaneSelect(int theId);
void onCutSelect(int theId);
-
-
+ void setBaseDefault();
+ void setDefault( int all = -1);
+ void DrawTable();
+
private:
QHButtonGroup* mySelPlane;
QAD_SpinBoxDbl* myRotXSpn;
QLabel* myRotXLbl;
QLabel* myRotYLbl;
QAD_SpinBoxDbl* myPosSpn;
+ QLineEdit* myBasePlanePos;
+ QCheckBox* myCBSetDef;
QHButtonGroup* mySelPlane2;
QAD_SpinBoxDbl* myNbSpn;
QLabel* myRotXLbl2;
QLabel* myRotYLbl2;
QAD_SpinBoxDbl* myPosSpn2;
+ QTable* myPosTable;
+ bool hasInit;
+
+ QDoubleValidator *mydvalidator;
+ VISU::CutLines_i* myCutLines;
+
+ VISU::CutPlanes::Orientation getOrientaion(bool IsBasePlane = true);
+ void setOrientation( const VISU::CutPlanes::Orientation orient);
+ void setOrientation2( const VISU::CutPlanes::Orientation orient);
+
};
#endif // VISUGUI_CUTLINESDLG_H
+
// Module : VISU
// $Header$
-using namespace std;
#include "VisuGUI_CutPlanesDlg.h"
-#include <qlayout.h>
+#include "VISU_CutPlanes_i.hh"
+
#include "QAD_Application.h"
#include "QAD_Desktop.h"
+#include <qlayout.h>
+#include <qcheckbox.h>
+#include <qstyle.h>
+#include <qstring.h>
+#include <qvalidator.h>
+#include <qlineedit.h>
+
+using namespace std;
+
/*!
Constructor
*/
nbPlan->setValue( 1 );
nbPlan->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
+ myPosTable = new QTable(this, "Positions of planes" );
+ myPosTable->setMaximumHeight( 227 );
+ myPosTable->setMinimumWidth( 294 );
+ //myPosTable->setGeometry( QRect( 11, 98, 289, 325 ) );
+ myPosTable->setNumCols(2);
+ myPosTable->setNumRows(0);
+
+ QHeader *th = myPosTable->horizontalHeader();
+ th->setLabel( 0, "Position" );
+ th->setLabel( 1, "Set default" );
+
QGroupBox* GBrot = new QGroupBox( tr( "Rotations" ), this, "GBrot" );
GBrot->setColumnLayout(0, Qt::Vertical );
GBrot->layout()->setSpacing( 0 );
QLabel* aPosLbl = new QLabel(tr( "LBL_POS" ), this);
myPosSpn = new QAD_SpinBoxDbl( this, 0, 1, 0.1 );
+ th->setStyle("QStyle::CE_PushButton");
+
// layouting
TopLayout->addMultiCellWidget( SelPlane, 0, 0, 0, 1 );
- TopLayout->addWidget( LabelPosi_3, 1, 0 );
- TopLayout->addWidget( nbPlan, 1, 1 );
- TopLayout->addMultiCellWidget( GBrot, 2, 2, 0, 1 );
- TopLayout->addWidget(aPosLbl, 3, 0 );
- TopLayout->addWidget(myPosSpn, 3, 1 );
- TopLayout->addMultiCellWidget( GroupButtons, 4, 4, 0, 1 );
+ TopLayout->addMultiCellWidget( GBrot, 1, 1, 0, 1 );
+ TopLayout->addWidget( LabelPosi_3, 2, 0 );
+ TopLayout->addWidget( nbPlan, 2, 1 );
+ TopLayout->addMultiCellWidget( myPosTable, 3, 3, 0, 1 );
+ TopLayout->setRowStretch ( 3, 3 );
+ TopLayout->addWidget(aPosLbl, 4, 0 );
+ TopLayout->addWidget(myPosSpn, 4, 1 );
+ TopLayout->addMultiCellWidget( GroupButtons, 5, 5, 0, 1 );
// signals and slots connections
connect( SelPlane, SIGNAL( clicked( int )), this, SLOT( orientationChanged( int ) ) );
-
+ connect( nbPlan, SIGNAL( valueChanged( int )), this, SLOT( DrawTable( ) ) );
+ connect( myPosSpn, SIGNAL( valueChanged( double )), this, SLOT( DrawTable( ) ) );
+ connect( RBzx, SIGNAL( toggled(bool)), this, SLOT( DrawTable( ) ) );
+ connect( RByz, SIGNAL( toggled(bool)), this, SLOT( DrawTable( ) ) );
+ connect( RBxy, SIGNAL( toggled(bool)), this, SLOT( DrawTable( ) ) );
+ connect( th, SIGNAL( clicked(int)), this, SLOT( setDefault(int) ) );
+
connect( buttonOk, SIGNAL( clicked() ), this, SLOT( accept() ) );
connect( buttonCancel, SIGNAL( clicked() ), this, SLOT( reject() ) );
+ myCutPlanes = NULL;
+
// default values
+ hasInit = false;
X1 = 0; X2 = 0;
Y1 = 0; Y2 = 0;
Z1 = 0; Z2 = 0;
- RBxy->setChecked( true );
+ RByz->setChecked( true );
orientationChanged( 0 );
}
*/
VisuGUI_CutPlanesDlg::~VisuGUI_CutPlanesDlg()
{
+ if(myCutPlanes) delete myCutPlanes;
}
setRotation(thePrs->GetRotateX()*180./PI, thePrs->GetRotateY()*180./PI);
setPlanePos(thePrs->GetOrientationType());
myPosSpn->setValue(thePrs->GetDisplacement());
+ hasInit = true;
+ // init table
+ myCutPlanes = new VISU::CutPlanes_i(thePrs->GetResult(),false);
+ myCutPlanes->SameAs(thePrs);
+ DrawTable();
}
void VisuGUI_CutPlanesDlg::storeToPrsObject(VISU::CutPlanes_i* thePrs) {
thePrs->SetRotateY(getRotation2()*PI/180.);
thePrs->SetOrientationType(getOrientaion());
thePrs->SetDisplacement(myPosSpn->value());
- thePrs->Update();
+ for (int i = 0; i < getNbPlanes(); ++i)
+ {
+ if (!((QCheckBox*)myPosTable->cellWidget( i, 1 ))->isChecked())
+ thePrs->SetPlanePosition( i, ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->text().toDouble() );
+ else thePrs->SetDefault(i);
+ }
}
/*!
{
return Rot2->value();
}
+
+/*!
+ Draw the table of planes positions
+*/
+
+void VisuGUI_CutPlanesDlg::DrawTable()
+{
+ if (!hasInit) return;
+
+ int aNbRows = myPosTable->numRows();
+ int aNbPlanes = getNbPlanes();
+
+ if (aNbRows>0)
+ for (int i = 0; i < aNbRows; ++i)
+ {
+ if (!((QCheckBox*)myPosTable->cellWidget( i, 1 ))->isChecked())
+ myCutPlanes->SetPlanePosition( i, ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->text().toDouble() );
+ }
+
+ myCutPlanes->SetNbPlanes(aNbPlanes);
+ myCutPlanes->SetDisplacement(myPosSpn->value());
+ myCutPlanes->SetOrientationType(getOrientaion());
+
+ if (aNbRows < aNbPlanes)
+ {
+ if (aNbRows == 0) myPosTable->setNumRows(aNbPlanes);
+ else myPosTable->insertRows(aNbRows, aNbPlanes - aNbRows );
+
+ QHeader *vh = myPosTable->verticalHeader();
+ QString str;
+
+ QDoubleValidator *dvalidator = new QDoubleValidator(myPosTable);
+ dvalidator->setDecimals(32);
+
+ for (int i = aNbRows; i < myPosTable->numRows(); ++i)
+ {
+ QLineEdit *editline = new QLineEdit( myPosTable );
+ editline->setValidator(dvalidator);
+ myPosTable->setCellWidget( i, 0, editline );
+
+ QCheckBox *checkbox = new QCheckBox( myPosTable );
+ myPosTable->setCellWidget(i, 1, checkbox );
+ connect(checkbox , SIGNAL( clicked() ), this , SLOT( setDefault() ) );
+
+ str = str.setNum(i+1);
+ str.prepend ("Plane# ");
+ vh->setLabel( i, str );
+ }
+ }
+ else if (aNbRows > aNbPlanes)
+ for (int i = aNbRows-1; myPosTable->numRows() != aNbPlanes; --i )
+ myPosTable->removeRow(i);
+
+ for (int i = 0; i < myPosTable->numRows(); ++i)
+ {
+ ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->setText( QString::number(myCutPlanes->GetPlanePosition(i)) );
+
+ if (myCutPlanes->IsDefault(i))
+ {
+ ((QCheckBox*)myPosTable->cellWidget( i, 1 ))->setChecked(true);
+ ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->setEnabled(false);
+ }
+ }
+}
+
+void VisuGUI_CutPlanesDlg::setDefault(int all)
+{
+ if (all == 0) return;
+
+ if (all == 1)
+ for (int i = 0; i < getNbPlanes(); ++i)
+ ((QCheckBox*)myPosTable->cellWidget( i, 1 ))->setChecked(true);
+
+ for (int i = 0; i < getNbPlanes(); ++i)
+ {
+ if ( ((QCheckBox*)myPosTable->cellWidget( i, 1 ))->isChecked() )
+ {
+ myCutPlanes->SetDefault(i);
+ ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->setText( QString::number(myCutPlanes->GetPlanePosition(i)) );
+ ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->setEnabled(false);
+ }
+ else ((QLineEdit*)myPosTable->cellWidget( i, 0 ))->setEnabled(true);
+ }
+}
#ifndef VISUGUI_CUTPLANESDLG_H
#define VISUGUI_CUTPLANESDLG_H
+#include "QAD_SpinBoxDbl.h"
+#include "VisuGUI_ScalarBarDlg.h"
+
#include <qdialog.h>
#include <qbuttongroup.h>
#include <qgroupbox.h>
#include <qpushbutton.h>
#include <qradiobutton.h>
#include <qspinbox.h>
-#include "QAD_SpinBoxDbl.h"
-#include "VISU_PrsObject_i.hh"
-#include "VisuGUI_ScalarBarDlg.h"
+#include <qtable.h>
+#include "SALOMEconfig.h"
+#include CORBA_CLIENT_HEADER(VISU_Gen)
+namespace VISU{
+ class CutPlanes_i;
+}
class VisuGUI_CutPlanesDlg : public QDialog
{
void initFromPrsObject(VISU::CutPlanes_i* thePrs);
void storeToPrsObject(VISU::CutPlanes_i* thePrs);
-
-
+
private:
QLabel* LabelRot1;
QLabel* LabelRot2;
QRadioButton* RByz;
QRadioButton* RBxy;
QAD_SpinBoxDbl* myPosSpn;
-
+ QTable* myPosTable;
+ VISU::CutPlanes_i* myCutPlanes;
double X1, X2;
double Y1, Y2;
double Z1, Z2;
-
+ bool hasInit;
private slots:
void editScalarBar();
void orientationChanged( int );
+ void DrawTable();
+ void setDefault( int all = -1);
};
#endif // VISUGUI_CUTPLANESDLG_H
-
-
-
-
-
-
-
--- /dev/null
+// SALOME SALOMEGUI : GUI of VISU module
+//
+// Copyright (C) 2003 CEA/DEN, EDF R&D
+//
+//
+//
+// File : QAD_FileDlg.cxx
+// Author :
+// Module : SALOME
+// $Header: /dn05/salome/CVS/SALOME_ROOT/SALOME/src/VISUGUI/Visu_FileDlg.cxx
+
+
+#include <qapplication.h>
+#include <qlabel.h>
+#include <qpushbutton.h>
+#include <qstring.h>
+#include "QAD_Config.h"
+#include "VisuGUI_FileDlg.h"
+
+using namespace std;
+
+bool VisuGUI_FileDlg::IsBuild = false;
+
+/*!
+Constructor
+*/
+VisuGUI_FileDlg::VisuGUI_FileDlg( QWidget* parent, bool open, bool showQuickDir, bool modal ) :
+ QAD_FileDlg( parent, open, showQuickDir, modal )
+{
+ myCBuildAll = new QCheckBox( tr("Full loading for current file"), this );
+ QLabel* label = new QLabel("", this);
+ label->setMaximumWidth(0);
+ QPushButton* pb = new QPushButton(this);
+ pb->setMaximumWidth(0);
+ addWidgets( label, myCBuildAll, pb );
+ QString aIsBuild = QAD_CONFIG->getSetting("Visu:BuildResult");
+ if (aIsBuild.isEmpty()? 0 : aIsBuild.toInt()) myCBuildAll->setChecked(true);
+}
+
+/*!
+ Destructor
+*/
+VisuGUI_FileDlg::~VisuGUI_FileDlg()
+{
+}
+
+/*!
+ Processes selection : tries to set given path or filename as selection
+*/
+bool VisuGUI_FileDlg::processPath( const QString& path )
+{
+ if ( !path.isNull() ) {
+ QFileInfo fi( path );
+ if ( fi.exists() ) {
+ if ( fi.isFile() )
+ setSelection( path );
+ else if ( fi.isDir() )
+ setDir( path );
+ return true;
+ }
+ else {
+ if ( QFileInfo( fi.dirPath() ).exists() ) {
+ setDir( fi.dirPath() );
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+/*!
+ Returns the file name for Open/Save [ static ]
+*/
+QString VisuGUI_FileDlg::getFileName( QWidget* parent,
+ const QString& initial,
+ const QStringList& filters,
+ const QString& caption,
+ bool open,
+ bool showQuickDir,
+ QAD_FileValidator* validator )
+{
+ VisuGUI_FileDlg* fd = new VisuGUI_FileDlg( parent, open, showQuickDir, true );
+ if ( !caption.isEmpty() )
+ fd->setCaption( caption );
+ if ( !initial.isEmpty() ) {
+ fd->processPath( initial ); // VSR 24/03/03 check for existing of directory has been added to avoid QFileDialog's bug
+ }
+ fd->setFilters( filters );
+ if ( validator )
+ fd->setValidator( validator );
+ fd->exec();
+ QString filename = fd->selectedFile();
+
+ VisuGUI_FileDlg::IsBuild = fd->IsChecked();
+
+ delete fd;
+ qApp->processEvents();
+
+ return filename;
+}
+
+bool VisuGUI_FileDlg::IsChecked()
+{
+ return myCBuildAll->isChecked();
+}
+
--- /dev/null
+// SALOME SALOMEGUI : GUI of VISU module
+//
+// Copyright (C) 2003 CEA/DEN, EDF R&D
+//
+//
+//
+// File : QAD_FileDlg.h
+// Author :
+// Module : SALOME
+// $Header: /dn05/salome/CVS/SALOME_ROOT/VISU/src/VISUGUI/VisuGUI_FileDlg.h
+
+#ifndef VISU_FILEDIALOG_H
+#define VISU_FILEDIALOG_H
+
+#include "QAD_FileDlg.h"
+#include <qcheckbox.h>
+
+class VisuGUI_FileDlg : public QAD_FileDlg
+{
+ Q_OBJECT
+
+public:
+ VisuGUI_FileDlg( QWidget* parent, bool open, bool showQuickDir = true, bool modal = true );
+ ~VisuGUI_FileDlg();
+
+public:
+ static bool IsBuild;
+ static QString getFileName( QWidget* parent,
+ const QString& initial,
+ const QStringList& filters,
+ const QString& caption,
+ bool open,
+ bool showQuickDir = true,
+ QAD_FileValidator* validator = 0);
+
+private:
+ QCheckBox* myCBuildAll;
+ bool IsChecked();
+ bool processPath( const QString& path );
+
+};
+
+#endif
// Module : VISU
// $Header$
-using namespace std;
#include "VisuGUI_IsoSurfacesDlg.h"
-#include <limits.h>
-#include <qlayout.h>
+#include "VISU_IsoSurfaces_i.hh"
+
#include "QAD_Application.h"
#include "QAD_Desktop.h"
-#include <qvalidator.h>
#include "QAD_MessageBox.h"
+#include <limits.h>
+
+#include <qlayout.h>
+#include <qvalidator.h>
+
+using namespace std;
/*!
Constructor
*/
VisuGUI_IsoSurfacesDlg::VisuGUI_IsoSurfacesDlg()
- : QDialog( QAD_Application::getDesktop(), "VisuGUI_IsoSurfacesDlg", true, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu )
+ : QDialog( QAD_Application::getDesktop(), "VisuGUI_IsoSurfacesDlg", true, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu )
{
setCaption( tr( "Iso Surfaces Definition" ) );
setSizeGripEnabled( TRUE );
-
+
QGridLayout* TopLayout = new QGridLayout( this );
TopLayout->setSpacing( 6 );
TopLayout->setMargin( 11 );
LabelMax->setBuddy(MaxIso);
TopGroupLayout->addWidget( MaxIso, 1, 1 );
+ CBUpdate = new QCheckBox ( tr( "Update scalar bar with these values" ), TopGroup);
+ CBUpdate->setSizePolicy( QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed) );
+ TopGroupLayout->addMultiCellWidget( CBUpdate, 4, 4, 0, 1);
+ CBUpdate->setChecked(true);
+
+ CBLog = new QCheckBox ( tr( "Logarithmic scaling" ), TopGroup);
+ CBLog->setSizePolicy( QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed) );
+ TopGroupLayout->addMultiCellWidget( CBLog, 3, 3, 0, 1);
+
QLabel* LabelNbr = new QLabel( tr( "Number of surfaces:" ), TopGroup, "LabelNbr" );
TopGroupLayout->addWidget( LabelNbr, 2, 0 );
NbrIso = new QSpinBox( 1, 100, 1, TopGroup, "NbrIso" );
NbrIso->setValue( 1 );
TopGroupLayout->addWidget( NbrIso, 2, 1 );
-
+
QGroupBox* GroupButtons = new QGroupBox( this, "GroupButtons" );
GroupButtons->setGeometry( QRect( 10, 10, 281, 48 ) );
GroupButtons->setColumnLayout(0, Qt::Vertical );
GroupButtonsLayout->setAlignment( Qt::AlignTop );
GroupButtonsLayout->setSpacing( 6 );
GroupButtonsLayout->setMargin( 11 );
-
+
QPushButton* buttonOk = new QPushButton( tr( "&OK" ), GroupButtons, "buttonOk" );
buttonOk->setAutoDefault( TRUE );
buttonOk->setDefault( TRUE );
TopLayout->addWidget( TopGroup, 0, 0 );
TopLayout->addWidget( GroupButtons, 1, 0 );
-
+
// signals and slots connections
connect( buttonOk, SIGNAL( clicked() ), this, SLOT( accept() ) );
connect( buttonCancel, SIGNAL( clicked() ), this, SLOT( reject() ) );
+ connect( CBUpdate, SIGNAL( clicked() ), this, SLOT(onCBUpdate() ) );
}
/*!
- Destructor
+ Destructor
*/
VisuGUI_IsoSurfacesDlg::~VisuGUI_IsoSurfacesDlg()
{
}
-
void VisuGUI_IsoSurfacesDlg::initFromPrsObject(VISU::IsoSurfaces_i* thePrs) {
NbrIso->setValue(thePrs->GetNbSurfaces());
- MinIso->setText(QString::number(thePrs->GetRangeMin()));
- MaxIso->setText(QString::number(thePrs->GetRangeMax()));
+ MinIso->setText(QString::number(thePrs->GetSubMin()));
+ MaxIso->setText(QString::number(thePrs->GetSubMax()));
+ switch(thePrs->GetScaling()){
+ case VISU::LOGARITHMIC :
+ CBLog->setChecked(true);
+ break;
+ default:
+ CBLog->setChecked(false);
+ }
}
-
void VisuGUI_IsoSurfacesDlg::storeToPrsObject(VISU::IsoSurfaces_i* thePrs) {
thePrs->SetNbSurfaces(NbrIso->value());
- thePrs->SetRange(MinIso->text().toDouble(), MaxIso->text().toDouble());
- thePrs->Update();
+ thePrs->SetSubRange(MinIso->text().toDouble(), MaxIso->text().toDouble());
+ if (CBUpdate->isChecked())
+ {
+ thePrs->SetRange(MinIso->text().toDouble(), MaxIso->text().toDouble());
+ if (CBLog->isChecked())
+ thePrs->SetScaling(VISU::LOGARITHMIC);
+ else
+ thePrs->SetScaling(VISU::LINEAR);
+ }
}
void VisuGUI_IsoSurfacesDlg::accept() {
+
if (MinIso->text().toDouble() >= MaxIso->text().toDouble())
QAD_MessageBox::warn1( this,tr("VISU_WARNING"),
- tr("MSG_MINMAX_VALUES"),
- tr("VISU_BUT_OK"));
- else
- QDialog::accept();
+ tr("MSG_MINMAX_VALUES"),
+ tr("VISU_BUT_OK"));
+ else if ( CBUpdate->isChecked() && CBLog->isChecked() && (MinIso->text().toDouble() <=0 || MaxIso->text().toDouble() <=0) )
+ {
+
+ QAD_MessageBox::warn1( this,
+ tr("VISU_WARNING"),
+ tr("WRN_LOGARITHMIC_RANGE_ISOSURF"),
+ tr("VISU_BUT_OK"));
+ }
+ else QDialog::accept();
+}
+
+void VisuGUI_IsoSurfacesDlg::onCBUpdate()
+{
+ if (CBUpdate->isChecked())
+ CBLog->setDisabled(false);
+ else CBLog->setDisabled(true);
}
#include <qgroupbox.h>
#include <qspinbox.h>
#include <qpushbutton.h>
-#include "VISU_PrsObject_i.hh"
+#include <qcheckbox.h>
#include <qlineedit.h>
+namespace VISU{
+ class IsoSurfaces_i;
+}
class VisuGUI_IsoSurfacesDlg : public QDialog
{
public:
VisuGUI_IsoSurfacesDlg();
~VisuGUI_IsoSurfacesDlg();
-
+
void initFromPrsObject(VISU::IsoSurfaces_i* thePrs);
void storeToPrsObject(VISU::IsoSurfaces_i* thePrs);
-
+
protected slots:
void accept();
-
- private:
- QLineEdit* MinIso;
- QLineEdit* MaxIso;
- QSpinBox* NbrIso;
+ void onCBUpdate();
+
+private:
+ QLineEdit* MinIso;
+ QLineEdit* MaxIso;
+ QSpinBox* NbrIso;
+ QCheckBox* CBUpdate;
+ QCheckBox* CBLog;
};
#endif // VISUGUI_ISOSURFACESDLG_H
// Module : VISU
// $Header$
-using namespace std;
#include "VisuGUI_MagnitudeDlg.h"
-#include <qlayout.h>
+#include "VISU_DeformedShape_i.hh"
+
#include "QAD_Application.h"
#include "QAD_Desktop.h"
+#include <qlayout.h>
+
+using namespace std;
+
/*!
Constructor
*/
void VisuGUI_MagnitudeDlg::initFromPrsObject(VISU::DeformedShape_i* thePrs) {
setFactor(thePrs->GetScale());
- UseMagn->setChecked(thePrs->isColored());
+ UseMagn->setChecked(thePrs->IsColored());
}
void VisuGUI_MagnitudeDlg::storeToPrsObject(VISU::DeformedShape_i* thePrs) {
thePrs->SetScale(getFactor());
- thePrs->setColored(isColored());
+ thePrs->ShowColored(isColored());
}
#include <qcheckbox.h>
#include <qlabel.h>
#include <qpushbutton.h>
+
#include "QAD_SpinBoxDbl.h"
-#include "VISU_PrsObject_i.hh"
+
+namespace VISU{
+ class DeformedShape_i;
+}
class VisuGUI_MagnitudeDlg : public QDialog
{
// Module : VISU
// $Header$
-using namespace std;
#include "VisuGUI_NonIsometricDlg.h"
+#include "VISU_Actor.h"
+#include "VISU_PipeLine.hxx"
-#include <qgroupbox.h>
-#include <qlabel.h>
-#include <qpushbutton.h>
-#include <qlayout.h>
#include "QAD_SpinBoxDbl.h"
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include "QAD_StudyFrame.h"
#include "QAD_RightFrame.h"
#include "VTKViewer_ViewFrame.h"
-#include "VISU_Actor.h"
#include "utilities.h"
#include "SALOME_Selection.h"
#include "SALOME_ListIteratorOfListIO.hxx"
#include "SALOME_ListIO.hxx"
+#include <qgroupbox.h>
+#include <qlabel.h>
+#include <qpushbutton.h>
+#include <qlayout.h>
+
+using namespace std;
+
/*!
Constructor
*/
// Module : VISU
// $Header$
-using namespace std;
#include "VisuGUI_ScalarBarDlg.h"
-#include <limits.h>
-#include <qlayout.h>
-#include <qvalidator.h>
+#include "VISU_ScalarMap_i.hh"
+#include "VISU_ScalarMapPL.hxx"
+
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include "QAD_Config.h"
#include "QAD_MessageBox.h"
#include "VISU_Convertor.hxx"
+#include <limits.h>
+#include <qlayout.h>
+#include <qvalidator.h>
+
+using namespace std;
+
/*!
Constructor
*/
* Initialise dialog box from presentation object
*/
void VisuGUI_ScalarBarDlg::initFromPrsObject(VISU::ScalarMap_i* thePrs) {
+ initFromResources();
myModeCombo->setCurrentItem(thePrs->GetScalarMode());
setPosAndSize( thePrs->GetPosX(),
thePrs->GetPosY(),
setLogarithmic(false);
}
float aRange[2];
- thePrs->GetFieldRange(aRange);
+ thePrs->GetScalarMapPL()->GetSourceRange(aRange);
Rmin = aRange[0]; Rmax = aRange[1];
setRange( thePrs->GetMin(), thePrs->GetMax(),
- 0.0, 0.0, thePrs->isRangeFixed() );
+ 0.0, 0.0, thePrs->IsRangeFixed() );
setScalarBarData( thePrs->GetNbColors(), thePrs->GetLabels() );
bool isScalarMode = (thePrs->GetField()->myNbComp > 1);
myModeLbl->setEnabled(isScalarMode);
thePrs->SetPosition(XSpin->value(), YSpin->value());
thePrs->SetSize(WidthSpin->value(), HeightSpin->value());
thePrs->SetOrientation((RBvert->isChecked())? VISU::ScalarMap::VERTICAL : VISU::ScalarMap::HORIZONTAL);
- if (RBFrange->isChecked()) {
- thePrs->CalculateRange();
- } else {
- thePrs->SetRange(MinEdit->text().toDouble(), MaxEdit->text().toDouble());
- }
if(isLogarithmic())
thePrs->SetScaling(VISU::LOGARITHMIC);
else
thePrs->SetScaling(VISU::LINEAR);
+
+ if (RBFrange->isChecked()) {
+ thePrs->SetSourceRange();
+ } else {
+ thePrs->SetRange(MinEdit->text().toDouble(), MaxEdit->text().toDouble());
+ }
thePrs->SetNbColors(ColorSpin->value());
thePrs->SetLabels(LabelSpin->value());
- thePrs->Update();
-
+
if (isToSave()) storeToResources();
}
#ifndef VISUGUI_SCALARBARDLG_H
#define VISUGUI_SCALARBARDLG_H
+#include "QAD_SpinBoxDbl.h"
+
#include <qdialog.h>
#include <qbuttongroup.h>
#include <qgroupbox.h>
#include <qlineedit.h>
#include <qcombobox.h>
-#include "QAD_SpinBoxDbl.h"
-#include "VISU_PrsObject_i.hh"
-
+namespace VISU{
+ class ScalarMap_i;
+}
class VisuGUI_ScalarBarDlg : public QDialog
{
#include "VisuGUI_PointsResultsDlg.h"
#include "VisuGUI_Selection.h"
-int PickViewer(QAD_Study *theActiveStudy, int theSelectionMode){
- SALOME_Selection *aSel = SALOME_Selection::Selection(theActiveStudy->getSelection());
- SALOME_ListIteratorOfListIO It(aSel->StoredIObjects());
- for(;It.More(); It.Next()){
- Handle(SALOME_InteractiveObject) IObject = It.Value();
- if (aSel->SelectionMode() == theSelectionMode ){
- if (aSel->HasIndex(IObject)) {
- TColStd_MapOfInteger MapIndex ;
- aSel->GetIndex(IObject, MapIndex) ;
- TColStd_MapIteratorOfMapOfInteger ite(MapIndex);
- for(;ite.More(); ite.Next())
- return ite.Key();
- }
- }
- }
- return -1;
-}
-
template<class TData, class TDialog> void SetMessage(TData* theData, int theId, TDialog* theDialog){
// Scalar result
QString Msg_1;
// PICKING CELL //
// ============================================================================================ //
-void VisuGUI_Selection::PickingCell(QAD_Study *theActiveStudy, vtkDataSet *theDataSet){
- int id = PickViewer(theActiveStudy,SelectionCell);
- if(id >= 0){
+void VisuGUI_Selection::PickingCell(QAD_Study *theActiveStudy, vtkDataSet *theDataSet, int theId){
+ if(theId >= 0){
VisuGUI_CellsResultsDlg *aResultsDlg = new VisuGUI_CellsResultsDlg(QAD_Application::getDesktop(), 0, TRUE, 0);
vtkCellData *aData = theDataSet->GetCellData();
- vtkCell *aCell = theDataSet->GetCell(id);
+ vtkCell *aCell = theDataSet->GetCell(theId);
float aPntCoord[12][3];
int aNbOfPoints = aCell->GetNumberOfPoints();
QString::number( aPntCoord[i][2] ));
}
- SetMessage(aData,id,aResultsDlg);
+ SetMessage(aData,theId,aResultsDlg);
- aResultsDlg->IdCell->setText( QString::number( id ) );
+ aResultsDlg->IdCell->setText( QString::number( theId ) );
aResultsDlg->NbPoint->setText( QString::number( aNbOfPoints ) );
aResultsDlg->exec();
delete aResultsDlg;
// PICKING POINT //
// ============================================================================================ //
-void VisuGUI_Selection::PickingPoint(QAD_Study *theActiveStudy, vtkDataSet *theDataSet){
- int id = PickViewer(theActiveStudy,SelectionPoint);
- if(id >= 0){
+void VisuGUI_Selection::PickingPoint(QAD_Study *theActiveStudy, vtkDataSet *theDataSet, int theId){
+ if(theId >= 0){
VisuGUI_PointsResultsDlg *aResultsDlg = new VisuGUI_PointsResultsDlg(QAD_Application::getDesktop(), 0, TRUE, 0);
vtkPointData *aData = theDataSet->GetPointData();
float Coord[3];
- theDataSet->GetPoint(id,Coord);
+ theDataSet->GetPoint(theId,Coord);
aResultsDlg->CoordX->setText( QString::number( Coord[0] ) );
aResultsDlg->CoordY->setText( QString::number( Coord[1] ) );
aResultsDlg->CoordZ->setText( QString::number( Coord[2] ) );
- aResultsDlg->IdPoint->setText( QString::number(id) );
+ aResultsDlg->IdPoint->setText( QString::number(theId) );
- SetMessage(aData,id,aResultsDlg);
+ SetMessage(aData,theId,aResultsDlg);
aResultsDlg->exec();
delete aResultsDlg;
void VisuGUI_Selection::Highlight(QAD_Study *theActiveStudy, const Handle(SALOME_InteractiveObject)& theIO, int theId){
MESSAGE("HighlightCell");
SALOME_Selection *aSel = SALOME_Selection::Selection(theActiveStudy->getSelection());
- aSel->AddIObject( theIO, false );
- aSel->AddOrRemoveIndex( theIO, theId, false, true );
+ aSel->AddIObject(theIO);
+ aSel->AddOrRemoveIndex(theIO, theId, false);
}
#define SelectionActor 4
namespace VisuGUI_Selection{
- void PickingCell(QAD_Study *theActiveStudy, vtkDataSet *theDataSet);
- void PickingPoint(QAD_Study *theActiveStudy, vtkDataSet *theDataSet);
+ void PickingCell(QAD_Study *theActiveStudy, vtkDataSet *theDataSet, int theId);
+ void PickingPoint(QAD_Study *theActiveStudy, vtkDataSet *theDataSet, int theId);
void Highlight(QAD_Study *theActiveStudy, const Handle(SALOME_InteractiveObject)& theIO, int theId);
};
// Module : VISU
#include "VisuGUI_StreamLinesDlg.h"
-#include <limits.h>
-#include <qlayout.h>
-#include <qgroupbox.h>
-#include <qcolordialog.h>
+#include "VISU_StreamLines_i.hh"
+#include "VISU_Mesh_i.hh"
+#include "VISU_Gen_i.hh"
+#include "VISU_StreamLinesPL.hxx"
+#include "VISU_Actor.h"
+
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include "QAD_Config.h"
+#include "QAD_MessageBox.h"
#include "VisuGUI.h"
#include "SALOME_Selection.h"
+#include "VTKViewer_ViewFrame.h"
+
+#include <limits.h>
+#include <qlayout.h>
+#include <qgroupbox.h>
+#include <qcolordialog.h>
+using namespace std;
extern VisuGUI *visuGUI;
aSrcLayout->setSpacing( 6 );
aSrcLayout->setMargin( 0 );
- myUseSrcChk = new QCheckBox(tr("Use source presentation"), aSourceBox);
- aSrcLayout->addMultiCellWidget(myUseSrcChk, 0, 0, 0, 1);
+ QLabel* aTypeLbl = new QLabel( tr( "LBL_SOURCE_TYPE" ), aSourceBox);
+ aSrcLayout->addWidget(aTypeLbl, 0, 0);
+
+ myUseSrcCombo = new QComboBox(aSourceBox);
+ const char* aChoise[] = { "None", "Entity", "Family", "Group", "Presentation", 0 };
+ myUseSrcCombo->insertStrList(aChoise);
+ aSrcLayout->addWidget(myUseSrcCombo, 0, 1);
mySrcCombo = new QComboBox(aSourceBox);
- mySrcCombo->setEnabled(myUseSrcChk->isChecked());
+ mySrcCombo->setEnabled((myUseSrcCombo->currentItem() == 0));
+
+ connect(myUseSrcCombo, SIGNAL(activated(int)), this, SLOT(onSourceTypeChange(int)));
// Find All prs obj
QAD_Study* aActiveStudy = VisuGUI::GetActiveStudy();
Handle(SALOME_InteractiveObject) aIO = aSel->firstIObject();
if (aIO->hasEntry()){
SALOMEDS::SObject_var aSObject = VisuGUI::GetStudyDocument()->FindObjectID(aIO->getEntry());
- SALOMEDS::SComponent_var aComp = aSObject->GetFatherComponent();
- SALOMEDS::ChildIterator_var aIter = VisuGUI::GetStudyDocument()->NewChildIterator( aComp );
+ aSObject = aSObject->GetFather();
+ aSObject = aSObject->GetFather();
+ aSObject = aSObject->GetFather();
+ aSObject = aSObject->GetFather();
+ mySelectionObj = aSObject;
+ CORBA::Object_var anObject = VISU::SObjectToObject(mySelectionObj);
+ VISU::Result_var aResult;
+ if (CORBA::is_nil(anObject)) {
+ mySelectionObj = mySelectionObj->GetFather();
+ }
+ SALOMEDS::ChildIterator_var aIter = VisuGUI::GetStudyDocument()->NewChildIterator( mySelectionObj );
for (aIter->InitEx(true); aIter->More(); aIter->Next() ) {
SALOMEDS::SObject_var aChildSObj = aIter->Value();
CORBA::Object_var aChildObject = VISU::SObjectToObject( aChildSObj );
+
if(!CORBA::is_nil( aChildObject ) ) {
VISU::Prs3d_var aPrsObj = VISU::Prs3d::_narrow( aChildObject );
- if( !CORBA::is_nil( aPrsObj ) ) {
- if (aPrsObj->GetType() != VISU::TSTREAMLINES) {
+ if( !CORBA::is_nil( aPrsObj ) ) { // if this is a Prs object
+ if ((aPrsObj->GetType() != VISU::TSTREAMLINES) &&
+ (aPrsObj->GetType() != VISU::TMESH)) {
SALOMEDS::GenericAttribute_var anAttr;
if ( aChildSObj->FindAttribute(anAttr, "AttributeName") ) {
SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
- mySrcCombo->insertItem(QString(aName->Value()));
+ myPrsLst += QString(aName->Value());
myPrsList.append(aPrsObj);
+ continue;
+ }
+ }
+ }
+ }
+ // else { // This is not a Prs object
+ SALOMEDS::GenericAttribute_var anAttr;
+ if (aChildSObj->FindAttribute(anAttr, "AttributeComment")) {
+ SALOMEDS::AttributeComment_var aComment = SALOMEDS::AttributeComment::_narrow(anAttr);
+ string aComm = aComment->Value();
+ QString strIn(aComm.c_str());
+ VISU::Storable::TRestoringMap aMap;
+ VISU::Storable::StrToMap(strIn,aMap);
+ bool isExist;
+ VISU::VISUType aType = (VISU::VISUType)VISU::Storable::FindValue(aMap,"myType",&isExist).toInt();
+ if (isExist) {
+ if ((aType == VISU::TFAMILY) || (aType == VISU::TGROUP) || (aType == VISU::TENTITY)) {
+ SALOMEDS::GenericAttribute_var aNameAttr;
+ if ( aChildSObj->FindAttribute(aNameAttr, "AttributeName") ) {
+ SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(aNameAttr);
+ VISU::Prs3d_var aPrsObj = VISU::Prs3d::_narrow( aChildObject );
+ switch(aType) {
+ case VISU::TFAMILY:
+ myFamilisLst += QString(aName->Value());
+ myFamilyList.append(aPrsObj);
+ break;
+ case VISU::TGROUP:
+ myGroupsLst += QString(aName->Value());
+ myGroupList.append(aPrsObj);
+ break;
+ case VISU::TENTITY:
+ myEntitiesLst += QString(aName->Value());
+ myEntityList.append(aPrsObj);
+ break;
+ }
}
}
}
}
}
}
-
- connect(myUseSrcChk, SIGNAL(toggled(bool)), mySrcCombo, SLOT(setEnabled(bool)));
+ // connect(myUseSrcChk, SIGNAL(toggled(bool)), mySrcCombo, SLOT(setEnabled(bool)));
aSrcLayout->addMultiCellWidget(mySrcCombo, 1, 1, 0, 1);
QLabel* aPercentLbl = new QLabel( tr( "Used points (0..1)" ), aSourceBox);
myStepLen = new QAD_SpinBoxDbl( this, DBL_MIN, DBL_MAX, 0.1);
myStepLen->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
TopLayout->addWidget(myStepLen, 1, 1);
+ connect(myStepLen, SIGNAL(valueChanged(double)), this, SLOT(StepLengthChanged(double)));
QLabel* aIntegStepLenLbl = new QLabel( tr( "Integration Step" ), this);
TopLayout->addWidget(aIntegStepLenLbl, 2, 0);
myIntegStepLen = new QAD_SpinBoxDbl( this, DBL_MIN, DBL_MAX, 0.1);
myIntegStepLen->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
TopLayout->addWidget(myIntegStepLen, 2, 1);
+ connect(myIntegStepLen, SIGNAL(valueChanged(double)), this, SLOT(IntegrationStepChanged(double)));
QLabel* aPropagationLbl = new QLabel( tr( "Propagation Time" ), this);
TopLayout->addWidget(aPropagationLbl, 3, 0);
myPropTime = new QAD_SpinBoxDbl( this, DBL_MIN, DBL_MAX, 1);
myPropTime->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
TopLayout->addWidget(myPropTime, 3, 1);
-
connect(myPropTime, SIGNAL(valueChanged(double)), this, SLOT(PropagationTimeChanged(double)));
QLabel* aDirLbl = new QLabel( tr( "Direction" ), this);
void VisuGUI_StreamLinesDlg::initFromPrsObject(VISU::StreamLines_i* thePrs) {
+ myPropTime->setValue(thePrs->GetPropagationTime());
+
+ myStepLen->setRange(VISU_StreamLinesPL::GetMinStepLength(thePrs->GetIntegrationStep()),
+ VISU_StreamLinesPL::GetMaxStepLength(thePrs->GetPropagationTime()));
myStepLen->setValue(thePrs->GetStepLength());
+
+ myIntegStepLen->setRange(thePrs->GetMinIntegrationStep(),thePrs->GetMaxIntegrationStep());
myIntegStepLen->setValue(thePrs->GetIntegrationStep());
- myPropTime->setValue(thePrs->GetPropagationTime());
+
switch (thePrs->GetDirection()) {
case VISU::StreamLines::FORWARD:
myDirCombo->setCurrentItem(0);
case VISU::StreamLines::BOTH:
myDirCombo->setCurrentItem(2);
}
- myUseScalar->setChecked(thePrs->isColored());
+ myUseScalar->setChecked(thePrs->IsColored());
myPntPercent->setValue(thePrs->GetUsedPoints());
-
- myUseSrcChk->setChecked(false);
+
+ mySrcCombo->setEnabled(false);
QString aSrcEntry = thePrs->GetSourceEntry();
- if (!aSrcEntry.isEmpty()) {
- for (int i = 0; i < myPrsList.count(); i++) {
- VISU::Prs3d_i* aPrs = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(myPrsList[i]));
- if (aSrcEntry == aPrs->GetEntry()) {
- myUseSrcChk->setChecked(true);
- mySrcCombo->setCurrentItem(i);
- break;
- }
- }
- }
-
+
SALOMEDS::Color anOldColor = thePrs->GetColor();
QColor aColor = QColor(int(255*anOldColor.R),int(255*anOldColor.G),int(255*anOldColor.B));
setColor(aColor);
enableSetColor();
+
+#define INITPRS(PRSLIST, PRSNUM) \
+ for (int i = 0; i < PRSLIST.count(); i++) { \
+ VISU::Prs3d_i* aPrs = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(PRSLIST[i])); \
+ if (aPrs == NULL) continue; \
+ if (aSrcEntry == aPrs->GetEntry()) { \
+ onSourceTypeChange(PRSNUM); \
+ myUseSrcCombo->setCurrentItem(PRSNUM); \
+ mySrcCombo->setEnabled(true); \
+ mySrcCombo->setCurrentItem(i); \
+ return; \
+ } \
+ }
+
+ if (!aSrcEntry.isEmpty()) {
+ INITPRS(myEntityList, 1);
+ INITPRS(myFamilyList, 2);
+ INITPRS(myGroupList, 3);
+ INITPRS(myPrsList, 4);
+ }
+
+#undef INITPRS
- myIntegStepLen->setMaxValue(thePrs->GetMaxIntegrationStep());
- myIntegStepLen->setMinValue(thePrs->GetMinIntegrationStep());
- myStepLen->setMaxValue(myPropTime->value());
- myStepLen->setMinValue(myPropTime->value()/10000.);
}
void VisuGUI_StreamLinesDlg::storeToPrsObject(VISU::StreamLines_i* thePrs) {
- thePrs->SetStepLength(myStepLen->value());
+ //Order of setting of the values are important
thePrs->SetIntegrationStep(myIntegStepLen->value());
thePrs->SetPropagationTime(myPropTime->value());
+ thePrs->SetStepLength(myStepLen->value());
switch (myDirCombo->currentItem()) {
case 0:
thePrs->SetDirection(VISU::StreamLines::FORWARD);
case 2:
thePrs->SetDirection(VISU::StreamLines::BOTH);
}
- thePrs->setColored(myUseScalar->isChecked());
- if(!thePrs->isColored()){
+ thePrs->ShowColored(myUseScalar->isChecked());
+ if(!thePrs->IsColored()){
SALOMEDS::Color aColor;
aColor.R = myColor.red()/255.;
aColor.G = myColor.green()/255.;
aColor.B = myColor.blue()/255.;
thePrs->SetColor(aColor);
}
- if (myUseSrcChk->isChecked() && (myPrsList.count() > 0)) {
- thePrs->SetSource(myPrsList[mySrcCombo->currentItem()]);
- } else
- thePrs->SetSource(VISU::Prs3d::_nil());
thePrs->SetUsedPoints(myPntPercent->value());
+
+ int aSrcSelection = myUseSrcCombo->currentItem();
+ int aSrcItem = (mySrcCombo->count() > 0)? mySrcCombo->currentItem() : -1;
+ if ((aSrcSelection > 0) && (aSrcItem > -1)) {
+ VISU::Prs3d_var aPrs;
+ VISU::VISUType aType;
+ QString aName;
+ switch (aSrcSelection){
+ case 1: // Entity
+ aPrs = myEntityList[aSrcItem];
+ aType = VISU::TENTITY;
+ aName = myEntitiesLst[aSrcItem];
+ break;
+ case 2: // Family
+ aPrs = myFamilyList[aSrcItem];
+ aType = VISU::TFAMILY;
+ aName = myFamilisLst[aSrcItem];
+ break;
+ case 3: // Group
+ aPrs = myGroupList[aSrcItem];
+ aType = VISU::TGROUP;
+ aName = myGroupsLst[aSrcItem];
+ break;
+ case 4: // Presentation
+ aPrs = myPrsList[aSrcItem];
+ break;
+ }
+ if (!CORBA::is_nil( aPrs )) {
+ thePrs->SetSource(aPrs);
+ } else if (aSrcSelection == 4) {
+ thePrs->SetSource(VISU::Prs3d::_nil());
+ } else { // Create Mesh presentation
+ thePrs->SetSource(createMesh(aType, aName));
+ }
+ } else
+ thePrs->SetSource(VISU::Prs3d::_nil());
}
/*!
SelColor->setEnabled(!myUseScalar->isChecked() );
}
+void VisuGUI_StreamLinesDlg::StepLengthChanged(double theValue){
+}
+
+void VisuGUI_StreamLinesDlg::IntegrationStepChanged(double theValue) {
+ PropagationTimeChanged(myPropTime->value());
+}
+
void VisuGUI_StreamLinesDlg::PropagationTimeChanged(double theValue) {
- myStepLen->setMaxValue(theValue);
- myStepLen->setMinValue(theValue/1000000.);
+ myStepLen->setMinValue(VISU_StreamLinesPL::GetMinStepLength(myIntegStepLen->value()));
+ myStepLen->setMaxValue(VISU_StreamLinesPL::GetMaxStepLength(myPropTime->value()));
+}
+
+void VisuGUI_StreamLinesDlg::onSourceTypeChange(int theIndex) {
+ mySrcCombo->clear();
+ if (theIndex == 0) {
+ mySrcCombo->setEnabled(false);
+ return;
+ } else
+ mySrcCombo->setEnabled(true);
+
+ switch(theIndex) {
+ case 1: // Entity
+ mySrcCombo->insertStringList(myEntitiesLst);
+ return;
+ case 2: // Family
+ mySrcCombo->insertStringList(myFamilisLst);
+ return;
+ case 3: // Group
+ mySrcCombo->insertStringList(myGroupsLst);
+ return;
+ case 4: // Presentation
+ mySrcCombo->insertStringList(myPrsLst);
+ return;
+ }
}
+
+VISU::Mesh_var VisuGUI_StreamLinesDlg::createMesh(VISU::VISUType theType, QString theName) {
+ CORBA::Object_var anObject = VISU::SObjectToObject(mySelectionObj);
+ VISU::Result_var aResult;
+ if (!CORBA::is_nil(anObject)) {
+ aResult = VISU::Result::_narrow(anObject);
+ }
+ if(CORBA::is_nil(aResult)) {
+ QAD_MessageBox::warn1(QAD_Application::getDesktop(), tr ("VISU_WARNING"),
+ tr ("WRN_NO_AVAILABLE_DATA"),
+ tr ("VISU_BUT_OK"));
+ return VISU::Mesh::_nil();
+ }
+ SALOMEDS::ChildIterator_var aIter = VisuGUI::GetStudyDocument()->NewChildIterator( mySelectionObj );
+ VISU::Storable::TRestoringMap aMap;
+
+ for (aIter->InitEx(true); aIter->More(); aIter->Next() ) {
+ SALOMEDS::SObject_var aChildSObj = aIter->Value();
+ SALOMEDS::GenericAttribute_var anAttr;
+ if (aChildSObj->FindAttribute(anAttr, "AttributeComment")) {
+ SALOMEDS::AttributeComment_var aComment = SALOMEDS::AttributeComment::_narrow(anAttr);
+ CORBA::String_var aComm = aComment->Value();
+ QString strIn(aComm.in());
+ aMap.clear();
+ VISU::Storable::StrToMap(strIn,aMap);
+ bool isExist;
+ VISU::VISUType aType = (VISU::VISUType)VISU::Storable::FindValue(aMap,"myType",&isExist).toInt();
+ if (isExist) {
+ if (aType != theType) continue;
+
+ SALOMEDS::GenericAttribute_var aNameAttr;
+ if ( aChildSObj->FindAttribute(aNameAttr, "AttributeName") ) {
+ SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(aNameAttr);
+ if (QString(aName->Value()) == theName) break; //use current map
+ }
+ }
+ }
+ }
+ CORBA::Object_var aMesh;
+ QString aMeshName = VISU::Storable::FindValue(aMap,"myMeshName");
+ switch (theType) {
+ case VISU::TFAMILY:
+ {
+ VISU::Entity anEntity = (VISU::Entity)VISU::Storable::FindValue(aMap,"myEntityId").toInt();
+ aMesh = VisuGUI::GetVisuGen()->FamilyMeshOnEntity(aResult,aMeshName.latin1(),anEntity,theName.latin1());
+ }
+ break;
+ case VISU::TGROUP:
+ {
+ aMesh = VisuGUI::GetVisuGen()->GroupMesh(aResult,aMeshName.latin1(), theName.latin1());
+ }
+ break;
+ case VISU::TENTITY:
+ {
+ VISU::Entity anEntity = (VISU::Entity)VISU::Storable::FindValue(aMap,"myId").toInt();
+ aMesh = VisuGUI::GetVisuGen()->MeshOnEntity(aResult,aMeshName.latin1(),anEntity);
+ }
+ break;
+ }
+ VISU::Mesh_i* pPresent = NULL;
+ if(!CORBA::is_nil(aMesh))
+ pPresent = dynamic_cast<VISU::Mesh_i*>(VISU::GetServant(aMesh));
+ if (pPresent == NULL) {
+ QAD_MessageBox::warn1 ( QAD_Application::getDesktop(), tr ("VISU_WARNING"),
+ tr ("ERR_CANT_BUILD_PRESENTATION"),
+ tr ("VISU_BUT_OK") );
+ return VISU::Mesh::_nil();
+ }
+ // Create Actor
+ if(VTKViewer_ViewFrame* vf = visuGUI->GetVtkViewFrame()){
+ try{
+ pPresent->SetPresentationType(VISU::POINT);
+ VISU_Actor *anActor = pPresent->CreateActor();
+ vf->AddActor(anActor);
+ }catch(std::runtime_error& exc){
+ QAD_MessageBox::warn1 ( QAD_Application::getDesktop(), tr ("VISU_WARNING"),
+ tr ("ERR_CANT_CREATE_ACTOR"),
+ tr ("VISU_BUT_OK") );
+ }
+ }
+ return pPresent->_this();
+}
#ifndef VISUGUI_STREAMLINESDLG_H
#define VISUGUI_STREAMLINESDLG_H
+#include "QAD_SpinBoxDbl.h"
+
#include <qdialog.h>
#include <qcombobox.h>
#include <qcheckbox.h>
-#include "QAD_SpinBoxDbl.h"
-#include "VISU_PrsObject_i.hh"
+#include <qstringlist.h>
+#include "SALOMEconfig.h"
+#include CORBA_CLIENT_HEADER(VISU_Gen)
+
+namespace VISU{
+ class StreamLines_i;
+}
class VisuGUI_StreamLinesDlg: public QDialog
{
private slots:
void onSelectionActive(bool theActive);
+ void StepLengthChanged(double theValue);
+ void IntegrationStepChanged(double theValue);
void PropagationTimeChanged(double theValue);
+ void onSourceTypeChange(int theIndex);
private:
+ VISU::Mesh_var createMesh(VISU::VISUType theType, QString theName);
+
QAD_SpinBoxDbl* myStepLen;
QAD_SpinBoxDbl* myIntegStepLen;
QAD_SpinBoxDbl* myPropTime;
QCheckBox* myUseScalar;
QPushButton* SelColor;
QColor myColor;
- QCheckBox* myUseSrcChk;
+ //QCheckBox* myUseSrcChk;
+ QComboBox* myUseSrcCombo;
QAD_SpinBoxDbl* myPntPercent;
QComboBox* mySrcCombo;
QValueList<VISU::Prs3d_var> myPrsList;
+ QValueList<VISU::Prs3d_var> myEntityList;
+ QValueList<VISU::Prs3d_var> myFamilyList;
+ QValueList<VISU::Prs3d_var> myGroupList;
+ QStringList myEntitiesLst;
+ QStringList myFamilisLst;
+ QStringList myGroupsLst;
+ QStringList myPrsLst;
+ SALOMEDS::SObject_var mySelectionObj;
private slots:
void setVColor();
#include "VisuGUI_StreamLinesDlg.h"
#include "VISU_TimeAnimation.h"
-static double MAXVALUE = 1.0E+300;
+#include "VISU_ScalarMap_i.hh"
+#include "VISU_IsoSurfaces_i.hh"
+#include "VISU_DeformedShape_i.hh"
+#include "VISU_CutPlanes_i.hh"
+#include "VISU_CutLines_i.hh"
+#include "VISU_Vectors_i.hh"
+#include "VISU_StreamLines_i.hh"
+static double MAXVALUE = 1.0E+300;
SetupDlg::SetupDlg(QWidget* theParent, VISU_TimeAnimation* theAnimator)
if (myAnimator->getFieldData(i).myPrs == 0)
myAnimator->generatePresentations(i);
}
+ if (myAnimator->getNbFrames() == 0) {
+ myPlayFrame->setEnabled(false);
+ QApplication::restoreOverrideCursor();
+ QMessageBox::warning(QAD_Application::getDesktop(), tr("ERROR"), tr("MSG_NO_ANIMATIONDATA"));
+ return;
+ }
mySlider->setMaxValue(myAnimator->getNbFrames()-1);
myPlayFrame->setEnabled(true);
if (!myAnimator->generateFrames()) {
//************************************************************************
void VisuGUI_TimeAnimationDlg::onPlayPressed() {
- if (myPlayBtn->isOn()) {
+ if (myPlayBtn->isOn() && (!myAnimator->running())) {
myPlayBtn->setIconSet(MYpausePixmap);
if (mySaveCheck->isChecked())
myAnimator->dumpTo(myPathEdit->text());
#include "VisuGUI_ScalarBarDlg.h"
-class VISU_TimeAnimation;
+#include "SALOMEconfig.h"
+#include CORBA_SERVER_HEADER(SALOMEDS)
+#include CORBA_SERVER_HEADER(SALOMEDS_Attributes)
+#include CORBA_CLIENT_HEADER(VISU_Gen)
+class VISU_TimeAnimation;
/**
* Auxilliary class for presentations definition
// Module : VISU
// $Header$
-using namespace std;
#include "VisuGUI_VectorsDlg.h"
-#include <qlayout.h>
-#include <qcolordialog.h>
+#include "VISU_Vectors_i.hh"
+
#include "QAD_Application.h"
#include "QAD_Desktop.h"
+#include <qlayout.h>
+#include <qcolordialog.h>
+
+using namespace std;
+
/*!
Constructor
*/
void VisuGUI_VectorsDlg::initFromPrsObject(VISU::Vectors_i* thePrs) {
setScaleFactor(thePrs->GetScale());
setLineWidth((int)thePrs->GetLineWidth());
- setUseMagnColor(thePrs->isColored());
+ setUseMagnColor(thePrs->IsColored());
SALOMEDS::Color anOldColor = thePrs->GetColor();
QColor aColor = QColor(int(255*anOldColor.R),int(255*anOldColor.G),int(255*anOldColor.B));
setColor(aColor);
void VisuGUI_VectorsDlg::storeToPrsObject(VISU::Vectors_i* thePrs) {
thePrs->SetScale(getScaleFactor());
thePrs->SetLineWidth(getLineWidth());
- thePrs->setColored(getUseMagnColor());
- if(!thePrs->isColored()){
+ thePrs->ShowColored(getUseMagnColor());
+ if(!thePrs->IsColored()){
SALOMEDS::Color aColor;
aColor.R = myColor.red()/255.;
aColor.G = myColor.green()/255.;
#ifndef VISUGUI_VECTORSDLG_H
#define VISUGUI_VECTORSDLG_H
+#include "QAD_SpinBoxDbl.h"
+
#include <qdialog.h>
#include <qbuttongroup.h>
#include <qgroupbox.h>
#include <qlabel.h>
#include <qspinbox.h>
#include <qpushbutton.h>
-#include "QAD_SpinBoxDbl.h"
-#include "VISU_PrsObject_i.hh"
+#include "SALOMEconfig.h"
+#include CORBA_CLIENT_HEADER(VISU_Gen)
+namespace VISU{
+ class Vectors_i;
+}
class VisuGUI_VectorsDlg : public QDialog
{
// Module : VISU
// $Header$
-using namespace std;
#include "VisuGUI_VisuAsDlg.h"
-#include "VISU_PrsObject_i.hh"
+
+#include "VISU_Actor.h"
+#include "VISU_Prs3d_i.hh"
+
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include "QAD_RightFrame.h"
#include "VTKViewer_ViewFrame.h"
+
#include <qlayout.h>
+using namespace std;
+
/*!
Constructor
*/
*/
bool VisuGUI_VisuAsDlg::ActorTypeIsValid( VISU_Actor* Actor, int test )
{
- VISU::Prs3d_i* aPrs3d = Actor->getPrs3d();
+ VISU::Prs3d_i* aPrs3d = Actor->GetPrs3d();
if(!aPrs3d) return false;
if(test == -1) {
switch(aPrs3d->GetType()){
#ifndef VISUGUI_VISUASDLG_H
#define VISUGUI_VISUASDLG_H
-#include "VISU_Actor.h"
-
#include <qdialog.h>
#include <qcombobox.h>
#include <qgroupbox.h>
#include <qpushbutton.h>
#include <qlabel.h>
+class VISU_Actor;
+
class VisuGUI_VisuAsDlg : public QDialog
{
Q_OBJECT
msgid "VisuGUI_IsoSurfacesDlg::Number of surfaces"
msgstr ""
+#: VisuGUI_IsoSurfacesDlg.cxx:170
+msgid "VisuGUI_IsoSurfacesDlg::WRN_LOGARITHMIC_RANGE_ISOSURF"
+msgstr "Logarithmic scaling: use range values > 0"
+
#: VisuGUI_MagnitudeDlg.cxx:43
msgid "VisuGUI_MagnitudeDlg::VISU_BUT_CANCEL"
msgstr "Cancel"
msgid "WRN_CANT_VISUALIZE_PRS"
msgstr "The presentation can't be visualized.\nNull actor is created."
+
+msgid "LBL_SOURCE_TYPE"
+msgstr "Source type"
+
+msgid "MSG_NO_ANIMATIONDATA"
+msgstr "There is no data for animation"
# Libraries targets
LIB = libVisuEngine.la
-LIB_SRC = VISU_Gen_i.cc VISU_Result_i.cc \
- VISU_PrsObject_i.cc VISU_ViewManager_i.cc VISU_Table_i.cc \
- VISU_Extractor.cxx VISU_FieldTransform.cxx \
- VISU_Convertor.cxx VISU_MedConvertor.cxx VISU_DatConvertor.cxx \
- VISU_Convertor_impl.cxx VISU_CorbaMedConvertor.cxx \
- VISU_TimeAnimation.cxx
+LIB_SRC = VISUConfig.cc VISU_Gen_i.cc VISU_Result_i.cc \
+ VISU_ViewManager_i.cc VISU_PrsObject_i.cc VISU_Table_i.cc \
+ VISU_Prs3d_i.cc VISU_Mesh_i.cc VISU_ScalarMap_i.cc \
+ VISU_IsoSurfaces_i.cc VISU_DeformedShape_i.cc \
+ VISU_CutPlanes_i.cc VISU_CutLines_i.cc \
+ VISU_Vectors_i.cc VISU_StreamLines_i.cc \
+ VISU_TimeAnimation.cxx VISU_CorbaMedConvertor.cxx
LIB_MOC = VISU_TimeAnimation.h
LIB_CLIENT_IDL = SALOMEDS.idl SALOMEDS_Attributes.idl
# Executables targets
-BIN = VISU_Convertor
-BIN_SRC = VISU_Convertor_impl.cxx VISU_MedConvertor.cxx
+BIN =
+BIN_SRC =
BIN_CLIENT_IDL =
BIN_SERVER_IDL =
EXPORT_HEADERS = VISUConfig.hh VISU_Gen_i.hh VISU_Result_i.hh \
VISU_PrsObject_i.hh VISU_ViewManager_i.hh VISU_Table_i.hh \
- VISU_Extractor.hxx VISU_FieldTransform.hxx VISU_Convertor.hxx \
+ VISU_Prs3d_i.hh VISU_Mesh_i.hh VISU_ScalarMap_i.hh \
+ VISU_IsoSurfaces_i.hh VISU_DeformedShape_i.hh \
+ VISU_CutPlanes_i.hh VISU_CutLines_i.hh \
+ VISU_Vectors_i.hh VISU_StreamLines_i.hh \
VISU_TimeAnimation.h
+
# additionnal information to compil and link file
CPPFLAGS += -ftemplate-depth-32 $(QT_INCLUDES) $(PYTHON_INCLUDES) $(OCC_INCLUDES) $(VTK_INCLUDES) \
$(MED2_INCLUDES) $(HDF5_INCLUDES) $(QWT_INCLUDES)
+
LDFLAGS += $(QT_MT_LIBS) $(VTK_LIBS) $(QWT_LIBS) -lSalomeNS -lTOOLSDS \
- -lSalomeContainer -lOpUtil -lSalomeGUI -lVTKViewer -lVisuObject -lSalomeHDFPersist
+ -lSalomeContainer -lOpUtil -lSalomeGUI -lVTKViewer -lSalomeHDFPersist \
+ -lVisuConvertor -lVisuPipeLine -lVisuObject
+
LIBS+= $(PYTHON_LIBS) $(MED2_LIBS) $(HDF5_LIBS) -lPlot2d
# additional file to be cleaned
CLEAN =
DISTCLEAN =
-@CONCLUDE@
-
-
-
+@CONCLUDE@
\ No newline at end of file
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISUConfig.cc
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISUConfig.hh"
+
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+namespace VISU{
+ //===========================================================================
+ QMutex* Base_i::myMutex = NULL; //apo - &VISUMutex;
+ CORBA::ORB_var Base_i::myOrb;
+ PortableServer::POA_var Base_i::myPOA;
+ SALOME_NamingService* Base_i::myNamingService;
+ SALOME_LifeCycleCORBA* Base_i::myEnginesLifeCycle;
+ VISU_Gen_i* Base_i::myVisuGenImpl;
+ Base_i::~Base_i() {}
+ char* Base_i::GetID(){
+ CORBA::Object_ptr anObject = _this();
+ CORBA::String_var aString = myOrb->object_to_string(anObject);
+ return aString._retn();
+ //return CORBA::string_dup(myOrb->object_to_string(_this()));
+ }
+
+ //===========================================================================
+ static int mySCnt = 0;
+ static int myQCnt = 0;
+ static int myIsBatchMode = 0;
+
+ Mutex::Mutex(QMutex* theMutex, QApplication* theQApp, int theDelay) :
+ myQApp(theQApp), isQAppLocked(theQApp->locked()), myDelay(theDelay),
+ myMutex(theMutex), isSessionLocked(theMutex->locked())
+ {
+ if(MYDEBUG) MESSAGE("Mutex::Mutex : "<<(!isQAppLocked && !myQCnt)<<" "<<(!isSessionLocked && !mySCnt));
+ if(!myIsBatchMode && isQAppLocked) myIsBatchMode++;
+ if(!isSessionLocked && !mySCnt) { myMutex->lock();}; mySCnt++;
+ if(!isQAppLocked && !myQCnt) {
+ myQApp->lock();
+ myQApp->syncX();
+ };
+ myQCnt++;
+ }
+ Mutex::~Mutex(){
+ myQCnt--;
+ if(!isQAppLocked && !myQCnt) {
+ myQApp->flushX();
+ //if(myDelay > 0)
+ myQApp->processEvents(myDelay+3);
+ myQApp->unlock();
+ }
+ mySCnt--; if(!isSessionLocked && !mySCnt) { myMutex->unlock();}
+ if(MYDEBUG) MESSAGE("Mutex::~Mutex : "<<(!isQAppLocked && !myQCnt)<<" "<<(!isSessionLocked && !mySCnt));
+ }
+
+
+ //===========================================================================
+ static Storable::TCallbackMap VisuStoreMap;
+ string Storable::ToString(){
+ ostringstream strOut;
+ Storable::DataToStream( strOut, "myComment", GetComment() );
+ ToStream(strOut);
+ strOut<<ends;
+ if(MYDEBUG) MESSAGE("Storable::ToString - "<<strOut.str());
+ //apo - auto_ptr<char> aRet(strOut.str());
+ return strOut.str();
+ }
+
+ void Storable::Registry(const char* theComment, TStorableEngine theEngine)
+ throw(std::logic_error&)
+ {
+ if(!VisuStoreMap.insert(TCallbackMap::value_type(theComment,theEngine)).second){
+ if(MYDEBUG) MESSAGE("Storable::Registry >> dupliacte registring !!!");
+ throw std::logic_error("Storable::Registry >> dupliacte registring !!!");
+ }
+ }
+
+ void Storable::StrToMap(const QString& theStr, VISU::Storable::TRestoringMap& theMap){
+ if(0 && MYDEBUG) MESSAGE("Storable::StrToMap : string="<<theStr);
+ QStringList strList = QStringList::split( ";", theStr, false );
+ for ( int i = 0; i < strList.count(); i++ ) {
+ QString next = strList[ i ];
+ int pos = next.find("=");
+ QString aName, aValue;
+ if ( pos < 0 ) {
+ aName = next.stripWhiteSpace();
+ aValue = "";
+ }
+ else {
+ aName = next.left( pos ).stripWhiteSpace();
+ aValue = next.mid( pos+1 );
+ if ( aValue.isNull() )
+ aValue = "";
+ }
+ if ( !aName.isEmpty() )
+ theMap.insert( TRestoringMap::value_type( aName.latin1(), aValue ) );
+ }
+ }
+
+ void Storable::DataToStream(ostringstream& theStr, const QString& theName, const QString& theVal) {
+ QString output = ( !theName.isNull() ? theName : QString("") )
+ + QString( "=" )
+ + ( !theVal.isNull() ? theVal : QString("") );
+ theStr<<output.latin1()<<";";
+ }
+
+ void Storable::DataToStream(ostringstream& theStr, const QString& theName, const int theVal) {
+ QString output = ( !theName.isNull() ? theName : QString("") )
+ + QString( "=" )
+ + QString::number( theVal );
+ theStr<<output.latin1()<<";";
+ }
+
+ void Storable::DataToStream(ostringstream& theStr, const QString& theName, const double theVal) {
+ QString output = ( !theName.isNull() ? theName : QString("") )
+ + QString( "=" )
+ + QString::number( theVal );
+ theStr<<output.latin1()<<";";
+ }
+ Storable* Storable::Create(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const string& theLocalPersistentID)
+ throw (std::runtime_error&)
+ {
+ try{
+ QString strIn( theLocalPersistentID.c_str() );
+ TRestoringMap aMap;
+ StrToMap(strIn,aMap);
+ //CORBA::String_var aResultID(GetResultSO(theSObject)->GetID());
+ //aMap.insert(TRestoringMap::value_type("ResultID", strdup(aResultID)));
+ bool isExist;
+ QString aComment = VISU::Storable::FindValue(aMap,"myComment",&isExist);
+ if ( isExist ) {
+ TCallbackMap::const_iterator i = VisuStoreMap.find(aComment.latin1());
+ if(MYDEBUG) MESSAGE("Storable::Create - "<<aComment.latin1()<<" "<<(i != VisuStoreMap.end()));
+ if(i == VisuStoreMap.end()) return NULL;
+ return (i->second)(theSObject,thePrefix,aMap);
+ }
+ }catch(std::logic_error& exc){
+ INFOS("Follow exception was accured :\n"<<exc.what());
+ }catch(...){
+ INFOS("Unknown exception was accured!");
+ }
+ return NULL;
+ }
+
+ const QString& Storable::FindValue(const TRestoringMap& theMap, const string& theArg, bool* isFind)
+ throw(std::logic_error&)
+ {
+ TRestoringMap::const_iterator i = theMap.find(theArg);
+ if(i == theMap.end()) {
+ if(MYDEBUG) MESSAGE("Storable::Init >> there is no value for "<<theArg);
+ if(isFind != NULL) *isFind = false;
+ //throw std::logic_error(string("Storable::Init >> there is no value for ") + theArg);
+ static QString BAD_VALUE("NULL");
+ return BAD_VALUE;
+ }
+ if(isFind != NULL) *isFind = true;
+ return i->second;
+ }
+
+
+ //===========================================================================
+ PortableServer::Servant GetServant(CORBA::Object_ptr theObject){
+ if(CORBA::is_nil(theObject)) return NULL;
+ try{
+ PortableServer::POA_ptr aPOA = Base_i::GetPOA();
+ return aPOA->reference_to_servant(theObject);
+ } catch (...) {
+ INFOS("GetServant - Unknown exception was accured!");
+ return NULL;
+ }
+ }
+
+
+ //===========================================================================
+ CORBA::Object_var SObjectToObject(SALOMEDS::SObject_ptr theSObject){
+ SALOMEDS::GenericAttribute_var anAttr;
+ CORBA::Object_var anObj;
+ try{
+ if(theSObject->FindAttribute(anAttr, "AttributeIOR")){
+ SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+ CORBA::String_var aValue = anIOR->Value();
+ CORBA::ORB_ptr anORB = Base_i::GetORB();
+ if(strcmp(aValue,"") != 0)
+ anObj = anORB->string_to_object(aValue);
+ }
+ }catch(...){
+ INFOS("SObjectToObject - Unknown exception was accured!");
+ }
+ return anObj;
+ }
+
+
+ //===========================================================================
+ string FindEntryWithComment(SALOMEDS::Study_ptr theStudyDocument, const char* theStartEntry,
+ const char* theComment, int IsAllLevels)
+ {
+ SALOMEDS::ChildIterator_var anIter =
+ theStudyDocument->NewChildIterator(theStudyDocument->FindObjectID(theStartEntry));
+ anIter->InitEx(IsAllLevels);
+ SALOMEDS::SObject_var aFieldSO;
+ for(;anIter->More();anIter->Next()) {
+ SALOMEDS::GenericAttribute_var anAttr;
+ if (anIter->Value()->FindAttribute(anAttr,"AttributeComment")) {
+ SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr);
+ CORBA::String_var aString = aCmnt->Value();
+ string aValue(aString);
+ if (aValue == theComment) {
+ aFieldSO = anIter->Value();
+ aString = aFieldSO->GetID();
+ aValue = aString;
+ return aValue;
+ }
+ }
+ }
+ return "";
+ }
+ //===========================================================================
+ string CreateAttributes(SALOMEDS::Study_ptr theStudyDocument,
+ const char* theFatherEntry, const char* theRefFatherEntry,
+ const char* theIOR, const char* theName,
+ const char* thePersistentRef, const char* theComment,
+ CORBA::Boolean theCreateNew)
+ {
+ SALOMEDS::StudyBuilder_var aStudyBuilder = theStudyDocument->NewBuilder();
+ SALOMEDS::SObject_var aFather = theStudyDocument->FindObjectID(theFatherEntry);
+ SALOMEDS::SObject_var newObj;
+ if (theCreateNew) newObj = aStudyBuilder->NewObject(aFather);
+ else newObj = aFather;
+ SALOMEDS::GenericAttribute_var anAttr;
+ if(strcmp(theIOR,"") != 0){
+ anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributeIOR");
+ SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+ anIOR->SetValue(theIOR);
+ }
+ if(strcmp(theName,"") != 0){
+ anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributeName");
+ SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
+ aName->SetValue(theName);
+ }
+ if(strcmp(thePersistentRef,"") != 0){
+ anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributePersistentRef");
+ SALOMEDS::AttributePersistentRef_var aPRef = SALOMEDS::AttributePersistentRef::_narrow(anAttr);
+ aPRef->SetValue(thePersistentRef);
+ }
+ if(strcmp(theComment,"") != 0){
+ anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributeComment");
+ SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr);
+ aCmnt->SetValue(theComment);
+ INFOS("CreateAttributes - Comment = "<<theComment);
+ }
+ if(strcmp(theRefFatherEntry,"") != 0){
+ SALOMEDS::SObject_var aRefFather = theStudyDocument->FindObjectID(theRefFatherEntry);
+ SALOMEDS::SObject_var anObj = aStudyBuilder->NewObject(aRefFather);
+ aStudyBuilder->Addreference(anObj,newObj);
+ }
+ CORBA::String_var anEntry = newObj->GetID();
+ string aRet(anEntry);
+ if(0 && MYDEBUG) MESSAGE("CreateAttributes - anEntry = "<<aRet<<"; IOR = "<<theIOR);
+ return aRet;
+ }
+}
+
+
+QString VISU::GenerateName(const string& theFmt, int theId){
+ static QString aName;
+ if(theId > 0)
+ aName.sprintf("%s:%d",theFmt.c_str(),theId);
+ else
+ aName.sprintf("%s",theFmt.c_str());
+ return aName;
+}
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
-// File : VISU_Common.hh
+// File : VISUConfig.hh
// Author : Alexey PETROV
// Module : VISU
#include <qfileinfo.h>
#include <qapplication.h>
-using namespace std;
-
// IDL headers
-#include <SALOMEconfig.h>
+#include "SALOMEconfig.h"
#include CORBA_SERVER_HEADER(VISU_Gen)
#include CORBA_SERVER_HEADER(MED)
#include CORBA_SERVER_HEADER(SALOMEDS)
namespace VISU{
//===========================================================================
class VISU_Gen_i;
+
class Base_i : public virtual POA_VISU::Base,
public virtual PortableServer::RefCountServantBase
{
static SALOME_NamingService* GetNS() { return myNamingService;}
static SALOME_LifeCycleCORBA* GetLCC() { return myEnginesLifeCycle;}
static VISU_Gen_i* GetVisuGenImpl() { return myVisuGenImpl;}
- static VISU_Gen_var GetVisuGenInter();
};
+
+
//===========================================================================
class Mutex{
QMutex* myMutex;
Mutex(QMutex* theMutex, QApplication* theQApp, int theDelay = 0);
~Mutex();
};
+
+
//===========================================================================
class Storable : public virtual Base_i {
protected:
virtual void ToStream(std::ostringstream& theStr) = 0;
public:
- string ToString();
+ std::string ToString();
virtual const char* GetComment() const = 0;
- typedef map<string,QString> TRestoringMap;
+ typedef std::map<std::string,QString> TRestoringMap;
typedef Storable* (*TStorableEngine)(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const TRestoringMap& theMap);
- typedef map<string,TStorableEngine> TCallbackMap;
+ const std::string& thePrefix, const TRestoringMap& theMap);
+ typedef std::map<string,TStorableEngine> TCallbackMap;
static void Registry(const char* theComment, TStorableEngine theEngine)
throw(std::logic_error&);
- static Storable* Create(SALOMEDS::SObject_ptr, const string& thePrefix, const string& theString)
+ static Storable* Create(SALOMEDS::SObject_ptr, const std::string& thePrefix, const std::string& theString)
throw(std::runtime_error&);
- static const QString& FindValue(const TRestoringMap& theMap, const string& theArg, bool* isFind = NULL)
+ static const QString& FindValue(const TRestoringMap& theMap, const std::string& theArg, bool* isFind = NULL)
throw(std::logic_error&);
static void StrToMap(const QString& theStr, VISU::Storable::TRestoringMap& theMap);
static SALOMEDS::SObject_ptr GetResultSO(SALOMEDS::SObject_ptr theSObject);
static void DataToStream(std::ostringstream& theStr, const QString& theName, const int theVal);
static void DataToStream(std::ostringstream& theStr, const QString& theName, const double theVal);
};
+
+
//===========================================================================
const CORBA::Boolean IsMultifile();
+ QString GenerateName(const string& theFmt, int theId);
+
PortableServer::Servant GetServant(CORBA::Object_ptr theObject);
CORBA::Object_var SObjectToObject(SALOMEDS::SObject_ptr theSObject);
+
SALOMEDS::SComponent_var FindOrCreateVisuComponent(SALOMEDS::Study_ptr theStudyDocument);
- string CreateAttributes(SALOMEDS::Study_ptr theStudyDocument,
- const char* theFatherEntry, const char* theRefFatherEntry,
- const char* theIOR, const char* theName,
- const char* thePersistentRef, const char* theComment,
- CORBA::Boolean theCreateNew = true);
- string FindEntryWithComment(SALOMEDS::Study_ptr theStudyDocument, const char* theStartEntry,
- const char* theComment, int IsAllLevels = true);
+
+ std::string CreateAttributes(SALOMEDS::Study_ptr theStudyDocument,
+ const char* theFatherEntry, const char* theRefFatherEntry,
+ const char* theIOR, const char* theName,
+ const char* thePersistentRef, const char* theComment,
+ CORBA::Boolean theCreateNew = true);
+
+ std::string FindEntryWithComment(SALOMEDS::Study_ptr theStudyDocument, const char* theStartEntry,
+ const char* theComment, int IsAllLevels = true);
}
#endif
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : VISU_CorbaMedConvertor.cxx
// Author : Alexey PETROV
// Module : VISU
+// $Header$
+// Copyright (C) 2003 CEA/DEN, EDF R&D
-using namespace std;
#include "VISU_CorbaMedConvertor.hxx"
-using namespace VISU;
+
#include <valarray>
#include <vtkCellType.h>
+using namespace VISU;
+using namespace std;
+
#define USER_INTERLACE MED_FULL_INTERLACE
-#ifdef DEBUG
+#ifdef _DEBUG_
static int MYDEBUG = 0;
#else
static int MYDEBUG = 0;
SALOME_MED::MED_TETRA4,
SALOME_MED::MED_PYRA5,
SALOME_MED::MED_PENTA6,
- SALOME_MED::MED_TETRA10,
SALOME_MED::MED_HEXA8,
+ SALOME_MED::MED_TETRA10,
SALOME_MED::MED_PYRA13,
SALOME_MED::MED_PENTA15,
SALOME_MED::MED_HEXA20
CORBAMED2VTK(MED_TETRA4,VTK_TETRA,4),
CORBAMED2VTK(MED_PYRA5,VTK_PYRAMID,5),
CORBAMED2VTK(MED_PENTA6,VTK_WEDGE,6),
- CORBAMED2VTK(MED_TETRA10,VTK_TETRA,4),
CORBAMED2VTK(MED_HEXA8,VTK_HEXAHEDRON,8),
+ CORBAMED2VTK(MED_TETRA10,VTK_TETRA,4),
CORBAMED2VTK(MED_PYRA13,VTK_PYRAMID,5),
CORBAMED2VTK(MED_PENTA15,VTK_WEDGE,6),
CORBAMED2VTK(MED_HEXA20,VTK_HEXAHEDRON,8)
return "";
}
+
+static void GetCellsSize(vtkIdType& theNbCells, vtkIdType& theCellsSize,
+ SALOME_MED::MESH_ptr theMEDMesh,
+ const VISU::TEntity& theEntity)
+{
+ int iGeomElemEnd;
+ int* aGeomElemVector;
+ GetEntity2Geom(theEntity,aGeomElemVector,&iGeomElemEnd);
+ theNbCells = theCellsSize = 0;
+ const SALOME_MED::medEntityMesh& aMedEntity = aVisu2MedEntity[theEntity];
+ if(MYDEBUG) MESSAGE("GetCellsSize - theEntity = "<<theEntity);
+ for (int iGeomElem = 0, aCounter = 0; iGeomElem < iGeomElemEnd; iGeomElem++) {
+ int medId = GetIdMEDType(aGeomElemVector[iGeomElem]);
+ SALOME_MED::medGeometryElement aMedType = salome_med2vtk[medId].medType;
+ med_int iNumElemEnd = theMEDMesh->getNumberOfElements(aMedEntity,aMedType);
+ if(iNumElemEnd > 0){
+ if(MYDEBUG) MESSAGE("GetCellsSize - iNumElemEnd = "<<iNumElemEnd);
+ theNbCells += iNumElemEnd;
+ theCellsSize += iNumElemEnd*(salome_med2vtk[medId].vtkNbNodes + 1);
+ }
+ }
+}
+
+
+static void GetCellsSize(vtkIdType& theNbCells, vtkIdType& theCellsSize,
+ SALOME_MED::FAMILY_ptr theMEDFamily)
+{
+ SALOME_MED::medGeometryElement_array_var aGeom = theMEDFamily->getTypes();
+ med_int iGeomElemEnd = aGeom->length();
+ theNbCells = theCellsSize = 0;
+ if(MYDEBUG) MESSAGE("GetCellsSize - iGeomElemEnd = "<<iGeomElemEnd);
+ for (int iGeomElem = 0; iGeomElem < iGeomElemEnd; iGeomElem++) {
+ SALOME_MED::medGeometryElement aGeomType = aGeom[iGeomElem];
+ Engines::long_array_var aCellNumForType = theMEDFamily->getNumber(aGeomType);
+ int medId = GetIdMEDType(aGeomType);
+ med_int iNumElemEnd = aCellNumForType->length();
+ if(iNumElemEnd > 0){
+ if(MYDEBUG) MESSAGE("GetCellsSize - iNumElemEnd = "<<iNumElemEnd);
+ theNbCells += iNumElemEnd;
+ theCellsSize += iNumElemEnd*(salome_med2vtk[medId].vtkNbNodes + 1);
+ }
+ }
+}
+
+
+static void GetCellsSize(VISU::TMesh& theMesh,
+ SALOME_MED::MESH_ptr theMEDMesh,
+ const VISU::TEntity& theEntity)
+{
+ VISU::TMeshOnEntity& aMeshOnEntity = theMesh.myMeshOnEntityMap[theEntity];
+ if(theEntity == VISU::NODE_ENTITY){
+ theMesh.myNbPoints = theMEDMesh->getNumberOfNodes();
+ aMeshOnEntity.myNbCells = theMesh.myNbPoints;
+ aMeshOnEntity.myCellsSize = 2*theMesh.myNbPoints;
+ vtkIdType aNbCells, aCellsSize;
+ GetCellsSize(aNbCells,aCellsSize,theMEDMesh,VISU::CELL_ENTITY);
+ if(aNbCells > 0){
+ VISU::TMeshOnEntity& aMeshOnCells = theMesh.myMeshOnEntityMap[VISU::CELL_ENTITY];
+ aMeshOnCells.myEntity = VISU::CELL_ENTITY;
+ aMeshOnCells.myMeshName = theMesh.myName;
+ aMeshOnCells.myNbCells = aNbCells;
+ aMeshOnCells.myCellsSize = aCellsSize;
+ }
+ }else
+ GetCellsSize(aMeshOnEntity.myNbCells,aMeshOnEntity.myCellsSize,theMEDMesh,theEntity);
+}
+
+
VISU_Convertor* VISU_MEDFieldConvertor::Build() throw (std::runtime_error&){
if(myField->_is_nil())
throw std::runtime_error("VISU_MEDFieldConvertor::Build >> myField->_is_nil() !!!");
aMeshOnEntity.myMeshName = aMeshName.in();
VISUMED::TMeshOnEntity& aMeshOnEntity2 = aMesh2.myMeshOnEntityMap[anEntity];
aMeshOnEntity2.mySupport = aMEDSupport;
- if(anEntity == VISU::NODE_ENTITY){
- aMesh.myMeshOnEntityMap[VISU::CELL_ENTITY].myEntity = VISU::CELL_ENTITY;
- aMesh.myMeshOnEntityMap[VISU::CELL_ENTITY].myMeshName = aMeshName.in();
+ if(anEntity == VISU::NODE_ENTITY)
aMesh2.myMeshOnEntityMap[VISU::CELL_ENTITY].mySupport = aMEDSupport;
- }
+ GetCellsSize(aMesh,aMEDMesh,anEntity);
VISU::TField& aField = aMeshOnEntity.myFieldMap[aFieldName.in()];
aField.myId = myField->getOrderNumber();
aField.myEntity = anEntity;
aField.myMeshName = aMeshName.in();
aField.myNbComp = myField->getNumberOfComponents();
+ aField.myNbValField = 1;
+ aField.myDataSize = aMeshOnEntity.myNbCells * aField.myNbComp;
aField.myCompNames.resize(aField.myNbComp);
aField.myUnitNames.resize(aField.myNbComp);
if(MYDEBUG) MESSAGE("VISU_MEDFieldConvertor::Build - aMeshName = "<<aMeshName<<"; myDim = "<<aMesh.myDim);
CORBA::Short aTag = mySObject->Tag();
SALOMEDS::SObject_var aMedCompSObj = mySObject->GetFather();
SALOMEDS::SObject_var aMeshSObj;
- CORBA::Boolean aBool = aMedCompSObj->FindSubObject(aTag+1,aMeshSObj);
- if(!aBool) throw std::runtime_error("VISU_MEDConvertor::Build >> Cann't find MEDMESH label !!!");
+ if(!aMedCompSObj->FindSubObject(aTag+1,aMeshSObj))
+ throw std::runtime_error("VISU_MEDConvertor::Build >> Cann't find MEDMESH label !!!");
if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - MEDMESH found.");
SALOMEDS::ChildIterator_var aMeshIterator = aStudy->NewChildIterator(aMeshSObj);
for(; aMeshIterator->More(); aMeshIterator->Next()){
if(CORBA::is_nil(aMedSupport)) continue;
SALOME_MED::SUPPORT_var aMEDSupport = SALOME_MED::SUPPORT::_narrow(aMedSupport);
if(aMEDSupport->_is_nil()) continue;
+ SALOME_MED::MESH_var aMeshOnSupport = aMEDSupport->getMesh();
SALOME_MED::medEntityMesh aMEDEntity = aMEDSupport->getEntity();
VISU::TEntity anEntity = aMed2VisuEntity[aMEDEntity];
CORBA::String_var aSupportName = aMEDSupport->getName();
- bool isDataPresent = false;
if(aMEDSupport->isOnAllElements()){
if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - Support isOnAllElements = '"<<aSupportName<<"' anEntity = "<<anEntity);
+ int aNbCells, aCellsSize;
//Check, if there is any data on the support?
- SALOME_MED::MESH_var aMeshOnSupport = aMEDSupport->getMesh();
if(anEntity == VISU::NODE_ENTITY){
- if(aMeshOnSupport->getNumberOfNodes() > 0)
- isDataPresent = true;
+ aMesh.myNbPoints = aMeshOnSupport->getNumberOfNodes();
+ aNbCells = aMesh.myNbPoints;
+ aCellsSize = 2*aMesh.myNbPoints;
}else{
- int iGeomElemEnd;
- int* aGeomElemVector;
- GetEntity2Geom(anEntity,aGeomElemVector,&iGeomElemEnd);
- const SALOME_MED::medEntityMesh& aMedEntity = aVisu2MedEntity[anEntity];
- for (int iGeomElem = 0, aCounter = 0; iGeomElem < iGeomElemEnd; iGeomElem++) {
- int medId = GetIdMEDType(aGeomElemVector[iGeomElem]);
- SALOME_MED::medGeometryElement aMedType = salome_med2vtk[medId].medType;
- med_int iNumElemEnd = aMeshOnSupport->getNumberOfElements(aMedEntity,aMedType);
- if(iNumElemEnd > 0) {
- isDataPresent = true;
- break;
- }
- }
+ GetCellsSize(aNbCells,aCellsSize,aMeshOnSupport,anEntity);
}
- if(!isDataPresent) continue;
+ if(aNbCells == 0) continue;
VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity];
- aMeshOnEntity.myEntity = anEntity;
aMeshOnEntity.myMeshName = aMeshName.in();
- VISUMED::TMeshOnEntity& aMeshOnEntity2 = aMesh2.myMeshOnEntityMap[anEntity];
+ aMeshOnEntity.myEntity = anEntity;
+ aMeshOnEntity.myNbCells = aNbCells;
+ aMeshOnEntity.myCellsSize = aCellsSize;
+
+ VISUMED::TMeshOnEntity& aMeshOnEntity2 = aMesh2.myMeshOnEntityMap[anEntity];
aMeshOnEntity2.mySupport = aMEDSupport;
}else{
SALOME_MED::FAMILY_var aMEDFamily = SALOME_MED::FAMILY::_narrow(aMedSupport);
if(!aMEDFamily->_is_nil()) {
- if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aFamily = '"<<aSupportName<<"' anEntity = "<<anEntity);
- VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity];
- VISU::TFamily& aFamily = aMeshOnEntity.myFamilyMap[aSupportName.in()];
- aFamily.myName = aSupportName.in();
- aFamily.myEntity = anEntity;
- aFamily.myId = aMEDFamily->getIdentifier();
- VISUMED::TMeshOnEntity& aMeshOnEntity2 = aMesh2.myMeshOnEntityMap[anEntity];
- VISUMED::TFamily& aFamily2 = aMeshOnEntity2.myFamilyMap[aSupportName.in()];
- aFamily2.myFamily = aMEDFamily;
+ int aNbCells, aCellsSize;
+ GetCellsSize(aNbCells,aCellsSize,aMEDFamily);
+ if(aNbCells > 0){
+ if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aFamily = '"<<aSupportName<<"' anEntity = "<<anEntity);
+ VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity];
+ VISU::TFamily& aFamily = aMeshOnEntity.myFamilyMap[aSupportName.in()];
+ aFamily.myName = aSupportName.in();
+ aFamily.myEntity = anEntity;
+ aFamily.myNbCells = aNbCells;
+ aFamily.myCellsSize = aCellsSize;
+ aFamily.myId = aMEDFamily->getIdentifier();
+
+ VISUMED::TMeshOnEntity& aMeshOnEntity2 = aMesh2.myMeshOnEntityMap[anEntity];
+ VISUMED::TFamily& aFamily2 = aMeshOnEntity2.myFamilyMap[aSupportName.in()];
+ aFamily2.myFamily = aMEDFamily;
+ }
}
SALOME_MED::GROUP_var aMEDGroup = SALOME_MED::GROUP::_narrow(aMedSupport);
if(!aMEDGroup->_is_nil()) {
VISUMED::TGroupMap& aGroupMap2 = aMesh2.myGroupMap;
VISUMED::TGroup& aGroup2 = aGroupMap2[aSupportName.in()];
aGroup2.myGroup = aMEDGroup;
- //VISU::TGroupMap& aGroupMap = aMesh.myGroupMap;
- //VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity];
- //VISU::TGroup& aGroup = aGroupMap[aSupportName.in()];
- //aGroup.myName = aSupportName.in();
- //aGroup.myMeshName = aMesh.myName;
SALOME_MED::Family_array_var aFamilies = aMEDGroup->getFamilies();
int iFamilyEnd = aFamilies->length();
for(int iFamaily = 0; iFamaily < iFamilyEnd; iFamaily++){
aMEDFamily = aFamilies[iFamaily];
CORBA::String_var aFamilyName = aMEDFamily->getName();
VISU::TMeshOnEntity& aMeshOnEntity = aMesh.myMeshOnEntityMap[anEntity];
+ if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aGroup - aFamilyName = '"<<aFamilyName.in()<<"'");
VISU::TFamily& aFamily = aMeshOnEntity.myFamilyMap[aFamilyName.in()];
VISU::TBindGroups& aBindGroups = aFamily.myGroups;
aBindGroups.insert(aSupportName.in());
VISU::TGroup& aGroup = aGroupMap[aGroupName];
aGroup.myName = aGroupName;
aGroup.myMeshName = aMesh.myName;
+ aGroup.myNbCells += aFamily.myNbCells;
+ aGroup.myCellsSize += aFamily.myCellsSize;
VISU::TFamilyAndEntity aFamilyAndEntity(aFamily.myName,aFamily.myEntity);
aGroup.myFamilyAndEntitySet.insert(aFamilyAndEntity);
}
}
}
SALOMEDS::SObject_var aFieldSObj;
- aBool = aMedCompSObj->FindSubObject(aTag+2,aFieldSObj);
- if(aBool){
+ if(aMedCompSObj->FindSubObject(aTag+2,aFieldSObj)){
if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - MEDFIELD found.");
SALOMEDS::ChildIterator_var aFieldIterator = aStudy->NewChildIterator(aFieldSObj);
for(int iField = 0; aFieldIterator->More(); aFieldIterator->Next(), iField++){
aFieldSObj = aFieldIterator->Value();
if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aFieldName = '"<<::GetName(aFieldSObj)<<"'");
SALOMEDS::ChildIterator_var aTimeStampIterator = aStudy->NewChildIterator(aFieldSObj);
- for(; aTimeStampIterator->More(); aTimeStampIterator->Next()){
+ for(int iTimeStamp = 1; aTimeStampIterator->More(); aTimeStampIterator->Next(), iTimeStamp++){
SALOMEDS::SObject_var aTimeStampSObj = aTimeStampIterator->Value();
if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aTimeStampSObj = '"<<::GetName(aTimeStampSObj)<<"'");
CORBA::Object_var aMedField = SObjectToObject(aTimeStampSObj);
aMeshOnEntity.myMeshName = aMeshName.in();
VISUMED::TMeshOnEntity& aMeshOnEntity2 = aMesh2.myMeshOnEntityMap[anEntity];
aMeshOnEntity2.mySupport = aMEDSupport;
- if(anEntity == VISU::NODE_ENTITY){
- aMesh.myMeshOnEntityMap[VISU::CELL_ENTITY].myEntity = VISU::CELL_ENTITY;
- aMesh.myMeshOnEntityMap[VISU::CELL_ENTITY].myMeshName = aMeshName.in();
+ if(anEntity == VISU::NODE_ENTITY)
aMesh2.myMeshOnEntityMap[VISU::CELL_ENTITY].mySupport = aMEDSupport;
- }
+ GetCellsSize(aMesh,aMEDMesh,anEntity);
VISU::TField& aField = aMeshOnEntity.myFieldMap[aFieldName.in()];
aField.myId = iField;
aField.myEntity = anEntity;
aField.myMeshName = aMeshName.in();
aField.myNbComp = aMEDField->getNumberOfComponents();
+ aField.myNbValField = iTimeStamp;
+ aField.myDataSize = aMeshOnEntity.myNbCells * aField.myNbComp;
+ if(MYDEBUG && !iTimeStamp)
+ MESSAGE("VISU_MEDConvertor::Build - aMeshOnEntity.myNbCells = "<<aMeshOnEntity.myNbCells);
aField.myCompNames.resize(aField.myNbComp);
aField.myUnitNames.resize(aField.myNbComp);
- //int iTimeStamp = aMEDField->getOrderNumber();
- int iTimeStamp = aMEDField->getIterationNumber();
- VISU::TField::TValForTime& aValForTime = aField.myValField[iTimeStamp];
- aValForTime.myId = iTimeStamp;
- double dt = aMEDField->getTime();
- aValForTime.myTime = VISU::TField::TTime(dt,"");
+ int anId = aMEDField->getIterationNumber();
+ VISU::TField::TValForTime& aValForTime = aField.myValField[anId];
+ aValForTime.myId = anId;
+ aValForTime.myTime = VISU::TField::TTime(aMEDField->getTime(),"");
VISUMED::TField& aField2 = aMeshOnEntity2.myFieldMap[aFieldName.in()];
- VISUMED::TField::TValForTime& aValForTime2 = aField2.myValField[iTimeStamp];
+ VISUMED::TField::TValForTime& aValForTime2 = aField2.myValField[anId];
aValForTime2.myField = aMEDField;
if(MYDEBUG)
- MESSAGE("VISU_MEDConvertor::Build - aMeshName = '"<<aMeshName<<"'; myEntity = "<<anEntity<<"; myTime = "<<dt);
+ MESSAGE("VISU_MEDConvertor::Build - aMeshName = '"<<aMeshName<<
+ "'; myEntity = "<<anEntity<<"; myTime = "<<aValForTime.myTime.first);
}
}
}
return NULL;
}
SALOMEDS::ChildIterator_var aTimeStampIterator = aStudy->NewChildIterator(mySObject);
- for(; aTimeStampIterator->More(); aTimeStampIterator->Next()){
+ for(int iTimeStamp = 1; aTimeStampIterator->More(); aTimeStampIterator->Next(), iTimeStamp++){
SALOMEDS::SObject_var aTimeStampSObj = aTimeStampIterator->Value();
if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aTimeStampSObj = '"<<::GetName(aTimeStampSObj)<<"'");
CORBA::Object_var aMedField = SObjectToObject(aTimeStampSObj);
VISU::TMesh &aMesh = myMeshMap[aMeshName.in()];
aMesh.myDim = aMEDMesh->getSpaceDimension();
aMesh.myName = aMeshName.in();
+ aMesh.myNbPoints = aMEDMesh->getNumberOfNodes();
VISUMED::TMesh &aMesh2 = myMeshMap2[aMeshName.in()];
aMesh2.myMesh = aMEDMesh;
if(MYDEBUG) MESSAGE("VISU_MEDConvertor::Build - aMeshName = "<<aMeshName<<"; myDim = "<<aMesh.myDim);
aMeshOnEntity.myMeshName = aMeshName.in();
VISUMED::TMeshOnEntity& aMeshOnEntity2 = aMesh2.myMeshOnEntityMap[anEntity];
aMeshOnEntity2.mySupport = aMEDSupport;
- if(anEntity == VISU::NODE_ENTITY){
- aMesh.myMeshOnEntityMap[VISU::CELL_ENTITY].myEntity = VISU::CELL_ENTITY;
- aMesh.myMeshOnEntityMap[VISU::CELL_ENTITY].myMeshName = aMeshName.in();
+ if(anEntity == VISU::NODE_ENTITY)
aMesh2.myMeshOnEntityMap[VISU::CELL_ENTITY].mySupport = aMEDSupport;
- }
+ GetCellsSize(aMesh,aMEDMesh,anEntity);
VISU::TField& aField = aMeshOnEntity.myFieldMap[aFieldName.in()];
CORBA::Short iField = mySObject->Tag();
aField.myEntity = anEntity;
aField.myMeshName = aMeshName.in();
aField.myNbComp = aMEDField->getNumberOfComponents();
+ aField.myNbValField = iTimeStamp;
+ aField.myDataSize = aMeshOnEntity.myNbCells * aField.myNbComp;
+ if(MYDEBUG && !iTimeStamp)
+ MESSAGE("VISU_MEDConvertor::Build - aMeshOnEntity.myNbCells = "<<aMeshOnEntity.myNbCells);
aField.myCompNames.resize(aField.myNbComp);
aField.myUnitNames.resize(aField.myNbComp);
- //int iTimeStamp = aMEDField->getOrderNumber();
- int iTimeStamp = aMEDField->getIterationNumber();
- VISU::TField::TValForTime& aValForTime = aField.myValField[iTimeStamp];
- aValForTime.myId = iTimeStamp;
- double dt = aMEDField->getTime();
- aValForTime.myTime = VISU::TField::TTime(dt,"");
+ int anId = aMEDField->getIterationNumber();
+ VISU::TField::TValForTime& aValForTime = aField.myValField[anId];
+ aValForTime.myId = anId;
+ aValForTime.myTime = VISU::TField::TTime(aMEDField->getTime(),"");
VISUMED::TField& aField2 = aMeshOnEntity2.myFieldMap[aFieldName.in()];
- VISUMED::TField::TValForTime& aValForTime2 = aField2.myValField[iTimeStamp];
+ VISUMED::TField::TValForTime& aValForTime2 = aField2.myValField[anId];
aValForTime2.myField = aMEDField;
if(MYDEBUG)
- MESSAGE("VISU_MEDConvertor::Build - aMeshName = '"<<aMeshName<<"'; myEntity = "<<anEntity<<"; myTime = "<<dt);
+ MESSAGE("VISU_MEDConvertor::Build - aMeshName = '"<<aMeshName<<
+ "'; myEntity = "<<anEntity<<"; myTime = "<<aValForTime.myTime.first);
}
return this;
}
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : VISU_CorbaMedConvertor.hxx
// Author : Alexey PETROV
// Module : VISU
+// $Header$
+// Copyright (C) 2003 CEA/DEN, EDF R&D
#ifndef VISU_CorbaMedConvertor_HeaderFile
#define VISU_CorbaMedConvertor_HeaderFile
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_CutLinesPL.hxx"
+#include "VISU_Result_i.hh"
+#include "VISU_CutLines_i.hh"
+#include "VISU_Actor.h"
+
+#include "VISU_PipeLineUtils.hxx"
+
+#include <vtkAppendPolyData.h>
+
+using namespace VISU;
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+int VISU::CutLines_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration);
+}
+
+int VISU::CutLines_i::myNbPresent = 0;
+QString VISU::CutLines_i::GenerateName() { return VISU::GenerateName("CutLines",myNbPresent++);}
+
+const string VISU::CutLines_i::myComment = "CUTLINES";
+const char* VISU::CutLines_i::GetComment() const { return myComment.c_str();}
+
+VISU::CutLines_i::CutLines_i(Result_i* theResult, bool theAddToStudy) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ Prs3d_i(theResult),
+ ScalarMap_i(theResult, theAddToStudy)
+{
+ myCutLinesPL = NULL;
+}
+
+void VISU::CutLines_i::Destroy(){
+ ScalarMap_i::Destroy();
+}
+
+void VISU::CutLines_i::SameAs(const CutLines_i* theOrigin){
+ CutLines_i* aCutLines = const_cast<CutLines_i*>(theOrigin);
+ VISU::ScalarMap_i::SameAs(theOrigin);
+
+ //SetNbLines(aCutLines->GetNbLines());
+ //SetDisplacement(aCutLines->GetDisplacement());
+ //SetDisplacement2(aCutLines->GetDisplacement2());
+ //SetOrientationType(aCutLines->GetOrientationType());
+ //SetOrientationType2(aCutLines->GetOrientationType2());
+ //SetRotateX(aCutLines->GetRotateX());
+ //SetRotateY(aCutLines->GetRotateY());
+ //SetRotateX2(aCutLines->GetRotateX2());
+ //SetRotateY2(aCutLines->GetRotateY2());
+}
+
+VISU::Storable* VISU::CutLines_i::Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+}
+
+VISU::Storable* VISU::CutLines_i::Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ ScalarMap_i::Restore(theMap);
+ SetNbLines(VISU::Storable::FindValue(theMap,"myNbLines").toInt());
+ SetDisplacement(VISU::Storable::FindValue(theMap,"myDisplacement[0]").toDouble());
+ SetDisplacement2(VISU::Storable::FindValue(theMap,"myDisplacement[1]").toDouble());
+ SetOrientationType(VISU::CutPlanes::Orientation(VISU::Storable::FindValue(theMap,"myBasePlane[0]").toInt()));
+ SetOrientationType(VISU::CutPlanes::Orientation(VISU::Storable::FindValue(theMap,"myBasePlane[1]").toInt()));
+ SetRotateX(VISU::Storable::FindValue(theMap,"aRot[0][0]").toDouble());
+ SetRotateY(VISU::Storable::FindValue(theMap,"aRot[0][1]").toDouble());
+ SetRotateX2(VISU::Storable::FindValue(theMap,"aRot[1][0]").toDouble());
+ SetRotateY2(VISU::Storable::FindValue(theMap,"aRot[1][1]").toDouble());
+
+ return Build(true);
+}
+
+void VISU::CutLines_i::ToStream(std::ostringstream& theStr){
+ ScalarMap_i::ToStream(theStr);
+ Storable::DataToStream( theStr, "myNbLines", int(GetNbLines()) );
+ Storable::DataToStream( theStr, "myDisplacement[0]", GetDisplacement() );
+ Storable::DataToStream( theStr, "myDisplacement[1]", GetDisplacement2() );
+ Storable::DataToStream( theStr, "myBasePlane[0]", int(GetOrientationType()) );
+ Storable::DataToStream( theStr, "myBasePlane[1]", int(GetOrientationType2()) );
+ Storable::DataToStream( theStr, "aRot[0][0]", GetRotateX() );
+ Storable::DataToStream( theStr, "aRot[0][1]", GetRotateY() );
+ Storable::DataToStream( theStr, "aRot[1][0]", GetRotateX2() );
+ Storable::DataToStream( theStr, "aRot[1][1]", GetRotateY2() );
+}
+
+VISU::Storable* VISU::CutLines_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ VISU::Result_i* pResult = GetResult(theSObject);
+ if(pResult != NULL){
+ VISU::CutLines_i* pResent = new VISU::CutLines_i(pResult);
+ return pResent->Restore(theMap);
+ }
+ return NULL;
+}
+
+
+VISU::CutLines_i::~CutLines_i(){
+ if(MYDEBUG) MESSAGE("CutLines_i::~CutLines_i()");
+}
+
+
+void VISU::CutLines_i::SetOrientationType(VISU::CutPlanes::Orientation theOrient){
+ myCutLinesPL->SetPlaneOrientation(VISU_CutPlanesPL::PlaneOrientation(theOrient));
+}
+void VISU::CutLines_i::SetOrientationType2(VISU::CutPlanes::Orientation theOrient){
+ myCutLinesPL->SetPlaneOrientation(VISU_CutPlanesPL::PlaneOrientation(theOrient),1);
+}
+
+VISU::CutPlanes::Orientation VISU::CutLines_i::GetOrientationType() {
+ return VISU::CutPlanes::Orientation(myCutLinesPL->GetPlaneOrientation());
+}
+VISU::CutPlanes::Orientation VISU::CutLines_i::GetOrientationType2() {
+ return VISU::CutPlanes::Orientation(myCutLinesPL->GetPlaneOrientation(1));
+}
+
+
+void VISU::CutLines_i::SetDisplacement(CORBA::Double theDisp) {
+ myCutLinesPL->SetDisplacement(theDisp);
+}
+void VISU::CutLines_i::SetDisplacement2(CORBA::Double theDisp) {
+ myCutLinesPL->SetDisplacement(theDisp,1);
+}
+
+CORBA::Double VISU::CutLines_i::GetDisplacement() {
+ return myCutLinesPL->GetDisplacement();
+}
+CORBA::Double VISU::CutLines_i::GetDisplacement2() {
+ return myCutLinesPL->GetDisplacement(1);
+}
+
+
+void VISU::CutLines_i::SetBasePlanePosition(CORBA::Double thePlanePosition){
+ myCutLinesPL->SetPosition(thePlanePosition);
+}
+
+CORBA::Double VISU::CutLines_i::GetBasePlanePosition(){
+ return myCutLinesPL->GetPosition();
+}
+
+void VISU::CutLines_i::SetLinePosition(CORBA::Long thePlaneNumber, CORBA::Double thePlanePosition){
+ myCutLinesPL->SetPartPosition(thePlaneNumber,thePlanePosition);
+}
+
+CORBA::Double VISU::CutLines_i::GetLinePosition(CORBA::Long thePlaneNumber){
+ return myCutLinesPL->GetPartPosition(thePlaneNumber,1);
+}
+
+
+void VISU::CutLines_i::SetDefault(){
+ myCutLinesPL->SetDefault();
+}
+
+CORBA::Boolean VISU::CutLines_i::IsDefault(){
+ return myCutLinesPL->IsDefault();
+}
+
+void VISU::CutLines_i::SetDefaultPosition(CORBA::Long thePlaneNumber){
+ myCutLinesPL->SetPartDefault(thePlaneNumber);
+}
+
+CORBA::Boolean VISU::CutLines_i::IsDefaultPosition(CORBA::Long thePlaneNumber){
+ return myCutLinesPL->IsPartDefault(thePlaneNumber);
+}
+
+
+void VISU::CutLines_i::SetNbLines(CORBA::Long theNb) {
+ myCutLinesPL->SetNbParts(theNb);
+}
+CORBA::Long VISU::CutLines_i::GetNbLines() {
+ return myCutLinesPL->GetNbParts();
+}
+
+
+void VISU::CutLines_i::SetRotateX(CORBA::Double theAngle){
+ myCutLinesPL->SetRotateX(theAngle);
+}
+CORBA::Double VISU::CutLines_i::GetRotateX(){
+ return myCutLinesPL->GetRotateX();
+}
+
+void VISU::CutLines_i::SetRotateY(CORBA::Double theAngle){
+ myCutLinesPL->SetRotateY(theAngle);
+}
+CORBA::Double VISU::CutLines_i::GetRotateY(){
+ return myCutLinesPL->GetRotateY();
+}
+
+void VISU::CutLines_i::SetRotateX2(CORBA::Double theAngle){
+ myCutLinesPL->SetRotateX(theAngle,1);
+}
+CORBA::Double VISU::CutLines_i::GetRotateX2(){
+ return myCutLinesPL->GetRotateX(1);
+}
+
+void VISU::CutLines_i::SetRotateY2(CORBA::Double theAngle){
+ myCutLinesPL->SetRotateY(theAngle,1);
+}
+CORBA::Double VISU::CutLines_i::GetRotateY2(){
+ return myCutLinesPL->GetRotateY(1);
+}
+
+void VISU::CutLines_i::DoHook(){
+ if(!myPipeLine) myPipeLine = VISU_CutLinesPL::New();
+ myCutLinesPL = dynamic_cast<VISU_CutLinesPL*>(myPipeLine);
+
+ ScalarMap_i::DoHook();
+}
+
+void VISU::CutLines_i::BuildTableOfReal(SALOMEDS::SObject_ptr theSObject){
+
+ if(MYDEBUG) MESSAGE("CutPlanes_i::BuildTableOfReal");
+ Update();
+ SALOMEDS::GenericAttribute_var anAttr;
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ anAttr = aStudyBuilder->FindOrCreateAttribute(theSObject, "AttributeTableOfReal");
+ SALOMEDS::AttributeTableOfReal_var aTableOfReal = SALOMEDS::AttributeTableOfReal::_narrow(anAttr);
+
+ typedef set<long> TLineCont;
+ typedef map<float,TLineCont> TXMap;
+ typedef map<float,float> TXYMap;
+ typedef vector<TXYMap> TCurveVect;
+
+ const VISU::TField::TValField& aValField = myField->myValField;
+ const VISU::TField::TValForTime& aValForTime = aValField.find((int)myIteration)->second;
+ const VISU::TField::TTime& aTime = aValForTime.myTime;
+ QString aTitle;
+ //aTitle.sprintf("%s %s",myTitle.c_str(),aTime.second.c_str());
+ aTitle.sprintf("%s",myTitle.c_str());
+ aTitle = aTitle.simplifyWhiteSpace();
+ aTableOfReal->SetTitle(aTitle.latin1());
+
+ int iLineEnd = myCutLinesPL->GetAppendPolyData()->GetNumberOfInputs();
+ if(MYDEBUG) MESSAGE("CutPlanes_i::BuildTableOfReal iLineEnd = "<<iLineEnd);
+ TCurveVect aCurveVect(iLineEnd);
+ TLineCont aLineCont;
+ TXMap aXMap;
+ const float *aDirLn = myCutLinesPL->GetDirLn();
+ const float *aBasePnt = myCutLinesPL->GetBasePnt();
+ const float *aBoundPrjLn = myCutLinesPL->GetBoundPrjLn();
+ for(int iLine = 0; iLine < iLineEnd; iLine++){
+ vtkDataSet *aDataSet = myCutLinesPL->GetAppendPolyData()->GetInput(iLine);
+ aDataSet->Update();
+ int aNbPoints = aDataSet->GetNumberOfPoints();
+ vtkPointData *aPointData = aDataSet->GetPointData();
+ vtkDataArray *aScalars = aPointData->GetScalars();
+ vtkCellDataToPointData *aFilter = NULL;
+ if(!aScalars) {
+ aFilter = vtkCellDataToPointData::New();
+ aFilter->SetInput(aDataSet);
+ aFilter->PassCellDataOn();
+ aDataSet = aFilter->GetOutput();
+ aDataSet->Update();
+ }
+ aPointData = aDataSet->GetPointData();
+ aScalars = aPointData->GetScalars();
+ if(!aScalars) continue;
+ if(MYDEBUG) MESSAGE("CutPlanes_i::BuildTableOfReal iLine = "<<iLine<<"; aNbPoints = "<<aNbPoints);
+ aLineCont.insert(iLine);
+ TXYMap& aXYMap = aCurveVect[iLine];
+ float aPnt[3], aVect[3], aDist;
+ for(int i = 0; i < aNbPoints; i++){
+ aDataSet->GetPoint(i,aPnt);
+ Sub(aPnt,aBasePnt,aVect);
+ aDist = vtkMath::Dot(aVect,aDirLn) / aBoundPrjLn[2];
+ // the workaround
+ if(aDist < 0.0) aDist = 0.0;
+ if(aDist > 1.0) aDist = 1.0;
+ aXYMap[aDist] = aScalars->GetTuple1(i);
+ //aXMap[aDist].insert(iLine);
+ }
+ if(aFilter) aFilter->Delete();
+ }
+ iLineEnd = aLineCont.size();
+ if(iLineEnd == 0){
+ MESSAGE("CutPlanes_i::BuildTableOfReal aLineCont.size() == 0 !!!");
+ return;
+ }
+ //Resorting of theXYMap
+ for(int iLine = 0; iLine < iLineEnd; iLine++){
+ TXYMap& aXYMap = aCurveVect[iLine], aNewXYMap;
+ if(aXYMap.size() > 2){
+ TXYMap::const_iterator aXYMapIter[2] = {aXYMap.begin(), ++aXYMap.begin()};
+ aNewXYMap[aXYMapIter[0]->first] = aXYMapIter[0]->second;
+ aXMap[aXYMapIter[0]->first].insert(iLine);
+ for(; aXYMapIter[1] != aXYMap.end(); aXYMapIter[0]++, aXYMapIter[1]++){
+ float aY[3] = {aXYMapIter[0]->second, aXYMapIter[1]->second, 0.0};
+ aY[2] = (aY[0] + aY[1])/2.0;
+ float aX[3] = {aXYMapIter[0]->first, aXYMapIter[1]->first, 0.0};
+ aX[2] = (aX[0] + aX[1])/2.0;
+ aNewXYMap[aX[2]] = aY[2];
+ aXMap[aX[2]].insert(iLine);
+ }
+ aNewXYMap[aXYMapIter[0]->first] = aXYMapIter[0]->second;
+ aXMap[aXYMapIter[0]->first].insert(iLine);
+ aXYMap = aNewXYMap;
+ }else{
+ TXYMap::const_iterator aXYMapIter = aXYMap.begin();
+ for(; aXYMapIter != aXYMap.end(); aXYMapIter++){
+ aXMap[aXYMapIter->first].insert(iLine);
+ }
+ }
+ }
+ QString aString;
+ aTableOfReal->SetNbColumns(aXMap.size());
+ TXMap::const_iterator aXMapIter = aXMap.begin();
+ for(long i = 0; aXMapIter != aXMap.end(); aXMapIter++, i++){
+ float aDist = aXMapIter->first;
+ aTableOfReal->PutValue(aDist,1,i+1);
+ aString.sprintf("%d",i);
+ aTableOfReal->SetColumnTitle(i+1,aString.latin1());
+ const TLineCont& aLineCont = aXMapIter->second;
+ long jEnd = aLineCont.size();
+ if(MYDEBUG) MESSAGE("CutPlanes_i::BuildTableOfReal aDist = "<<aDist<<"; jEnd = "<<jEnd);
+ TLineCont::const_iterator aLineContIter = aLineCont.begin();
+ for(; aLineContIter != aLineCont.end(); aLineContIter++){
+ long iLine = *aLineContIter;
+ const TXYMap& aXYMap = aCurveVect[iLine];
+ TXYMap::const_iterator aXYMapIter = aXYMap.find(aDist);
+ if(aXYMapIter == aXYMap.end()) continue;
+ float aVal = aXYMapIter->second;
+ aTableOfReal->PutValue(aVal,iLine+2,i+1);
+ }
+ }
+
+ aTableOfReal->SetRowTitle(1,"X");
+ TLineCont::const_iterator aLineContIter = aLineCont.begin();
+ QString aUnitName = myField->myUnitNames[0].c_str();
+ int aScalarMode = myCutLinesPL->GetScalarMode();
+ if(aScalarMode != 0)
+ aUnitName = myField->myUnitNames[aScalarMode-1].c_str();
+ aUnitName = aUnitName.simplifyWhiteSpace();
+ for(long i = 0; aLineContIter != aLineCont.end(); aLineContIter++, i++){
+ long iLine = *aLineContIter;
+ aString.sprintf("Y%d",iLine);
+ aTableOfReal->SetRowTitle(i+2,aString.latin1());
+ aTableOfReal->SetRowUnit(i+2,aUnitName.latin1());
+ }
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_CutLines_i_HeaderFile
+#define VISU_CutLines_i_HeaderFile
+
+#include "VISU_ScalarMap_i.hh"
+
+class VISU_CutLinesPL;
+
+namespace VISU{
+ class CutLines_i : public virtual POA_VISU::CutLines,
+ public virtual ScalarMap_i
+ {
+ static int myNbPresent;
+ CutLines_i();
+ CutLines_i(const CutLines_i&);
+ public:
+ CutLines_i(Result_i* theResult, bool theAddToStudy = true);
+ virtual void SameAs(const CutLines_i* theOrigin);
+ virtual ~CutLines_i();
+ virtual void Destroy();
+
+ virtual VISU::VISUType GetType() { return VISU::TCUTLINES;};
+
+ virtual void SetOrientationType(VISU::CutPlanes::Orientation theOrient);
+ virtual VISU::CutPlanes::Orientation GetOrientationType();
+
+ virtual void SetOrientationType2(VISU::CutPlanes::Orientation theOrient);
+ virtual VISU::CutPlanes::Orientation GetOrientationType2();
+
+ virtual void SetDisplacement(CORBA::Double theDisp);
+ virtual CORBA::Double GetDisplacement();
+
+ virtual void SetDisplacement2(CORBA::Double theDisp);
+ virtual CORBA::Double GetDisplacement2();
+
+ virtual void SetBasePlanePosition(CORBA::Double thePlanePosition);
+ virtual CORBA::Double GetBasePlanePosition();
+
+ virtual void SetLinePosition(CORBA::Long thePlaneNumber, CORBA::Double thePlanePosition);
+ virtual CORBA::Double GetLinePosition(CORBA::Long thePlaneNumber);
+
+ virtual void SetDefault();
+ virtual CORBA::Boolean IsDefault();
+
+ virtual void SetDefaultPosition(CORBA::Long thePlaneNumber);
+ virtual CORBA::Boolean IsDefaultPosition(CORBA::Long thePlaneNumber);
+
+ virtual void SetNbLines(CORBA::Long theNb);
+ virtual CORBA::Long GetNbLines();
+
+ virtual void SetRotateX(CORBA::Double theAngle);
+ virtual CORBA::Double GetRotateX();
+ virtual void SetRotateY(CORBA::Double theAngle);
+ virtual CORBA::Double GetRotateY();
+
+ virtual void SetRotateX2(CORBA::Double theAngle);
+ virtual CORBA::Double GetRotateX2();
+ virtual void SetRotateY2(CORBA::Double theAngle);
+ virtual CORBA::Double GetRotateY2();
+
+ typedef VISU::CutLines TInterface;
+ VISU_CutLinesPL* GetCutLinesPL(){ return myCutLinesPL;}
+
+ protected:
+ virtual void DoHook();
+
+ VISU_CutLinesPL *myCutLinesPL;
+
+ public:
+ static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+ virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+
+ virtual void ToStream(std::ostringstream& theStr);
+
+ virtual Storable* Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+
+ void BuildTableOfReal(SALOMEDS::SObject_ptr theSObject);
+
+ static const string myComment;
+ virtual const char* GetComment() const;
+ virtual QString GenerateName();
+ };
+}
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_CutPlanesPL.hxx"
+#include "VISU_Result_i.hh"
+#include "VISU_CutPlanes_i.hh"
+#include "VISU_Actor.h"
+
+using namespace VISU;
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+int VISU::CutPlanes_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration);
+}
+
+
+int VISU::CutPlanes_i::myNbPresent = 0;
+QString VISU::CutPlanes_i::GenerateName() { return VISU::GenerateName("CutPlanes",myNbPresent++);}
+
+
+const string VISU::CutPlanes_i::myComment = "CUTPLANES";
+const char* VISU::CutPlanes_i::GetComment() const { return myComment.c_str();}
+
+
+VISU::CutPlanes_i::CutPlanes_i(Result_i* theResult, bool theAddToStudy) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ Prs3d_i(theResult),
+ ScalarMap_i(theResult, theAddToStudy)
+{
+ myCutPlanesPL = NULL;
+}
+
+
+void VISU::CutPlanes_i::Destroy(){
+ ScalarMap_i::Destroy();
+}
+
+
+void VISU::CutPlanes_i::SameAs(const CutPlanes_i* theOrigin){
+ CutPlanes_i* aCutPlanes = const_cast<CutPlanes_i*>(theOrigin);
+ VISU::ScalarMap_i::SameAs(theOrigin);
+
+ //SetNbPlanes(aCutPlanes->GetNbPlanes());
+ //SetDisplacement(aCutPlanes->GetDisplacement());
+ //SetOrientationType(aCutPlanes->GetOrientationType());
+ //SetRotateX(aCutPlanes->GetRotateX());
+ //SetRotateY(aCutPlanes->GetRotateY());
+}
+
+
+VISU::Storable* VISU::CutPlanes_i::Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+}
+
+
+VISU::Storable* VISU::CutPlanes_i::Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ ScalarMap_i::Restore(theMap);
+
+ SetNbPlanes(VISU::Storable::FindValue(theMap,"myNbPlanes").toInt());
+ SetDisplacement(VISU::Storable::FindValue(theMap,"myDisplacement").toDouble());
+ SetOrientationType(VISU::CutPlanes::Orientation(VISU::Storable::FindValue(theMap,"myBasePlane").toInt()));
+ SetRotateX(VISU::Storable::FindValue(theMap,"aRot[0]").toDouble());
+ SetRotateY(VISU::Storable::FindValue(theMap,"aRot[1]").toDouble());
+
+ return Build(true);
+}
+
+
+void VISU::CutPlanes_i::ToStream(std::ostringstream& theStr){
+ ScalarMap_i::ToStream(theStr);
+
+ Storable::DataToStream( theStr, "myNbPlanes", int(GetNbPlanes()) );
+ Storable::DataToStream( theStr, "myDisplacement", GetDisplacement() );
+ Storable::DataToStream( theStr, "myBasePlane", int(GetOrientationType()) );
+ Storable::DataToStream( theStr, "aRot[0]", GetRotateX() );
+ Storable::DataToStream( theStr, "aRot[1]", GetRotateY() );
+}
+
+
+VISU::Storable* VISU::CutPlanes_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ VISU::Result_i* pResult = GetResult(theSObject);
+ if(pResult != NULL){
+ VISU::CutPlanes_i* pResent = new VISU::CutPlanes_i(pResult);
+ return pResent->Restore(theMap);
+ }
+ return NULL;
+}
+
+
+VISU::CutPlanes_i::~CutPlanes_i(){
+ if(MYDEBUG) MESSAGE("CutPlanes_i::~CutPlanes_i()");
+}
+
+
+void VISU::CutPlanes_i::SetOrientationType(VISU::CutPlanes::Orientation theOrient){
+ myCutPlanesPL->SetPlaneOrientation(VISU_CutPlanesPL::PlaneOrientation(theOrient));
+}
+VISU::CutPlanes::Orientation VISU::CutPlanes_i::GetOrientationType() {
+ return VISU::CutPlanes::Orientation(myCutPlanesPL->GetPlaneOrientation());
+}
+
+
+void VISU::CutPlanes_i::SetDisplacement(CORBA::Double theDisp) {
+ myCutPlanesPL->SetDisplacement(theDisp);
+}
+CORBA::Double VISU::CutPlanes_i::GetDisplacement() {
+ return myCutPlanesPL->GetDisplacement();
+}
+
+
+void VISU::CutPlanes_i::SetPlanePosition(CORBA::Long thePlaneNumber, CORBA::Double thePlanePosition){
+ myCutPlanesPL->SetPartPosition(thePlaneNumber,thePlanePosition);
+}
+CORBA::Double VISU::CutPlanes_i::GetPlanePosition(CORBA::Long thePlaneNumber){
+ return myCutPlanesPL->GetPartPosition(thePlaneNumber);
+}
+
+
+void VISU::CutPlanes_i::SetDefault(CORBA::Long thePlaneNumber){
+ myCutPlanesPL->SetPartDefault(thePlaneNumber);
+}
+CORBA::Boolean VISU::CutPlanes_i::IsDefault(CORBA::Long thePlaneNumber){
+ return myCutPlanesPL->IsPartDefault(thePlaneNumber);
+}
+
+
+void VISU::CutPlanes_i::SetNbPlanes(CORBA::Long theNb) {
+ myCutPlanesPL->SetNbParts(theNb);
+}
+CORBA::Long VISU::CutPlanes_i::GetNbPlanes() {
+ return myCutPlanesPL->GetNbParts();
+}
+
+
+void VISU::CutPlanes_i::SetRotateX(CORBA::Double theAngle){
+ myCutPlanesPL->SetRotateX(theAngle);
+}
+CORBA::Double VISU::CutPlanes_i::GetRotateX(){
+ return myCutPlanesPL->GetRotateX();
+}
+
+
+void VISU::CutPlanes_i::SetRotateY(CORBA::Double theAngle){
+ myCutPlanesPL->SetRotateY(theAngle);
+}
+CORBA::Double VISU::CutPlanes_i::GetRotateY(){
+ return myCutPlanesPL->GetRotateY();
+}
+
+
+void VISU::CutPlanes_i::DoHook(){
+ if(!myPipeLine) myPipeLine = VISU_CutPlanesPL::New();
+ myCutPlanesPL = dynamic_cast<VISU_CutPlanesPL*>(myPipeLine);
+
+ ScalarMap_i::DoHook();
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_CutPlanes_i_HeaderFile
+#define VISU_CutPlanes_i_HeaderFile
+
+#include "VISU_ScalarMap_i.hh"
+
+class VISU_CutPlanesPL;
+
+namespace VISU{
+ class CutPlanes_i : public virtual POA_VISU::CutPlanes,
+ public virtual ScalarMap_i
+ {
+ static int myNbPresent;
+ CutPlanes_i();
+ CutPlanes_i(const CutPlanes_i&);
+ public:
+ CutPlanes_i(Result_i* theResult, bool theAddToStudy = true);
+ virtual void SameAs(const CutPlanes_i* theOrigin);
+ virtual ~CutPlanes_i();
+ virtual void Destroy();
+
+ virtual VISU::VISUType GetType() { return VISU::TCUTPLANES;};
+
+ virtual void SetOrientationType(VISU::CutPlanes::Orientation theOrient);
+ virtual VISU::CutPlanes::Orientation GetOrientationType();
+
+ virtual void SetDisplacement(CORBA::Double theDisp);
+ virtual CORBA::Double GetDisplacement();
+
+ virtual void SetPlanePosition(CORBA::Long thePlaneNumber, CORBA::Double thePlanePosition);
+ virtual CORBA::Double GetPlanePosition(CORBA::Long thePlaneNumber);
+
+ virtual void SetDefault(CORBA::Long thePlaneNumber);
+ virtual CORBA::Boolean IsDefault(CORBA::Long thePlaneNumber);
+
+ virtual void SetNbPlanes(CORBA::Long theNb);
+ virtual CORBA::Long GetNbPlanes();
+
+ virtual void SetRotateX(CORBA::Double theAngle);
+ virtual CORBA::Double GetRotateX();
+
+ virtual void SetRotateY(CORBA::Double theAngle);
+ virtual CORBA::Double GetRotateY();
+
+ typedef VISU::CutPlanes TInterface;
+ VISU_CutPlanesPL* GetCutPlanesPL(){ return myCutPlanesPL;}
+
+ protected:
+ virtual void DoHook();
+
+ VISU_CutPlanesPL *myCutPlanesPL;
+
+ public:
+ static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+ virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+
+ virtual void ToStream(std::ostringstream& theStr);
+
+ virtual Storable* Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+
+ static const string myComment;
+ virtual const char* GetComment() const;
+ virtual QString GenerateName();
+ };
+}
+
+
+#endif
+
+
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_DeformedShapePL.hxx"
+#include "VISU_Result_i.hh"
+#include "VISU_DeformedShape_i.hh"
+#include "VISU_ScalarMapAct.h"
+
+using namespace VISU;
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+int VISU::DeformedShape_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ try{
+ if(!VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration)) return 0;
+ const VISU::TField& aField = theResult->GetInput()->GetField(theMeshName,(VISU::TEntity)theEntity,theFieldName);
+ return aField.myNbComp > 1;
+ }catch(std::runtime_error& exc){
+ INFOS("Follow exception was accured :\n"<<exc.what());
+ }catch(...){
+ INFOS("Unknown exception was accured!");
+ }
+ return 0;
+}
+
+int VISU::DeformedShape_i::myNbPresent = 0;
+QString VISU::DeformedShape_i::GenerateName() { return VISU::GenerateName("Def.Shape",myNbPresent++);}
+
+const string VISU::DeformedShape_i::myComment = "DEFORMEDSHAPE";
+const char* VISU::DeformedShape_i::GetComment() const { return myComment.c_str();}
+
+VISU::DeformedShape_i::DeformedShape_i(Result_i* theResult, bool theAddToStudy) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ Prs3d_i(theResult),
+ ScalarMap_i(theResult, theAddToStudy)
+{
+ if(MYDEBUG) MESSAGE("DeformedShape_i::DeformedShape_i");
+ myDeformedShapePL = NULL;
+}
+
+void VISU::DeformedShape_i::Destroy(){
+ ScalarMap_i::Destroy();
+}
+
+void VISU::DeformedShape_i::SameAs(const DeformedShape_i* theOrigin)
+{
+ DeformedShape_i* aDefShape = const_cast<DeformedShape_i*>(theOrigin);
+ VISU::ScalarMap_i::SameAs(theOrigin);
+
+ //SetScale(aDefShape->GetScale());
+ SetColor(aDefShape->GetColor());
+ ShowColored(aDefShape->IsColored());
+}
+
+
+VISU::Storable* VISU::DeformedShape_i::Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ myIsColored = false;
+ myColor.R = myColor.G = myColor.B = 0.5;
+ return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+}
+
+VISU::Storable* VISU::DeformedShape_i::Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ ScalarMap_i::Restore(theMap);
+
+ SetScale(VISU::Storable::FindValue(theMap,"myFactor").toDouble());
+
+ myIsColored = VISU::Storable::FindValue(theMap,"myIsColored").toInt();
+ myColor.R = VISU::Storable::FindValue(theMap,"myColor.R").toDouble();
+ myColor.G = VISU::Storable::FindValue(theMap,"myColor.G").toDouble();
+ myColor.B = VISU::Storable::FindValue(theMap,"myColor.B").toDouble();
+
+ return Build(true);
+}
+
+void VISU::DeformedShape_i::ToStream(std::ostringstream& theStr){
+ ScalarMap_i::ToStream(theStr);
+
+ Storable::DataToStream( theStr, "myFactor", GetScale() );
+
+ Storable::DataToStream( theStr, "myIsColored", myIsColored );
+ Storable::DataToStream( theStr, "myColor.R", myColor.R );
+ Storable::DataToStream( theStr, "myColor.G", myColor.G );
+ Storable::DataToStream( theStr, "myColor.B", myColor.B );
+}
+
+VISU::Storable* VISU::DeformedShape_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ VISU::Result_i* pResult = GetResult(theSObject);
+ if(pResult != NULL){
+ VISU::DeformedShape_i* pResent = new VISU::DeformedShape_i(pResult);
+ return pResent->Restore(theMap);
+ }
+ return NULL;
+}
+
+
+VISU::DeformedShape_i::~DeformedShape_i(){
+ if(MYDEBUG) MESSAGE("DeformedShape_i::~DeformedShape_i()");
+}
+
+
+void VISU::DeformedShape_i::SetScale(CORBA::Double theScale) {
+ myDeformedShapePL->SetScale(theScale);
+}
+CORBA::Double VISU::DeformedShape_i::GetScale(){
+ return myDeformedShapePL->GetScale();
+}
+
+
+void VISU::DeformedShape_i::DoHook(){
+ if(!myPipeLine) myPipeLine = VISU_DeformedShapePL::New();
+ myDeformedShapePL = dynamic_cast<VISU_DeformedShapePL*>(myPipeLine);
+ myPipeLine->GetMapper()->SetScalarVisibility(IsColored());
+
+ ScalarMap_i::DoHook();
+}
+
+
+void VISU::DeformedShape_i::SetMapScale(double theMapScale){
+ myDeformedShapePL->SetMapScale(theMapScale);
+}
+
+
+VISU_Actor* VISU::DeformedShape_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
+ throw (std::runtime_error&)
+{
+ VISU_Actor* anActor = VISU::ScalarMap_i::CreateActor(theIO);
+ anActor->SetRepresentation(1);
+ anActor->GetProperty()->SetColor(myColor.R,myColor.G,myColor.B);
+ return anActor;
+}
+
+
+void VISU::DeformedShape_i::UpdateActor(VISU_Actor* theActor){
+ if(VISU_ScalarMapAct* anActor = dynamic_cast<VISU_ScalarMapAct*>(theActor)){
+ if(IsColored()){
+ anActor->SetBarVisibility(true);
+ myPipeLine->GetMapper()->SetScalarVisibility(1);
+ }else{
+ anActor->SetBarVisibility(false);
+ myPipeLine->GetMapper()->SetScalarVisibility(0);
+ anActor->GetProperty()->SetColor(myColor.R,myColor.G,myColor.B);
+ }
+ VISU::ScalarMap_i::UpdateActor(theActor);
+ }
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_DeformedShape_i_HeaderFile
+#define VISU_DeformedShape_i_HeaderFile
+
+#include "VISU_ScalarMap_i.hh"
+
+class VISU_DeformedShapePL;
+
+namespace VISU{
+ class DeformedShape_i : public virtual POA_VISU::DeformedShape,
+ public virtual ScalarMap_i
+ {
+ static int myNbPresent;
+ DeformedShape_i();
+ DeformedShape_i(const DeformedShape_i&);
+ public:
+ DeformedShape_i(Result_i* theResult, bool theAddToStudy = true);
+ virtual void SameAs(const DeformedShape_i* theOrigin);
+ virtual ~DeformedShape_i();
+ virtual void Destroy();
+
+ virtual VISU::VISUType GetType() { return VISU::TDEFORMEDSHAPE;};
+
+ virtual void SetScale(CORBA::Double theScale);
+ virtual CORBA::Double GetScale();
+
+ virtual CORBA::Boolean IsColored() { return myIsColored; }
+ virtual void ShowColored(CORBA::Boolean theColored) { myIsColored = theColored; }
+
+ virtual SALOMEDS::Color GetColor() { return myColor;}
+ virtual void SetColor(const SALOMEDS::Color& theColor) { myColor = theColor;}
+
+ typedef VISU::DeformedShape TInterface;
+ VISU_DeformedShapePL* GetDeformedShapePL(){ return myDeformedShapePL;}
+
+ protected:
+ virtual void DoHook();
+
+ VISU_DeformedShapePL *myDeformedShapePL;
+ SALOMEDS::Color myColor;
+ bool myIsColored;
+
+ public:
+ static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+ virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+
+ static const string myComment;
+ virtual const char* GetComment() const;
+ virtual QString GenerateName();
+
+ virtual void ToStream(std::ostringstream& theStr);
+
+ virtual Storable* Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+
+ virtual void SetMapScale(double theMapScale = 1.0);
+
+ virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL)
+ throw (std::runtime_error&);
+ virtual void UpdateActor(VISU_Actor* theActor);
+ };
+}
+#endif
+
+
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
-// File : VISU_Gen_i.cc file
-// Author : Alexey Petrov
+// File : VISU_Gen_i.cc
+// Author : Alexey PETROV
// Module : VISU
-// $Header:
-using namespace std;
#include "VISU_Gen_i.hh"
#include "VISU_Result_i.hh"
-#include "VISU_Convertor.hxx"
#include "VISU_PrsObject_i.hh"
#include "VISU_ViewManager_i.hh"
-#include "VISU_TimeAnimation.h"
+
+#include "VISU_Prs3d_i.hh"
+#include "VISU_Mesh_i.hh"
+#include "VISU_ScalarMap_i.hh"
+#include "VISU_IsoSurfaces_i.hh"
+#include "VISU_DeformedShape_i.hh"
+#include "VISU_CutPlanes_i.hh"
+#include "VISU_CutLines_i.hh"
+#include "VISU_Vectors_i.hh"
+#include "VISU_StreamLines_i.hh"
#include "VISU_Table_i.hh"
+#include "VISU_TimeAnimation.h"
#include "HDFascii.hxx"
#include "SALOMEDS_Tool.hxx"
+#include "utilities.h"
+
#include <strstream>
#include <TCollection_AsciiString.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
-#include <vtkUnstructuredGridReader.h>
-#include <vtkUnstructuredGridWriter.h>
#include <omnithread.h>
#include CORBA_SERVER_HEADER(SALOME_Session)
#include <qstring.h>
#include <qfileinfo.h>
+
+using namespace std;
+
static QFileInfo aFileInfo;
-#ifdef DEBUG
+#ifdef _DEBUG_
static int MYDEBUG = 0;
#else
static int MYDEBUG = 0;
#endif
-#include <utilities.h>
-
-//static int IS_LOADED = (cout<<"\n----------------- VisuEngine_factory is loaded -----------------\n", 1);
extern "C" {
PortableServer::ObjectId *
- VisuEngine_factory(CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, PortableServer::ObjectId * contId,
- const char *instanceName, const char *interfaceName)
- {
- if(MYDEBUG) MESSAGE("VisuEngine_factory : "<<interfaceName);
- VISU::VISU_Gen_i * pVISU_Gen = new VISU::VISU_Gen_i(orb, poa, contId, instanceName, interfaceName);
- return pVISU_Gen->getId() ;
- }
- VISU::VISU_Gen_ptr
- GetVisuGen(CORBA::ORB_ptr theORB, PortableServer::POA_ptr thePOA,
- SALOME_NamingService* theNamingService, QMutex* theMutex)
- {
- if(MYDEBUG) MESSAGE("extern \"C\" GetVisuGen");
- VISU::VISU_Gen_i *aVISU_Gen = new VISU::VISU_Gen_i(theORB,thePOA,theNamingService,theMutex);
- return VISU::VISU_Gen::_duplicate(aVISU_Gen->_this());
- //return aVISU_Gen->_this();
- }
-}
-
-namespace VISU{
- //===========================================================================
- //apo - static QMutex VISUMutex;
- QMutex* Base_i::myMutex = NULL; //apo - &VISUMutex;
- CORBA::ORB_var Base_i::myOrb;
- PortableServer::POA_var Base_i::myPOA;
- SALOME_NamingService* Base_i::myNamingService;
- SALOME_LifeCycleCORBA* Base_i::myEnginesLifeCycle;
- VISU_Gen_i* Base_i::myVisuGenImpl;
- VISU_Gen_var Base_i::GetVisuGenInter() { return myVisuGenImpl->_this();}
- Base_i::~Base_i() {}
- char* Base_i::GetID(){
- //CORBA::Object_var anObject = _this();
- //return CORBA::string_dup(myOrb->object_to_string(anObject));
- return CORBA::string_dup(myOrb->object_to_string(_this()));
- }
- //===========================================================================
- static int mySCnt = 0;
- static int myQCnt = 0;
- static int myIsBatchMode = 0;
-
- static int QApp_Counter = 0;
- static int Session_Counter = 0;
- static int COUNTER = 0;
-
- Mutex::Mutex(QMutex* theMutex, QApplication* theQApp, int theDelay) :
- myQApp(theQApp), isQAppLocked(theQApp->locked()), myDelay(theDelay),
- myMutex(theMutex), isSessionLocked(theMutex->locked())
+ VisuEngine_factory(CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, PortableServer::ObjectId * contId,
+ const char *instanceName, const char *interfaceName)
{
- if(MYDEBUG) MESSAGE("Mutex::Mutex : "<<(!isQAppLocked && !myQCnt)<<" "<<(!isSessionLocked && !mySCnt));
- if(!myIsBatchMode && isQAppLocked) myIsBatchMode++;
- if(!isSessionLocked && !mySCnt) { myMutex->lock();}; mySCnt++;
- if(!isQAppLocked && !myQCnt) {
- myQApp->lock();
- myQApp->syncX();
- };
- myQCnt++;
- }
- Mutex::~Mutex(){
- myQCnt--;
- if(!isQAppLocked && !myQCnt) {
- myQApp->flushX();
- //if(myDelay > 0)
- myQApp->processEvents(myDelay+3);
- myQApp->unlock();
- }
- mySCnt--; if(!isSessionLocked && !mySCnt) { myMutex->unlock();}
- if(MYDEBUG) MESSAGE("Mutex::~Mutex : "<<(!isQAppLocked && !myQCnt)<<" "<<(!isSessionLocked && !mySCnt));
+ if(MYDEBUG) MESSAGE("VisuEngine_factory : "<<interfaceName);
+ VISU::VISU_Gen_i * pVISU_Gen = new VISU::VISU_Gen_i(orb, poa, contId, instanceName, interfaceName);
+ return pVISU_Gen->getId() ;
}
- //===========================================================================
- static Storable::TCallbackMap VisuStoreMap;
- string Storable::ToString(){
- ostringstream strOut;
- Storable::DataToStream( strOut, "myComment", GetComment() );
- ToStream(strOut);
- strOut<<ends;
- if(MYDEBUG) MESSAGE("Storable::ToString - "<<strOut.str());
- //apo - auto_ptr<char> aRet(strOut.str());
- return strOut.str();
+ VISU::VISU_Gen_ptr
+ GetVisuGen(CORBA::ORB_ptr theORB, PortableServer::POA_ptr thePOA,
+ SALOME_NamingService* theNamingService, QMutex* theMutex)
+ {
+ if(MYDEBUG) MESSAGE("extern \"C\" GetVisuGen");
+ VISU::VISU_Gen_i *aVISU_Gen = new VISU::VISU_Gen_i(theORB,thePOA,theNamingService,theMutex);
+ return VISU::VISU_Gen::_duplicate(aVISU_Gen->_this());
+ //return aVISU_Gen->_this();
}
+}
- void Storable::Registry(const char* theComment, TStorableEngine theEngine)
- throw(std::logic_error&)
- {
- if(!VisuStoreMap.insert(TCallbackMap::value_type(theComment,theEngine)).second){
- if(MYDEBUG) MESSAGE("Storable::Registry >> dupliacte registring !!!");
- throw std::logic_error("Storable::Registry >> dupliacte registring !!!");
- }
- }
-
- void RegistryStorable() throw(std::logic_error&) {
- //Storable::Registry(View3D_i::myComment.c_str(),&View3DRestore);
- Storable::Registry(Result_i::myComment.c_str(),&ResultRestore);
- Storable::Registry(Mesh_i::myComment.c_str(),&MeshRestore);
- Storable::Registry(ScalarMap_i::myComment.c_str(),&ScalarMapRestore);
- Storable::Registry(DeformedShape_i::myComment.c_str(),&DeformedShapeRestore);
- Storable::Registry(CutPlanes_i::myComment.c_str(),&CutPlanesRestore);
- Storable::Registry(CutLines_i::myComment.c_str(),&CutLinesRestore);
- Storable::Registry(IsoSurfaces_i::myComment.c_str(),&IsoSurfacesRestore);
- Storable::Registry(StreamLines_i::myComment.c_str(),&StreamLinesRestore);
- Storable::Registry(Vectors_i::myComment.c_str(),&VectorsRestore);
- Storable::Registry(Table_i::myComment.c_str(),&TableRestore);
- Storable::Registry(Curve_i::myComment.c_str(),&CurveRestore);
- Storable::Registry(Container_i::myComment.c_str(),&ContainerRestore);
- }
+namespace VISU{
+ static string VisuTmpDir;
- void Storable::StrToMap(const QString& theStr, VISU::Storable::TRestoringMap& theMap){
- if(0 && MYDEBUG) MESSAGE("Storable::StrToMap : string="<<theStr);
- QStringList strList = QStringList::split( ";", theStr, false );
- for ( int i = 0; i < strList.count(); i++ ) {
- QString next = strList[ i ];
- int pos = next.find("=");
- QString aName, aValue;
- if ( pos < 0 ) {
- aName = next.stripWhiteSpace();
- aValue = "";
- }
- else {
- aName = next.left( pos ).stripWhiteSpace();
- aValue = next.mid( pos+1 );
- if ( aValue.isNull() )
- aValue = "";
- }
- if ( !aName.isEmpty() )
- theMap.insert( TRestoringMap::value_type( aName.latin1(), aValue ) );
- }
- }
- void Storable::DataToStream(ostringstream& theStr, const QString& theName, const QString& theVal) {
- QString output = ( !theName.isNull() ? theName : QString("") )
- + QString( "=" )
- + ( !theVal.isNull() ? theVal : QString("") );
- theStr<<output.latin1()<<";";
- }
- void Storable::DataToStream(ostringstream& theStr, const QString& theName, const int theVal) {
- QString output = ( !theName.isNull() ? theName : QString("") )
- + QString( "=" )
- + QString::number( theVal );
- theStr<<output.latin1()<<";";
- }
- void Storable::DataToStream(ostringstream& theStr, const QString& theName, const double theVal) {
- QString output = ( !theName.isNull() ? theName : QString("") )
- + QString( "=" )
- + QString::number( theVal );
- theStr<<output.latin1()<<";";
- }
- Storable* Storable::Create(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const string& theLocalPersistentID)
- throw (std::runtime_error&)
- {
- try{
- QString strIn( theLocalPersistentID.c_str() );
- TRestoringMap aMap;
- StrToMap(strIn,aMap);
- //CORBA::String_var aResultID(GetResultSO(theSObject)->GetID());
- //aMap.insert(TRestoringMap::value_type("ResultID", strdup(aResultID)));
- bool isExist;
- QString aComment = VISU::Storable::FindValue(aMap,"myComment",&isExist);
- if ( isExist ) {
- TCallbackMap::const_iterator i = VisuStoreMap.find(aComment.latin1());
- if(MYDEBUG) MESSAGE("Storable::Create - "<<aComment.latin1()<<" "<<(i != VisuStoreMap.end()));
- if(i == VisuStoreMap.end()) return NULL;
- return (i->second)(theSObject,thePrefix,aMap);
- }
- }catch(std::logic_error& exc){
- MESSAGE("Follow exception was accured :\n"<<exc.what());
- }catch(...){
- MESSAGE("Unknown exception was accured!");
- }
- return NULL;
- }
- const QString& Storable::FindValue(const TRestoringMap& theMap, const string& theArg, bool* isFind)
- throw(std::logic_error&)
- {
- TRestoringMap::const_iterator i = theMap.find(theArg);
- if(i == theMap.end()) {
- if(MYDEBUG) MESSAGE("Storable::Init >> there is no value for "<<theArg);
- if(isFind != NULL) *isFind = false;
- //throw std::logic_error(string("Storable::Init >> there is no value for ") + theArg);
- static QString BAD_VALUE("NULL");
- return BAD_VALUE;
- }
- if(isFind != NULL) *isFind = true;
- return i->second;
- }
+ static CORBA::Boolean myIsMultiFile;
+ const CORBA::Boolean IsMultifile() { return myIsMultiFile;}
- //===========================================================================
- PortableServer::Servant GetServant(CORBA::Object_ptr theObject){
- PortableServer::POA_ptr aPOA = Base_i::GetPOA();
- if(CORBA::is_nil(theObject))
- if(MYDEBUG) MESSAGE("GetServant - CORBA::is_nil(theObject)");
- return aPOA->reference_to_servant(theObject);
- }
- //===========================================================================
- CORBA::Object_var SObjectToObject(SALOMEDS::SObject_ptr theSObject){
- SALOMEDS::GenericAttribute_var anAttr;
- CORBA::Object_var anObj;
- try{
- if(theSObject->FindAttribute(anAttr, "AttributeIOR")){
- SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
- CORBA::String_var aValue = anIOR->Value();
- CORBA::ORB_ptr anORB = Base_i::GetORB();
- if(strcmp(aValue,"") != 0)
- anObj = anORB->string_to_object(aValue);
- }
- }catch(...){
- MESSAGE("SObjectToObject - Unknown exception was accured!");
- }
- return anObj;
- }
//===========================================================================
SALOMEDS::SComponent_var FindOrCreateVisuComponent(SALOMEDS::Study_ptr theStudyDocument){
SALOMEDS::SComponent_var aSComponent = theStudyDocument->FindComponent("VISU");
SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
aPixmap->SetPixMap( "ICON_OBJBROWSER_Visu" );
- VISU_Gen_var aVisuGen = Base_i::GetVisuGenInter();
+ VISU_Gen_var aVisuGen = Base_i::GetVisuGenImpl()->_this();
aStudyBuilder->DefineComponentInstance(aSComponent,aVisuGen);
if (aLocked) theStudyDocument->GetProperties()->SetLocked(true);
aStudyBuilder->CommitCommand();
}
return aSComponent;
}
- //===========================================================================
- string FindEntryWithComment(SALOMEDS::Study_ptr theStudyDocument, const char* theStartEntry,
- const char* theComment, int IsAllLevels)
- {
- if(0 && MYDEBUG) MESSAGE("FindEntryWithComment - '"<<theComment<<"'");
- SALOMEDS::ChildIterator_var anIter =
- theStudyDocument->NewChildIterator(theStudyDocument->FindObjectID(theStartEntry));
- anIter->InitEx(IsAllLevels);
- SALOMEDS::SObject_var aFieldSO;
- for(;anIter->More();anIter->Next()) {
- SALOMEDS::GenericAttribute_var anAttr;
- if (anIter->Value()->FindAttribute(anAttr,"AttributeComment")) {
- SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr);
- CORBA::String_var aString = aCmnt->Value();
- string aValue(aString);
- if (aValue == theComment) {
- aFieldSO = anIter->Value();
- aString = aFieldSO->GetID();
- aValue = aString;
- return aValue;
- }
- }
- }
- return "";
- }
- //===========================================================================
- string CreateAttributes(SALOMEDS::Study_ptr theStudyDocument,
- const char* theFatherEntry, const char* theRefFatherEntry,
- const char* theIOR, const char* theName,
- const char* thePersistentRef, const char* theComment,
- CORBA::Boolean theCreateNew)
- {
- if(0 && MYDEBUG)
- MESSAGE("CreateAttributes - theName = "<<theName<<"; theComment = '"<<theComment<<
- "'; theFatherEntry = "<<theFatherEntry);
- SALOMEDS::StudyBuilder_var aStudyBuilder = theStudyDocument->NewBuilder();
- SALOMEDS::SObject_var aFather = theStudyDocument->FindObjectID(theFatherEntry);
- SALOMEDS::SObject_var newObj;
- if (theCreateNew) newObj = aStudyBuilder->NewObject(aFather);
- else newObj = aFather;
- SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributeIOR");
- SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
- anIOR->SetValue(theIOR);
- anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributeName");
- SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
- aName->SetValue(theName);
- anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributePersistentRef");
- SALOMEDS::AttributePersistentRef_var aPRef = SALOMEDS::AttributePersistentRef::_narrow(anAttr);
- aPRef->SetValue(thePersistentRef);
- anAttr = aStudyBuilder->FindOrCreateAttribute(newObj, "AttributeComment");
- SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr);
- aCmnt->SetValue(theComment);
- if(strcmp(theRefFatherEntry,"") != 0){
- SALOMEDS::SObject_var aRefFather = theStudyDocument->FindObjectID(theRefFatherEntry);
- SALOMEDS::SObject_var anObj = aStudyBuilder->NewObject(aRefFather);
- aStudyBuilder->Addreference(anObj,newObj);
- }
- CORBA::String_var anEntry = newObj->GetID();
- string aRet(anEntry);
- if(0 && MYDEBUG) MESSAGE("CreateAttributes - anEntry = "<<aRet<<"; IOR = "<<theIOR);
- return aRet;
- }
- //===========================================================================
- static SALOMEDS::SComponent_var VisuSComponent;
- static string VisuTmpDir;
- static CORBA::Boolean myIsMultiFile;
- const CORBA::Boolean IsMultifile() {
- return myIsMultiFile;
+
+
+ void RegistryStorable() throw(std::logic_error&) {
+ Storable::Registry(Result_i::myComment.c_str(),&(Result_i::Restore));
+ Storable::Registry(Mesh_i::myComment.c_str(),&(Mesh_i::Restore));
+ Storable::Registry(ScalarMap_i::myComment.c_str(),&(ScalarMap_i::Restore));
+ Storable::Registry(DeformedShape_i::myComment.c_str(),&(DeformedShape_i::Restore));
+ Storable::Registry(CutPlanes_i::myComment.c_str(),&(CutPlanes_i::Restore));
+ Storable::Registry(CutLines_i::myComment.c_str(),&(CutLines_i::Restore));
+ Storable::Registry(IsoSurfaces_i::myComment.c_str(),&(IsoSurfaces_i::Restore));
+ Storable::Registry(StreamLines_i::myComment.c_str(),&(StreamLines_i::Restore));
+ Storable::Registry(Vectors_i::myComment.c_str(),&(Vectors_i::Restore));
+ Storable::Registry(Table_i::myComment.c_str(),&(Table_i::Restore));
+ Storable::Registry(Curve_i::myComment.c_str(),&(Curve_i::Restore));
+ Storable::Registry(Container_i::myComment.c_str(),&(Container_i::Restore));
}
+
+
//===========================================================================
VISU_Gen_i::VISU_Gen_i(CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
//aSession->GetInterface();
Engines::Component_var aComponent = aSession->GetVisuGen();
myVisuGen = VISU::VISU_Gen::_narrow(aComponent);
- }
+ }
VISU_Gen_i::VISU_Gen_i(CORBA::ORB_ptr theORB, PortableServer::POA_ptr thePOA,
SALOME_NamingService* theNamingService, QMutex* theMutex) :
}
//===========================================================================
bool VISU_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent,
- const SALOMEDS::TMPFile & theStream,
- const char* theURL,
- bool isMultiFile)
+ const SALOMEDS::TMPFile & theStream,
+ const char* theURL,
+ bool isMultiFile)
{
if(MYDEBUG) MESSAGE("VISU_Gen_i::Load - myMutex = "<<myMutex);
if(myMutex){
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
TCollection_AsciiString aTmpDir =
isMultiFile?TCollection_AsciiString((char*)theURL):SALOMEDS_Tool::GetTmpDir();
- VisuSComponent = SALOMEDS::SComponent::_duplicate(theComponent);
VisuTmpDir = aTmpDir.ToCString();
SALOMEDS::ListOfFileNames_var aSeq =
SALOMEDS_Tool::PutStreamToFiles(theStream, aTmpDir.ToCString(),isMultiFile);
bool VISU_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent,
const SALOMEDS::TMPFile & theStream,
const char* theURL,
- bool isMultiFile) {
+ bool isMultiFile)
+ {
return Load(theComponent, theStream, theURL, isMultiFile);
}
char* VISU_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
const char* aLocalPersistentID,
CORBA::Boolean isMultiFile,
- CORBA::Boolean isASCII) {
+ CORBA::Boolean isASCII)
+ {
if(myMutex){
CORBA::String_var aString("");
if(strcmp(aLocalPersistentID,"") != 0) {
}
//===========================================================================
SALOMEDS::TMPFile* VISU_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent,
- const char* theURL,
- bool isMultiFile)
+ const char* theURL,
+ bool isMultiFile)
{
if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - myMutex = "<<myMutex);
if(myMutex){
return myVisuGen->IORToLocalPersistentID(theSObject, IORString, isMultiFile, isASCII);
}
- void VISU_Gen_i::SetCurrentStudy(SALOMEDS::Study_ptr theStudy){
- //if(MYDEBUG) MESSAGE("VISU_Gen_i::SetCurrentStudy : "<<(!theStudy->_is_nil()));
+ char* VISU_Gen_i::GetID(){
if(myMutex)
- myStudyDocument = SALOMEDS::Study::_duplicate(theStudy);
- else
- myVisuGen->SetCurrentStudy(theStudy);
+ return Base_i::GetID();
+ return myVisuGen->GetID();
+ }
+
+ void VISU_Gen_i::SetCurrentStudy(SALOMEDS::Study_ptr theStudy){
+ if(myMutex){
+ if(!CORBA::is_nil(theStudy))
+ myStudyDocument = SALOMEDS::Study::_duplicate(theStudy);
+ }else
+ myVisuGen->SetCurrentStudy(SALOMEDS::Study::_duplicate(theStudy));
}
SALOMEDS::Study_ptr VISU_Gen_i::GetCurrentStudy(){
- if(MYDEBUG) MESSAGE("VISU_Gen_i::GetCurrentStudy : "<<myMutex);
if(myMutex)
return SALOMEDS::Study::_duplicate(myStudyDocument);
return myVisuGen->GetCurrentStudy();
if(myMutex){
if(myStudyDocument->GetProperties()->IsLocked()) return Result::_nil();
Mutex mt(myMutex,qApp);
+ VISU::Result_var aResult;
aFileInfo.setFile(theFileName);
Result_i* pResult = new Result_i(myStudyDocument);
if(pResult->Create(theFileName) != NULL)
- return Result::_duplicate(pResult->_this());
- return Result::_nil();
+ aResult = pResult->_this();
+ return aResult._retn();
}
return myVisuGen->ImportFile(theFileName);
}
}
ScalarMap_ptr VISU_Gen_i::ScalarMapOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, CORBA::Double theIteration){
- if(MYDEBUG) MESSAGE("VISU_Gen_i::ScalarMapOnField : "<<myMutex);
- if(myMutex){
- if(myStudyDocument->GetProperties()->IsLocked()) return ScalarMap::_nil();
- Mutex mt(myMutex,qApp);
- Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult));
- if(ScalarMap_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){
- ScalarMap_i* aPresent = new ScalarMap_i(pResult);
- if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL){
- //Base_i::myPOA->activate_object(aPresent);
- //aPresent->_remove_ref();
- return aPresent->_this();
- }
- }
- return ScalarMap::_nil();
- }
+ const char* theFieldName, CORBA::Double theIteration)
+ {
+ if(myMutex) return Prs3dOnField<VISU::ScalarMap_i>(theResult,theMeshName,theEntity,theFieldName,theIteration);
return myVisuGen->ScalarMapOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
}
DeformedShape_ptr VISU_Gen_i::DeformedShapeOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, CORBA::Double theIteration){
- if(MYDEBUG) MESSAGE("VISU_Gen_i::DeformedShapeOnField : "<<myMutex);
- if(myMutex){
- if(myStudyDocument->GetProperties()->IsLocked()) return DeformedShape::_nil();
- Mutex mt(myMutex,qApp);
- Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult));
- if(DeformedShape_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){
- DeformedShape_i* aPresent = new DeformedShape_i(pResult);
- if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL)
- return DeformedShape::_duplicate(aPresent->_this());
- }
- return DeformedShape::_nil();
- }
+ const char* theFieldName, CORBA::Double theIteration)
+ {
+ if(myMutex) return Prs3dOnField<VISU::DeformedShape_i>(theResult,theMeshName,theEntity,theFieldName,theIteration);
return myVisuGen->DeformedShapeOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
}
Vectors_ptr VISU_Gen_i::VectorsOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, CORBA::Double theIteration){
- if(MYDEBUG) MESSAGE("VISU_Gen_i::VectorsOnField : "<<myMutex);
- if(myMutex){
- if(myStudyDocument->GetProperties()->IsLocked()) return Vectors::_nil();
- Mutex mt(myMutex,qApp);
- Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult));
- if(Vectors_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){
- Vectors_i* aPresent = new Vectors_i(pResult);
- if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL)
- return Vectors::_duplicate(aPresent->_this());
- }
- return Vectors::_nil();
- }
+ const char* theFieldName, CORBA::Double theIteration)
+ {
+ if(myMutex) return Prs3dOnField<VISU::Vectors_i>(theResult,theMeshName,theEntity,theFieldName,theIteration);
return myVisuGen->VectorsOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
}
IsoSurfaces_ptr VISU_Gen_i::IsoSurfacesOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, CORBA::Double theIteration){
- if(MYDEBUG) MESSAGE("VISU_Gen_i::IsoSurfacesOnField : "<<myMutex);
- if(myMutex){
- if(myStudyDocument->GetProperties()->IsLocked()) return IsoSurfaces::_nil();
- Mutex mt(myMutex,qApp);
- Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult));
- if(IsoSurfaces_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){
- IsoSurfaces_i* aPresent = new IsoSurfaces_i(pResult);
- if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL)
- return IsoSurfaces::_duplicate(aPresent->_this());
- }
- return IsoSurfaces::_nil();
- }
+ const char* theFieldName, CORBA::Double theIteration)
+ {
+ if(myMutex) return Prs3dOnField<VISU::IsoSurfaces_i>(theResult,theMeshName,theEntity,theFieldName,theIteration);
return myVisuGen->IsoSurfacesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
}
StreamLines_ptr VISU_Gen_i::StreamLinesOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, CORBA::Double theIteration){
- if(MYDEBUG) MESSAGE("VISU_Gen_i::StreamLinesOnField : "<<myMutex);
- if(myMutex){
- if(myStudyDocument->GetProperties()->IsLocked()) return StreamLines::_nil();
- Mutex mt(myMutex,qApp);
- Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult));
- if(StreamLines_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){
- StreamLines_i* aPresent = new StreamLines_i(pResult);
- if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL)
- return StreamLines::_duplicate(aPresent->_this());
- }
- return StreamLines::_nil();
- }
+ const char* theFieldName, CORBA::Double theIteration)
+ {
+ if(myMutex) return Prs3dOnField<VISU::StreamLines_i>(theResult,theMeshName,theEntity,theFieldName,theIteration);
return myVisuGen->StreamLinesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
}
CutPlanes_ptr VISU_Gen_i::CutPlanesOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, CORBA::Double theIteration){
- if(MYDEBUG) MESSAGE("VISU_Gen_i::CutPlanesOnField : "<<myMutex);
- if(myMutex){
- if(myStudyDocument->GetProperties()->IsLocked()) return CutPlanes::_nil();
- Mutex mt(myMutex,qApp);
- Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult));
- if(CutPlanes_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){
- CutPlanes_i* aPresent = new CutPlanes_i(pResult);
- if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL)
- return CutPlanes::_duplicate(aPresent->_this());
- }
- return CutPlanes::_nil();
- }
+ const char* theFieldName, CORBA::Double theIteration)
+ {
+ if(myMutex) return Prs3dOnField<VISU::CutPlanes_i>(theResult,theMeshName,theEntity,theFieldName,theIteration);
return myVisuGen->CutPlanesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
}
CutLines_ptr VISU_Gen_i::CutLinesOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, CORBA::Double theIteration){
- if(MYDEBUG) MESSAGE("VISU_Gen_i::CutLinesOnField : "<<myMutex);
- if(myMutex){
- if(myStudyDocument->GetProperties()->IsLocked()) return CutLines::_nil();
- Mutex mt(myMutex,qApp);
- Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult));
- if(CutLines_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,theIteration)){
- CutLines_i* aPresent = new CutLines_i(pResult);
- if(aPresent->Create(theMeshName,theEntity,theFieldName,theIteration) != NULL)
- return CutLines::_duplicate(aPresent->_this());
- }
- return CutLines::_nil();
- }
+ const char* theFieldName, CORBA::Double theIteration)
+ {
+ if(myMutex) return Prs3dOnField<VISU::CutLines_i>(theResult,theMeshName,theEntity,theFieldName,theIteration);
return myVisuGen->CutLinesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
}
}
}
} catch (...) {
- MESSAGE("Unknown exception was accured!");
+ INFOS("Unknown exception was accured!");
}
return false;
}
// Assign an ID = 1 the the type VISU::Result
theObjectID = 1;
+
+
+ SALOMEDS::SComponent_var aSComponent = theObject->GetStudy()->FindComponent("VISU");
return aStreamFile._retn();
}
return myVisuGen->CopyFrom(theObject, theObjectID);
Mutex mt(myMutex,qApp);
SALOMEDS::SObject_var aResultSO;
if (theObjectID != 1) return aResultSO._retn();
-
+
CORBA::String_var aTmpDir = (const char*)SALOMEDS_Tool::GetTmpDir();
SALOMEDS::ListOfFileNames_var aSeq = SALOMEDS_Tool::PutStreamToFiles(theStream, aTmpDir, false);
stmIn.read(aString, aLength);
aString[aLength] = 0;
myIsMultiFile = true;
-
+
string aFileName(aTmpDir.in());
if(aSeq->length() > 1) aFileName += aSeq[1].in();
- Storable* aStorable = Storable::Create(theObject,aFileName,aString);
-
- SALOMEDS::ListOfFileNames_var aSeqToRm = new SALOMEDS::ListOfFileNames;
- aSeqToRm->length(1);
- aSeqToRm[0] = "copy_persistent";
- SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir, aSeqToRm.in(), true);
SALOMEDS::SComponent_var aComponent = theObject->GetFatherComponent();
SALOMEDS::Study_var aStudy = theObject->GetStudy();
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
CORBA::String_var aComponentID(aComponent->GetID()), aSObjID(theObject->GetID());
+
if (strcmp(aComponentID, aSObjID) == 0) //create the new result SObject
aResultSO = aStudyBuilder->NewObject(aComponent);
else
aResultSO = SALOMEDS::SObject::_duplicate(theObject);
- SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributeIOR");
+
+ //Just for Result::Restore to find the Comment attribute :(
+ SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributeComment");
+
+ Storable* aStorable = Storable::Create(aResultSO,aFileName,aString);
+
+ SALOMEDS::ListOfFileNames_var aSeqToRm = new SALOMEDS::ListOfFileNames;
+ aSeqToRm->length(1);
+ aSeqToRm[0] = "copy_persistent";
+ SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir, aSeqToRm.in(), true);
+
+ anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributeIOR");
SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
CORBA::String_var anIORValue(aStorable->GetID());
anIOR->SetValue(anIORValue);
#include "SALOME_NamingService.hxx"
namespace VISU{
+ class Result_i;
class VISU_Gen_i : public virtual POA_VISU::VISU_Gen,
public virtual ::Engines_Component_i,
public virtual Base_i
const char *instanceName,
const char *interfaceName);
virtual ~VISU_Gen_i();
+
+ virtual char* GetID();
virtual VISU::VISUType GetType() { return VISU::TVISUGEN;};
virtual void SetCurrentStudy(SALOMEDS::Study_ptr theStudy);
virtual SALOMEDS::Study_ptr GetCurrentStudy();
+
virtual ViewManager_ptr GetViewManager();
virtual SALOMEDS::SObject_ptr ImportTables(const char* theFileName);
virtual Mesh_ptr GroupMesh(Result_ptr theResult, const char* theMeshName, const char* theGroupName);
//Create 3D collored Presentation Of Different Types
+ template<typename TPrs3d_i> typename TPrs3d_i::TInterface::_ptr_type
+ Prs3dOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, CORBA::Double theIteration)
+ {
+ typedef typename TPrs3d_i::TInterface TPrs3d;
+ if(myStudyDocument->GetProperties()->IsLocked()) return TPrs3d::_nil();
+ Mutex mt(myMutex,qApp);
+ Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult));
+ if(TPrs3d_i::IsPossible(pResult,theMeshName,theEntity,theFieldName,int(theIteration))){
+ TPrs3d_i* aPresent = new TPrs3d_i(pResult);
+ if(aPresent->Create(theMeshName,theEntity,theFieldName,int(theIteration)) != NULL){
+ return aPresent->_this();
+ }
+ }
+ return TPrs3d::_nil();
+ }
+
virtual ScalarMap_ptr ScalarMapOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity,
const char* theFieldName, CORBA::Double theIteration);
virtual DeformedShape_ptr DeformedShapeOnField(Result_ptr theResult, const char* theMeshName, VISU::Entity theEntity,
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_IsoSurfacesPL.hxx"
+#include "VISU_Result_i.hh"
+#include "VISU_IsoSurfaces_i.hh"
+#include "VISU_Actor.h"
+
+using namespace VISU;
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+int VISU::IsoSurfaces_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration);
+}
+
+int VISU::IsoSurfaces_i::myNbPresent = 0;
+QString VISU::IsoSurfaces_i::GenerateName() { return VISU::GenerateName("IsoSurfaces",myNbPresent++);}
+
+const string VISU::IsoSurfaces_i::myComment = "ISOSURFACES";
+const char* VISU::IsoSurfaces_i::GetComment() const { return myComment.c_str();}
+
+VISU::IsoSurfaces_i::IsoSurfaces_i(Result_i* theResult, bool theAddToStudy) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ Prs3d_i(theResult),
+ ScalarMap_i(theResult, theAddToStudy)
+{
+ myIsoSurfacesPL = NULL;
+}
+
+void VISU::IsoSurfaces_i::Destroy(){
+ ScalarMap_i::Destroy();
+}
+
+void VISU::IsoSurfaces_i::SameAs(const IsoSurfaces_i* theOrigin) {
+ IsoSurfaces_i* aIsoSurfaces = const_cast<IsoSurfaces_i*>(theOrigin);
+ VISU::ScalarMap_i::SameAs(theOrigin);
+
+ //SetNbSurfaces(aIsoSurfaces->GetNbSurfaces());
+ //SetSubRange(aIsoSurfaces->GetSubMin(),aIsoSurfaces->GetSubMax());
+}
+
+VISU::Storable* VISU::IsoSurfaces_i::Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+}
+
+VISU::Storable* VISU::IsoSurfaces_i::Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ ScalarMap_i::Restore(theMap);
+
+ SetNbSurfaces(VISU::Storable::FindValue(theMap,"myNbSurface").toInt());
+ float aMin = VISU::Storable::FindValue(theMap,"myRange[0]").toDouble();
+ float aMax = VISU::Storable::FindValue(theMap,"myRange[1]").toDouble();
+ SetSubRange(aMin,aMax);
+
+ return Build(true);
+}
+
+void VISU::IsoSurfaces_i::ToStream(std::ostringstream& theStr){
+ ScalarMap_i::ToStream(theStr);
+
+ Storable::DataToStream( theStr, "myNbSurface", int(GetNbSurfaces()) );
+ Storable::DataToStream( theStr, "myRange[0]", GetSubMin() );
+ Storable::DataToStream( theStr, "myRange[1]", GetSubMax() );
+}
+
+VISU::Storable* VISU::IsoSurfaces_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ VISU::Result_i* pResult = GetResult(theSObject);
+ if(pResult != NULL){
+ VISU::IsoSurfaces_i* pResent = new VISU::IsoSurfaces_i(pResult);
+ return pResent->Restore(theMap);
+ }
+ return NULL;
+}
+
+
+VISU::IsoSurfaces_i::~IsoSurfaces_i(){
+ if(MYDEBUG) MESSAGE("IsoSurfaces_i::~IsoSurfaces_i()");
+}
+
+
+void VISU::IsoSurfaces_i::SetNbSurfaces(CORBA::Long theNb){
+ myIsoSurfacesPL->SetNbParts(theNb);
+}
+CORBA::Long VISU::IsoSurfaces_i::GetNbSurfaces(){
+ return myIsoSurfacesPL->GetNbParts();
+}
+
+
+void VISU::IsoSurfaces_i::SetSubRange(CORBA::Double theMin, CORBA::Double theMax){
+ float aRange[2] = {theMin, theMax};
+ myIsoSurfacesPL->SetRange(aRange);
+}
+CORBA::Double VISU::IsoSurfaces_i::GetSubMin(){
+ return myIsoSurfacesPL->GetMin();
+}
+CORBA::Double VISU::IsoSurfaces_i::GetSubMax(){
+ return myIsoSurfacesPL->GetMax();
+}
+
+
+void VISU::IsoSurfaces_i::DoHook(){
+ if(MYDEBUG) MESSAGE("IsoSurfaces_i::DoHook()- "<<myPipeLine);
+ if(!myPipeLine) myPipeLine = VISU_IsoSurfacesPL::New();
+ myIsoSurfacesPL = dynamic_cast<VISU_IsoSurfacesPL*>(myPipeLine);
+
+ ScalarMap_i::DoHook();
+}
+
+
+void VISU::IsoSurfaces_i::SetMapScale(double theMapScale){
+ myIsoSurfacesPL->SetMapScale(theMapScale);
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_IsoSurfaces_i_HeaderFile
+#define VISU_IsoSurfaces_i_HeaderFile
+
+#include "VISU_ScalarMap_i.hh"
+
+class VISU_IsoSurfacesPL;
+
+namespace VISU{
+ class IsoSurfaces_i : public virtual POA_VISU::IsoSurfaces,
+ public virtual ScalarMap_i
+ {
+ static int myNbPresent;
+ IsoSurfaces_i();
+ IsoSurfaces_i(const IsoSurfaces_i&);
+ public:
+ IsoSurfaces_i(Result_i* theResult, bool theAddToStudy = true);
+ virtual void SameAs(const IsoSurfaces_i* theOrigin);
+ virtual ~IsoSurfaces_i();
+ virtual void Destroy();
+
+ virtual VISU::VISUType GetType() { return VISU::TISOSURFACE;};
+
+ virtual void SetNbSurfaces(CORBA::Long theNb);
+ virtual CORBA::Long GetNbSurfaces();
+
+ virtual void SetSubRange(CORBA::Double theMin, CORBA::Double theMax);
+ virtual CORBA::Double GetSubMin();
+ virtual CORBA::Double GetSubMax();
+
+ typedef VISU::IsoSurfaces TInterface;
+ VISU_IsoSurfacesPL* GetIsoSurfacesPL(){ return myIsoSurfacesPL;}
+
+ protected:
+ virtual void DoHook();
+ VISU_IsoSurfacesPL* myIsoSurfacesPL;
+
+ public:
+ static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+ virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+
+ static const string myComment;
+ virtual const char* GetComment() const;
+ virtual QString GenerateName();
+
+ virtual void ToStream(std::ostringstream& theStr);
+
+ virtual Storable* Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+
+ virtual void SetMapScale(double theMapScale = 1.0);
+ };
+}
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_MeshPL.hxx"
+#include "VISU_Result_i.hh"
+#include "VISU_Mesh_i.hh"
+#include "VISU_MeshAct.h"
+
+using namespace VISU;
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+static int INCMEMORY = 4;
+
+int VISU::Mesh_i::myNbPresent = 0;
+
+QString VISU::Mesh_i::GenerateName() { return VISU::GenerateName("Mesh",myNbPresent++);}
+
+const string VISU::Mesh_i::myComment = "MESH";
+
+const char* VISU::Mesh_i::GetComment() const { return myComment.c_str();}
+
+VISU::Mesh_i::Mesh_i(Result_i* theResult) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ Prs3d_i(theResult)
+{
+ myPipeLine = myMeshPL = VISU_MeshPL::New();;
+}
+
+void VISU::Mesh_i::SameAs(const Mesh_i* theOrigin){
+ return; // "SameAs" command for mesh is not valid in current architecture
+}
+
+void VISU::Mesh_i::Destroy(){
+ SALOMEDS::SObject_var aSObj = myStudy->FindObjectID(GetEntry());
+ if(!aSObj->_is_nil()){
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ aStudyBuilder->RemoveAttribute(aSObj,"AttributeIOR");
+ }
+ Prs3d_i::Destroy();
+}
+
+int VISU::Mesh_i::IsPossible(Result_i* theResult, const char* theMeshName, Entity theEntity, const char* theFamilyName){
+ try{
+ vtkIdType aSize = INCMEMORY*
+ theResult->GetInput()->GetMeshOnEntitySize(theMeshName,(VISU::TEntity)theEntity,theFamilyName);
+ if(MYDEBUG) MESSAGE("Mesh_i::IsPossible - CheckAvailableMemory = "<<aSize);
+ if(VISU_PipeLine::CheckAvailableMemory(aSize)) return true;
+ return false;
+ }catch(std::runtime_error& exc){
+ INFOS("Follow exception was accured :\n"<<exc.what());
+ }catch(...){
+ INFOS("Unknown exception was accured!");
+ }
+ return 0;
+}
+
+VISU::Storable* VISU::Mesh_i::Create(const char* theMeshName, Entity theEntity, const char* theFamilyName){
+ myMeshName = theMeshName;
+ myEntity = VISU::TEntity(theEntity);
+ mySubMeshName = theFamilyName;
+ return Build(false);
+}
+
+
+int VISU::Mesh_i::IsPossible(Result_i* theResult, const char* theMeshName, const char* theGroupName){
+ try{
+ vtkIdType aSize = INCMEMORY*
+ theResult->GetInput()->GetMeshOnGroupSize(theMeshName,theGroupName);
+ if(MYDEBUG) MESSAGE("Mesh_i::IsPossible - CheckAvailableMemory = "<<aSize);
+ if(VISU_PipeLine::CheckAvailableMemory(aSize)) return true;
+ return false;
+ }catch(std::runtime_error& exc){
+ INFOS("Follow exception was accured :\n"<<exc.what());
+ }catch(...){
+ INFOS("Unknown exception was accured!");
+ }
+ return 0;
+}
+VISU::Storable* VISU::Mesh_i::Create(const char* theMeshName, const char* theGroupName){
+ myMeshName = theMeshName;
+ myEntity = VISU::TEntity(-1);
+ mySubMeshName = theGroupName;
+ return Build(false);
+}
+
+VISU::Storable* VISU::Mesh_i::Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ Prs3d_i::Restore(theMap);
+
+ myMeshName = VISU::Storable::FindValue(theMap,"myMeshName").latin1();
+ myEntity = (VISU::TEntity)VISU::Storable::FindValue(theMap,"myEntity").toInt();
+ mySubMeshName = VISU::Storable::FindValue(theMap,"mySubMeshName").latin1();
+
+ myPresentType = VISU::PresentationType(VISU::Storable::FindValue(theMap,"myPresentType").toInt());
+
+ myCellColor.R = VISU::Storable::FindValue(theMap,"myCellColor.R").toDouble();
+ myCellColor.G = VISU::Storable::FindValue(theMap,"myCellColor.G").toDouble();
+ myCellColor.B = VISU::Storable::FindValue(theMap,"myCellColor.B").toDouble();
+
+ myNodeColor.R = VISU::Storable::FindValue(theMap,"myNodeColor.R").toDouble();
+ myNodeColor.G = VISU::Storable::FindValue(theMap,"myNodeColor.G").toDouble();
+ myNodeColor.B = VISU::Storable::FindValue(theMap,"myNodeColor.B").toDouble();
+
+ myLinkColor.R = VISU::Storable::FindValue(theMap,"myLinkColor.R").toDouble();
+ myLinkColor.G = VISU::Storable::FindValue(theMap,"myLinkColor.G").toDouble();
+ myLinkColor.B = VISU::Storable::FindValue(theMap,"myLinkColor.B").toDouble();
+
+ return Build(true);
+}
+
+void VISU::Mesh_i::ToStream(std::ostringstream& theStr){
+ Prs3d_i::ToStream(theStr);
+
+ Storable::DataToStream( theStr, "myMeshName", myMeshName.c_str() );
+ Storable::DataToStream( theStr, "myEntity", myEntity );
+ Storable::DataToStream( theStr, "mySubMeshName", mySubMeshName.c_str() );
+
+ Storable::DataToStream( theStr, "myPresentType", int(myPresentType) );
+
+ Storable::DataToStream( theStr, "myCellColor.R", myCellColor.R );
+ Storable::DataToStream( theStr, "myCellColor.G", myCellColor.G );
+ Storable::DataToStream( theStr, "myCellColor.B", myCellColor.B );
+
+ Storable::DataToStream( theStr, "myNodeColor.R", myNodeColor.R );
+ Storable::DataToStream( theStr, "myNodeColor.G", myNodeColor.G );
+ Storable::DataToStream( theStr, "myNodeColor.B", myNodeColor.B );
+
+ Storable::DataToStream( theStr, "myLinkColor.R", myLinkColor.R );
+ Storable::DataToStream( theStr, "myLinkColor.G", myLinkColor.G );
+ Storable::DataToStream( theStr, "myLinkColor.B", myLinkColor.B );
+}
+
+VISU::Storable* VISU::Mesh_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ VISU::Result_i* pResult = GetResult(theSObject);
+ if(pResult != NULL){
+ VISU::Mesh_i* pResent = new VISU::Mesh_i(pResult);
+ return pResent->Restore(theMap);
+ }
+ return NULL;
+}
+
+
+VISU::Mesh_i::~Mesh_i(){
+ if(MYDEBUG) MESSAGE("Mesh_i::~Mesh_i()");
+}
+
+
+VISU::Storable* VISU::Mesh_i::Build(int theRestoring){
+ try{
+ if(myResult->GetInput() == NULL)
+ throw std::runtime_error("Mesh_i::Build - myResult->GetInput() == NULL !!!");
+ if(!theRestoring){
+ myPresentType = VISU::SHADED;
+ myName = GenerateName().latin1();
+ myCellColor.R = 0.0; myCellColor.G = myCellColor.B = 1.0;
+ myNodeColor.R = myNodeColor.G = 1.0; myNodeColor.B = 1.0;
+ myLinkColor.R = myLinkColor.G = myLinkColor.B = 83/255.;
+ }
+ if(int(myEntity) >= 0)
+ if(mySubMeshName == "")
+ myType = VISU::TENTITY;
+ else
+ myType = VISU::TFAMILY;
+ else
+ myType = VISU::TGROUP;
+ if(MYDEBUG) MESSAGE("Mesh_i::Build - myType = "<<myType);
+ QString aComment;
+
+ VISU_Convertor::TOutput *anOutput;
+ switch(myType){
+ case VISU::TENTITY :
+ anOutput = myResult->GetInput()->GetMeshOnEntity(myMeshName,myEntity);
+ aComment.sprintf("myComment=ENTITY;myType=%d;myMeshName=%s;myId=%d",
+ VISU::TENTITY,myMeshName.c_str(),myEntity);
+ break;
+ case VISU::TFAMILY :
+ anOutput = myResult->GetInput()->GetMeshOnEntity(myMeshName,myEntity,mySubMeshName);
+ aComment.sprintf("myComment=FAMILY;myType=%d;myMeshName=%s;myEntityId=%d;myName=%s",
+ VISU::TFAMILY,myMeshName.c_str(),myEntity,mySubMeshName.c_str());
+ break;
+ case VISU::TGROUP :
+ anOutput = myResult->GetInput()->GetMeshOnGroup(myMeshName,mySubMeshName);
+ aComment.sprintf("myComment=GROUP;myType=%d;myMeshName=%s;myName=%s",
+ VISU::TGROUP,myMeshName.c_str(),mySubMeshName.c_str());
+ break;
+ }
+ if(anOutput == NULL) throw std::runtime_error("Mesh_i::Build - anOutput == NULL !!!");
+ myMeshPL->SetInput(anOutput);
+ myMeshPL->Build();
+ if(!theRestoring) { //Setting IOR on the label
+ myMeshPL->Init();
+ string aResultEntry = myResult->GetEntry();
+ string anEntry = FindEntryWithComment(myStudy,aResultEntry.c_str(),aComment.latin1());
+ if(anEntry == "") throw std::runtime_error("Mesh_i::Build - anEntry was not found !!!");
+ SALOMEDS::SObject_var aSObj = myStudy->FindObjectID(anEntry.c_str());
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aSObj,"AttributeIOR");
+ SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+ CORBA::String_var aString = GetID();
+ anIOR->SetValue(aString);
+ }
+ return this;
+ }catch(std::runtime_error& exc){
+ INFOS("Follow exception was accured :\n"<<exc.what());
+ }catch(...){
+ INFOS("Unknown exception was accured!");
+ }
+ return NULL;
+}
+
+
+VISU_Actor* VISU::Mesh_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
+ throw (std::runtime_error&)
+{
+ VISU_MeshAct* anActor = VISU_MeshAct::New();
+ try{
+ VISU::Prs3d_i::CreateActor(anActor,theIO);
+ UpdateActor(anActor);
+ }catch(std::runtime_error& exc){
+ anActor->Delete();
+ throw exc;
+ }
+ return anActor;
+}
+
+void VISU::Mesh_i::UpdateActor(VISU_Actor* theActor){
+ if(VISU_MeshAct* anActor = dynamic_cast<VISU_MeshAct*>(theActor)){
+ if(MYDEBUG) MESSAGE("Mesh_i::UpdateActor");
+ VISU::Prs3d_i::UpdateActor(anActor);
+ anActor->SetRepresentation(myPresentType);
+ anActor->GetProperty()->SetColor(myCellColor.R, myCellColor.G, myCellColor.B);
+ anActor->GetEdgeProperty()->SetColor(myLinkColor.R, myLinkColor.G, myLinkColor.B);
+ anActor->GetNodeProperty()->SetColor(myNodeColor.R, myNodeColor.G, myNodeColor.B);
+ }
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_Mesh_i_HeaderFile
+#define VISU_Mesh_i_HeaderFile
+
+#include "VISU_Prs3d_i.hh"
+
+class VISU_MeshPL;
+
+namespace VISU{
+ class Mesh_i : public virtual POA_VISU::Mesh,
+ public virtual Prs3d_i
+ {
+ static int myNbPresent;
+ Mesh_i();
+ Mesh_i(const Mesh_i&);
+ public:
+ Mesh_i(Result_i* theResult);
+ virtual void SameAs(const Mesh_i* theOrigin);
+ virtual ~Mesh_i();
+ virtual void Destroy();
+
+ virtual VISU::VISUType GetType() { return VISU::TMESH;};
+
+ virtual void SetCellColor(const SALOMEDS::Color& theColor) { myCellColor = theColor;}
+ virtual SALOMEDS::Color GetCellColor() { return myCellColor;}
+
+ virtual void SetNodeColor(const SALOMEDS::Color& theColor) { myNodeColor = theColor;}
+ virtual SALOMEDS::Color GetNodeColor() { return myNodeColor;}
+
+ virtual void SetLinkColor(const SALOMEDS::Color& theColor) { myLinkColor = theColor;}
+ virtual SALOMEDS::Color GetLinkColor() { return myLinkColor;}
+
+ virtual void SetPresentationType(VISU::PresentationType theType) { myPresentType = theType;}
+ virtual PresentationType GetPresentationType() { return myPresentType;}
+
+ typedef VISU::Mesh TInterface;
+ VISU_MeshPL* GetMeshPL(){ return myMeshPL;}
+
+ protected:
+ Storable* Build(int theRestoring);
+
+ VISU_MeshPL* myMeshPL;
+
+ string myMeshName;
+ TEntity myEntity;
+ string mySubMeshName;
+ VISU::VISUType myType;
+
+ VISU::PresentationType myPresentType;
+ struct SALOMEDS::Color myCellColor, myNodeColor, myLinkColor;
+
+ public:
+ static int IsPossible(Result_i* theResult, const char* theMeshName, Entity theEntity, const char* theFamilyName = "");
+ virtual Storable* Create(const char* theMeshName, Entity theEntity, const char* theFamilyName = "");
+
+ static int IsPossible(Result_i* theResult, const char* theMeshName, const char* theGroupName);
+ virtual Storable* Create(const char* theMeshName, const char* theGroupName);
+
+ virtual void ToStream(std::ostringstream& theStr);
+
+ virtual const char* GetComment() const;
+ static const string myComment;
+ virtual QString GenerateName();
+
+ virtual Storable* Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+
+ virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL)
+ throw (std::runtime_error&);
+ virtual void UpdateActor(VISU_Actor* theActor);
+ };
+}
+
+#endif
+
+
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Prs3d_i.cc
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_PipeLine.hxx"
+#include "VISU_Result_i.hh"
+#include "VISU_Prs3d_i.hh"
+#include "VISU_Actor.h"
+using namespace VISU;
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+VISU::Prs3d_i::Prs3d_i(Result_i* theResult) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ myResult(theResult)
+{
+ myAddToStudy = true;
+ myPipeLine = NULL;
+}
+
+void VISU::Prs3d_i::SameAs(const Prs3d_i* theOrigin)
+{
+ Prs3d_i* aOrigin = const_cast<Prs3d_i*>(theOrigin);
+ myPipeLine->ShallowCopy(aOrigin->GetPL());
+}
+
+VISU::Prs3d_i::~Prs3d_i() {
+ if(MYDEBUG) MESSAGE("Prs3d_i::~Prs3d_i()");
+ myPipeLine->Delete();
+}
+
+void VISU::Prs3d_i::Destroy() {
+ CORBA::Object_var anObj = _this();
+ PortableServer::POA_ptr aPOA = Base_i::GetPOA();
+ PortableServer::ObjectId_var anId = aPOA->reference_to_id(anObj);
+ aPOA->deactivate_object(anId.in());
+ this->_remove_ref();
+}
+
+
+void VISU::Prs3d_i::CreateActor(VISU_Actor* theActor, const Handle(SALOME_InteractiveObject)& theIO)
+ throw (std::runtime_error&)
+{
+ try{
+ Update();
+ if(myAddToStudy){
+ Handle(SALOME_InteractiveObject) anIO = theIO;
+ if (anIO.IsNull())
+ anIO = new SALOME_InteractiveObject(strdup(GetEntry()),"VISU",strdup(GetName()));
+ theActor->setIO(anIO);
+ }
+ theActor->SetPipeLine(GetPipeLine());
+ theActor->SetPrs3d(this);
+ }catch(std::runtime_error& ex){
+ throw ex;
+ }catch(...){
+ throw std::runtime_error("Prs3d_i::CreateActor >> unexpected exception was caught!!!");
+ }
+}
+
+void VISU::Prs3d_i::UpdateActor(VISU_Actor* theActor){
+ theActor->GetMapper()->ShallowCopy(myPipeLine->GetMapper());
+ theActor->Modified();
+}
+
+VISU::Storable* VISU::Prs3d_i::Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ myName = VISU::Storable::FindValue(theMap,"myName").latin1();
+ return this;
+}
+
+void VISU::Prs3d_i::ToStream(std::ostringstream& theStr){
+ Storable::DataToStream( theStr, "myName", myName.c_str() );
+}
+
+void VISU::Prs3d_i::Update(){
+ myPipeLine->Update();
+}
+
+VISU_PipeLine* VISU::Prs3d_i::GetPipeLine(){
+ return GetPL();
+}
+
+VISU_PipeLine* VISU::Prs3d_i::GetPL(){
+ return myPipeLine;
+}
+
+VISU::Result_i* VISU::Prs3d_i::GetResult(SALOMEDS::SObject_ptr theSObject){
+ VISU::Result_var aResult = FindResult(theSObject);
+ if(!aResult->_is_nil())
+ return dynamic_cast<VISU::Result_i*>(VISU::GetServant(aResult.in()));
+ return NULL;
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_Prs3d_i_HeaderFile
+#define VISU_Prs3d_i_HeaderFile
+
+#include "VISU_PrsObject_i.hh"
+#include "Handle_SALOME_InteractiveObject.hxx"
+#include "VISU_Convertor.hxx"
+
+class VISU_PipeLine;
+class VISU_Actor;
+
+namespace VISU{
+ class Result_i;
+ class Prs3d_i : public virtual POA_VISU::Prs3d,
+ public virtual PrsObject_i
+ {
+ Prs3d_i();
+ Prs3d_i(const Prs3d_i&);
+ public:
+ Prs3d_i(Result_i* theResult);
+ virtual void SameAs(const Prs3d_i* theOrigin);
+ virtual ~Prs3d_i();
+ virtual void Destroy();
+
+ protected:
+ Result_i *myResult;
+ VISU_PipeLine *myPipeLine;
+
+ bool myAddToStudy;
+ void CreateActor(VISU_Actor* theActor, const Handle(SALOME_InteractiveObject)& theIO = NULL) throw (std::runtime_error&);
+
+ public:
+ virtual void Update();
+ virtual VISU_PipeLine* GetPipeLine();
+ VISU_PipeLine* GetPL();
+
+ virtual const char* GetComment() const = 0;
+ virtual QString GenerateName() = 0;
+
+ virtual Storable* Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+ virtual void ToStream(std::ostringstream& theStr);
+
+ virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL) throw (std::runtime_error&) = 0;
+ virtual void UpdateActor(VISU_Actor* theActor);
+
+ Result_i* GetResult() const { return myResult;}
+
+ static Result_i* GetResult(SALOMEDS::SObject_ptr theSObject);
+ };
+}
+
+#endif
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
// File : VISU_PrsObject_i.cxx
// Author : Alexey PETROV
// Module : VISU
-using namespace std;
#include "VISU_PrsObject_i.hh"
-#include "VISU_Extractor.hxx"
-#include "VISU_FieldTransform.hxx"
-#include "VISU_LookupTable.hxx"
-#include "VISU_ScalarBarActor.hxx"
-#include "VISU_Actor.h"
using namespace VISU;
+using namespace std;
-#include "QAD_Config.h"
-
-#include <vtkUnstructuredGridReader.h>
-#include <vtkUnstructuredGridWriter.h>
-#include <vtkPolyDataWriter.h>
-
-#include <vtkDataSet.h>
-#include <vtkDataSetMapper.h>
-#include <vtkProperty.h>
-
-#include <vtkPolyData.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkGeometryFilter.h>
-
-#include <vtkWarpVector.h>
-#include <vtkContourFilter.h>
-#include <vtkAppendPolyData.h>
-#include <vtkCutter.h>
-#include <vtkPlane.h>
-#include <vtkCellDataToPointData.h>
-
-#include <vtkGlyph3D.h>
-#include <vtkHedgeHog.h>
-#include <vtkPolyDataSource.h>
-#include <vtkGlyphSource2D.h>
-#include <vtkTransformPolyDataFilter.h>
-#include <vtkCellCenters.h>
-#include <vtkConeSource.h>
-#include <vtkStreamLine.h>
-#include <vtkMaskPoints.h>
-
-#ifdef DEBUG
+#ifdef _DEBUG_
static int MYDEBUG = 0;
static int MYDEBUGWITHFILES = 0;
#else
static int MYDEBUG = 0;
static int MYDEBUGWITHFILES = 0;
#endif
-static float EPS = 1.0E-3;
-const float PI2 = 2.0*PI;
-
-void WriteToFile(vtkPolyData* theDataSet, const string& theFileName){
- vtkPolyDataWriter* aWriter = vtkPolyDataWriter::New();
- aWriter->SetFileName(theFileName.c_str());
- aWriter->SetInput(theDataSet);
- aWriter->Write();
- aWriter->Delete();
-}
-
-//==============================================================================
-void SetIOR(SALOMEDS::SObject_var& theSObject, const char* theIOR){
- SALOMEDS::GenericAttribute_var anAttr;
- theSObject->FindAttribute(anAttr, "AttributeIOR");
- SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
- CORBA::String_var aValue(theIOR);
- anIOR->SetValue(aValue);
-}
-
-float CalcScaleFactor(float theBound[6], int theNbElem){
- float aVolume = 1, vol, idim = 0;
- for(int i = 0; i < 6; i += 2){
- vol = fabs(theBound[i+1] - theBound[i]);
- if(vol > 0) {
- idim++;
- aVolume *= vol;
- }
- }
- aVolume /= theNbElem;
- float aFactor = pow(aVolume,(float)1./idim);
- return aFactor;
-}
-
-VISU::Result_i* GetResult(SALOMEDS::SObject_ptr theSObject){
- VISU::Result_var aResult = FindResult(theSObject);
- if(!aResult->_is_nil())
- return dynamic_cast<VISU::Result_i*>(VISU::GetServant(aResult.in()));
- return NULL;
-}
-
-//----------------------------------------------------------------
-// PrsObject
-//----------------------------------------------------------------
void VISU::PrsObject_i::SetName( const char* theName )
{
myName = theName;
CORBA::String_var anEntry = aSObject->GetID();
return anEntry.in();
}
-
-
-//----------------------------------------------------------------
-// Prs3d Object
-//----------------------------------------------------------------
-VISU::Prs3d_i::Prs3d_i(Result_i* theResult) :
- PrsObject_i(theResult->GetStudyDocument()),
- myResult(theResult)
-{
- myMapper = MapperType::New();
- myGeomFilter = vtkGeometryFilter::New();
- myGeomFilter->PointClippingOff();
- myGeomFilter->CellClippingOff();
- myGeomFilter->ExtentClippingOff();
- myGeomFilter->MergingOff();
- myColor.R = 0.5;
- myColor.G = 0.5;
- myColor.B = 0.5;
- myAddToStudy = true;
-}
-
-void VISU::Prs3d_i::SameAs(const Prs3d_i* theOrigin)
-{
- Prs3d_i* aOrigin = const_cast<Prs3d_i*>(theOrigin);
- SetColor(aOrigin->GetColor());
- myMapper->ShallowCopy(aOrigin->GetMapper());
-}
-
-void VISU::Prs3d_i::SetColor(const SALOMEDS::Color& theColor){
- myColor = theColor;
-}
-
-VISU::Prs3d_i::~Prs3d_i() {
- CORBA::release(myStudy);
- myMapper->Delete();
- myGeomFilter->Delete();
-}
-
-void VISU::Prs3d_i::Destroy() {
- CORBA::Object_var anObj = _this();
- PortableServer::POA_ptr aPOA = Base_i::GetPOA();
- PortableServer::ObjectId_var anId = aPOA->reference_to_id(anObj);
- aPOA->deactivate_object(anId.in());
- //this->_remove_ref();
-}
-
-
-/**
- * Create Actor referred on existing IO
- */
-bool VISU::Prs3d_i::CreateActor(VISU_Actor* theActor, const Handle(SALOME_InteractiveObject)& theIO){
- //MESSAGE("Prs3d_i::CreateActor");
- Update();
- myMapper->Update();
- static float eps = VTK_LARGE_FLOAT * 0.1 ;
- float aLength = myMapper->GetInput()->GetLength();
- if(aLength > eps){
- MESSAGE("Prs3d_i::CreateActor >> Diagonal of the actor is too large : "<<aLength);
- return false;
- }
- theActor->SetShrinkable(myMapper->GetInput()->GetNumberOfCells() > 10);
- myMapper->SetResolveCoincidentTopologyToShiftZBuffer();
- myMapper->SetResolveCoincidentTopologyZShift(0.02);
- theActor->SetMapper(myMapper);
- if (myAddToStudy) {
- if (theIO.IsNull()){
- //Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(GetEntry(),"VISU",GetName());
- //There is a bug in gcc compiler - const Standard_CString is mapping as char * const not as const char *
- //(where Standard_CString is defined as typedef char* Standard_CString)
- Handle(SALOME_InteractiveObject) anIO =
- new SALOME_InteractiveObject(strdup(GetEntry()),"VISU",(const Standard_CString)GetName());
- theActor->setIO(anIO);
- }else
- theActor->setIO(theIO);
- }
- theActor->setPrs3d(this);
- return true;
-}
-
-void VISU::Prs3d_i::UpdateActor(VISU_Actor* theActor) {
- if(MYDEBUG) MESSAGE("Prs3d_i::UpdateActor");
- myMapper->Update();
- theActor->Modified();
-}
-
-VISU::Storable* VISU::Prs3d_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding)
- throw(std::logic_error&)
-{
- if(MYDEBUG) MESSAGE(GetComment());
- myName = (const char*)(VISU::Storable::FindValue(theMap,"myName"));
- myColor.R = VISU::Storable::FindValue(theMap,"myColor.R").toDouble();
- myColor.G = VISU::Storable::FindValue(theMap,"myColor.G").toDouble();
- myColor.B = VISU::Storable::FindValue(theMap,"myColor.B").toDouble();
- return this;
-}
-
-void VISU::Prs3d_i::ToStream(std::ostringstream& theStr){
- Storable::DataToStream( theStr, "myName", myName.c_str() );
- Storable::DataToStream( theStr, "myColor.R", myColor.R );
- Storable::DataToStream( theStr, "myColor.G", myColor.G );
- Storable::DataToStream( theStr, "myColor.B", myColor.B );
-}
-
-void VISU::Prs3d_i::Update(){
- myMapper->Modified();
-}
-
-
-//----------------------------------------------------------------
-// Mesh Object
-//----------------------------------------------------------------
-int VISU::Mesh_i::myNbPresent = 0;
-
-QString VISU::Mesh_i::GenerateName() { return VISU::GenerateName("Mesh",myNbPresent++);}
-
-const string VISU::Mesh_i::myComment = "MESH";
-
-const char* VISU::Mesh_i::GetComment() const { return myComment.c_str();}
-
-
-VISU::Mesh_i::Mesh_i(Result_i* theResult) :
- PrsObject_i(theResult->GetStudyDocument()),
- Prs3d_i(theResult)
-{
- myInput = NULL;
- SALOMEDS::Color aColor = {0,1,1};
- SetCellColor(aColor);
- SetNodeColor(aColor);
- SALOMEDS::Color aLinkColor = {83/255.,83/255.,83/255.};
- SetLinkColor(aLinkColor);
-}
-
-void VISU::Mesh_i::SameAs(const Mesh_i* theOrigin)
-{
- return; // Same as command for mesh is not valid in current architecture
-// VISU::Prs3d_i::SameAs(theOrigin);
-// Mesh_i* aMesh = (Mesh_i*) theOrigin;
-// SetCellColor(aMesh->GetCellColor());
-// SetNodeColor(aMesh->GetNodeColor());
-// SetLinkColor(aMesh->GetLinkColor());
-// SetPresentationType(aMesh->GetPresentationType());
-// Build(false);
-}
-
-void VISU::Mesh_i::Destroy(){
- SALOMEDS::SObject_var aSObj = myStudy->FindObjectID(GetEntry());
- if(!aSObj->_is_nil()){
- SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
- aStudyBuilder->RemoveAttribute(aSObj,"AttributeIOR");
- }
- Prs3d_i::Destroy();
-}
-
-VISU::Storable* VISU::Mesh_i::Create(const char* theMeshName, int theEntity){
- myMeshName = theMeshName;
- myEntity = theEntity;
- mySubMeshName = "";
- return Build(false);
-}
-
-VISU::Storable* VISU::Mesh_i::Create(const char* theMeshName, int theEntity, const char* theFamilyName){
- myMeshName = theMeshName;
- myEntity = theEntity;
- mySubMeshName = theFamilyName;
- return Build(false);
-}
-VISU::Storable* VISU::Mesh_i::Create(const char* theMeshName, const char* theGroupName){
- myMeshName = theMeshName;
- myEntity = -1;
- mySubMeshName = theGroupName;
- return Build(false);
-}
-
-VISU::Storable* VISU::Mesh_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding)
- throw(std::logic_error&)
-{
- Prs3d_i::Restore(theMap,false);
-
- myMeshName = VISU::Storable::FindValue(theMap,"myMeshName").latin1();
- myEntity = VISU::Storable::FindValue(theMap,"myEntity").toInt();
- mySubMeshName = VISU::Storable::FindValue(theMap,"mySubMeshName").latin1();
-
- myColor.R = VISU::Storable::FindValue(theMap,"myCellColor.R").toDouble();
- myColor.G = VISU::Storable::FindValue(theMap,"myCellColor.G").toDouble();
- myColor.B = VISU::Storable::FindValue(theMap,"myCellColor.B").toDouble();
-
- myNodeColor.R = VISU::Storable::FindValue(theMap,"myNodeColor.R").toDouble();
- myNodeColor.G = VISU::Storable::FindValue(theMap,"myNodeColor.G").toDouble();
- myNodeColor.B = VISU::Storable::FindValue(theMap,"myNodeColor.B").toDouble();
-
- myLinkColor.R = VISU::Storable::FindValue(theMap,"myLinkColor.R").toDouble();
- myLinkColor.G = VISU::Storable::FindValue(theMap,"myLinkColor.G").toDouble();
- myLinkColor.B = VISU::Storable::FindValue(theMap,"myLinkColor.B").toDouble();
-
- if(theBuilding)
- return Build(true);
- return NULL;
-}
-
-void VISU::Mesh_i::ToStream(std::ostringstream& theStr){
- Prs3d_i::ToStream(theStr);
-
- Storable::DataToStream( theStr, "myMeshName", myMeshName.c_str() );
- Storable::DataToStream( theStr, "myEntity", myEntity );
- Storable::DataToStream( theStr, "mySubMeshName", mySubMeshName.c_str() );
-
- Storable::DataToStream( theStr, "myCellColor.R", myColor.R );
- Storable::DataToStream( theStr, "myCellColor.G", myColor.G );
- Storable::DataToStream( theStr, "myCellColor.B", myColor.B );
-
- Storable::DataToStream( theStr, "myNodeColor.R", myNodeColor.R );
- Storable::DataToStream( theStr, "myNodeColor.G", myNodeColor.G );
- Storable::DataToStream( theStr, "myNodeColor.B", myNodeColor.B );
-
- Storable::DataToStream( theStr, "myLinkColor.R", myLinkColor.R );
- Storable::DataToStream( theStr, "myLinkColor.G", myLinkColor.G );
- Storable::DataToStream( theStr, "myLinkColor.B", myLinkColor.B );
-}
-
-VISU::Storable* VISU::MeshRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&)
-{
- VISU::Result_i* pResult = GetResult(theSObject);
- if(pResult != NULL){
- VISU::Mesh_i* pResent = new VISU::Mesh_i(pResult);
- return pResent->Restore(theMap);
- }
- return NULL;
-}
-
-
-VISU::Mesh_i::~Mesh_i(){
- if(MYDEBUG) MESSAGE("Mesh_i::~Mesh_i()");
-}
-
-
-VISU::Storable* VISU::Mesh_i::Build(int theRestoring){
- try{
- if(myResult->GetInput() == NULL)
- throw std::runtime_error("Mesh_i::Build - myResult->GetInput() == NULL !!!");
- if(!theRestoring) myName = (const char*)(GenerateName());
- if(myEntity >= 0)
- if(mySubMeshName == "")
- myType = VISU::TENTITY;
- else
- myType = VISU::TFAMILY;
- else
- myType = VISU::TGROUP;
- if(MYDEBUG) MESSAGE("Mesh_i::Build - myType = "<<myType);
- //Building Input and comment for searching according label
- QString aComment;
- switch(myType){
- case VISU::TENTITY :
- myInput = myResult->GetInput()->GetMeshOnEntity(myMeshName,(VISU::TEntity)myEntity);
- aComment.sprintf("myComment=ENTITY;myType=%d;myMeshName=%s;myId=%d",
- VISU::TENTITY,myMeshName.c_str(),myEntity);
- break;
- case VISU::TFAMILY :
- myInput = myResult->GetInput()->GetMeshOnEntity(myMeshName,(VISU::TEntity)myEntity,mySubMeshName);
- aComment.sprintf("myComment=FAMILY;myType=%d;myMeshName=%s;myEntityId=%d;myName=%s",
- VISU::TFAMILY,myMeshName.c_str(),myEntity,mySubMeshName.c_str());
- break;
- case VISU::TGROUP :
- myInput = myResult->GetInput()->GetMeshOnGroup(myMeshName,mySubMeshName);
- aComment.sprintf("myComment=GROUP;myType=%d;myMeshName=%s;myName=%s",
- VISU::TGROUP,myMeshName.c_str(),mySubMeshName.c_str());
- break;
- }
- if(myInput == NULL) throw std::runtime_error("Mesh_i::Build - myInput == NULL !!!");
- //Binding pipeline
- vtkUnstructuredGrid *aDataSet = myInput->GetOutput();
- //Avoid selection points that don't belong any of cells
- myGeomFilter->SetInput(aDataSet);
- myMapper->SetInput(myGeomFilter->GetOutput());
- myMapper->ScalarVisibilityOff();
- //Setting IOR on the label
- if(!theRestoring) {
- string aResultEntry = myResult->GetEntry();
- string anEntry = FindEntryWithComment(myStudy,aResultEntry.c_str(),aComment.latin1());
- if(anEntry == "") throw std::runtime_error("Mesh_i::Build - anEntry was not found !!!");
- SALOMEDS::SObject_var aSObj = myStudy->FindObjectID(anEntry.c_str());
- SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
- SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aSObj,"AttributeIOR");
- SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
- CORBA::String_var aString = GetID();
- anIOR->SetValue(aString);
- }
- aDataSet->GetBounds(myBounds);
- if(MYDEBUGWITHFILES){
- string aFileName = string("/users/")+getenv("USER")+"/"+getenv("USER");
- aFileName += "-Mesh.vtk";
- ::WriteToFile(myGeomFilter->GetOutput(),aFileName.c_str());
- }
- return this;
- }catch(std::runtime_error& exc){
- MESSAGE("Follow exception was accured :\n"<<exc.what());
- }catch(...){
- MESSAGE("Unknown exception was accured!");
- }
- return NULL;
-}
-
-
-VISU_Actor* VISU::Mesh_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO) {
- VISUMesh_Actor* anActor = VISUMesh_Actor::New();
- if(MYDEBUG) MESSAGE("Prs3d_i::CreateActor");
- if(VISU::Prs3d_i::CreateActor(anActor,theIO)){
- UpdateActor(anActor);
- return anActor;
- }else{
- anActor->Delete();
- return NULL;
- }
-}
-
-void VISU::Mesh_i::UpdateActor(VISU_Actor* theActor) {
- if(VISUMesh_Actor* anActor = dynamic_cast<VISUMesh_Actor*>(theActor)){
- if(MYDEBUG) MESSAGE("Mesh_i::UpdateActor");
- VISU::Prs3d_i::UpdateActor(theActor);
- vtkProperty* aSurfaceProperty = anActor->GetProperty();
- aSurfaceProperty->SetColor(myColor.R, myColor.G, myColor.B);
- vtkProperty* anEdgeProperty = anActor->GetEdgeProperty();
- anEdgeProperty->SetColor(myLinkColor.R, myLinkColor.G, myLinkColor.B);
- }
-}
-
-
-
-//==============================================================================
-int VISU::ScalarMap_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- try{
- const VISU::TField& aField = theResult->GetInput()->GetField(theMeshName,(VISU::TEntity)theEntity,theFieldName);
- const VISU::TField::TValField& aValField = aField.myValField;
- bool aRes = aValField.find((int)theIteration) != aValField.end();
- if(MYDEBUG) MESSAGE("ScalarMap_i::IsPossible = "<<aRes)
- return aRes;
- }catch(std::runtime_error& exc){
- MESSAGE("Follow exception was accured :\n"<<exc.what());
- }catch(...){
- MESSAGE("Unknown exception was accured!");
- }
- return 0;
-}
-
-int VISU::ScalarMap_i::myNbPresent = 0;
-QString VISU::ScalarMap_i::GenerateName() { return VISU::GenerateName("ScalarMap",myNbPresent++);}
-
-const string VISU::ScalarMap_i::myComment = "SCALARMAP";
-const char* VISU::ScalarMap_i::GetComment() const { return myComment.c_str();}
-
-VISU::ScalarMap_i::ScalarMap_i(Result_i* theResult, bool theAddToStudy) :
- PrsObject_i(theResult->GetStudyDocument()),
- Prs3d_i(theResult)
-{
- myAddToStudy = theAddToStudy;
- myInput = VISU_Extractor::New();
- myFieldTransform = VISU_FieldTransform::New();
- myMapperTable = VISU_LookupTable::New();
- myBarTable = VISU_LookupTable::New();
- myIsColored = true;
- myMapScale = 1.0;
-}
-
-void VISU::ScalarMap_i::Destroy(){
- if(myAddToStudy){
- SALOMEDS::SObject_var aSObj = myStudy->FindObjectID(GetEntry());
- if(!aSObj->_is_nil()){
- SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
- aStudyBuilder->RemoveObject(aSObj);
- }
- }
- Prs3d_i::Destroy();
-}
-
-void VISU::ScalarMap_i::SameAs(const ScalarMap_i* theOrigin)
-{
- ScalarMap_i* aScalarMap = const_cast<ScalarMap_i*>(theOrigin);
- VISU::Prs3d_i::SameAs(aScalarMap);
- myField = aScalarMap->GetField();
- myMeshName = myField->myMeshName;
- myEntity = myField->myEntity;
- myIteration = aScalarMap->GetIteration();
- myFieldName = aScalarMap->GetFieldName();
-
- SetScalarMode(aScalarMap->GetScalarMode());
- SetRange(aScalarMap->GetMin(), aScalarMap->GetMax());
- SetScaling(aScalarMap->GetScaling());
- SetOrientation(aScalarMap->GetOrientation());
- SetPosition(aScalarMap->GetPosX(), aScalarMap->GetPosY());
- SetSize(aScalarMap->GetWidth(), aScalarMap->GetHeight());
- SetNbColors(aScalarMap->GetNbColors());
- SetLabels(aScalarMap->GetLabels());
- SetTitle(aScalarMap->GetTitle());
- Build(-1);
- Update();
-}
-
-
-/**
- * Creates Scalar Map and initialises it from resources
- */
-VISU::Storable* VISU::ScalarMap_i::Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, CORBA::Double theIteration){
- myIsFixedRange = false;
- // Orientation
- QString aOrient = QAD_CONFIG->getSetting("Visu:SBOrientation");
- if ( !aOrient.isEmpty() )
- myOrientation = (VISU::ScalarMap::Orientation) aOrient.toInt();
- else
- myOrientation = VISU::ScalarMap::VERTICAL;
-
- // Scalar Bar origin
- QString aXorigin = QAD_CONFIG->getSetting("Visu:SBXorigin");
- if ( !aXorigin.isEmpty() )
- myPosition[0] = aXorigin.toFloat();
- else {
- if(myOrientation == VISU::ScalarMap::VERTICAL) {
- myPosition[0] = 0.03;
- } else {
- myPosition[0] = 0.2;
- }
- }
-
- QString aYorigin = QAD_CONFIG->getSetting("Visu:SBYorigin");
- if ( !aYorigin.isEmpty() )
- myPosition[1] = aYorigin.toFloat();
- else {
- if(myOrientation == VISU::ScalarMap::VERTICAL) {
- myPosition[1] = 0.1;
- } else {
- myPosition[1] = 0.012;
- }
- }
-
- // Scalar Bar size
- QString aWidth = QAD_CONFIG->getSetting("Visu:SBWidth");
- if ( !aWidth.isEmpty() )
- myWidth = aWidth.toFloat();
- else {
- myWidth =(myOrientation == VISU::ScalarMap::VERTICAL)? 0.17:0.6;
- }
- QString aHeight = QAD_CONFIG->getSetting("Visu:SBHeight");
- if ( !aHeight.isEmpty() )
- myHeight = aHeight.toFloat();
- else {
- myHeight =(myOrientation == VISU::ScalarMap::VERTICAL)? 0.8:0.12;
- }
-
- // Nb of Colors
- QString aColors = QAD_CONFIG->getSetting("Visu:SBNumberOfColors");
- myNumberOfColors = (aColors.isEmpty())? 64 : aColors.toInt();
- if (myNumberOfColors > 64)
- myNumberOfColors = 64;
-
- // Nb of Labels
- QString aLabels = QAD_CONFIG->getSetting("Visu:SBNumberOfLabels");
- myNumberOfLabels = (aLabels.isEmpty())? 5 : aLabels.toInt();
- if (myNumberOfLabels > 65)
- myNumberOfLabels = 65;
-
- // Scalar Range
- QString aFixRange = QAD_CONFIG->getSetting("Visu:SBImposeRange");
- myIsFixedRange = (aFixRange.compare("true") == 0);
-
- QString aRangeMin = QAD_CONFIG->getSetting("Visu:SBMinimumValue");
- myScalarRange[0] = (aRangeMin.isEmpty())? 0 : aRangeMin.toFloat();
-
- QString aRangeMax = QAD_CONFIG->getSetting("Visu:SBMaximumValue");
- myScalarRange[1] = (aRangeMax.isEmpty())? 0 : aRangeMax.toFloat();
-
- QString aScaling = QAD_CONFIG->getSetting("Visu:SBScaling");
- if(aScaling.compare("LOGARITHMIC") == 0)
- myScaling = VISU::LOGARITHMIC;
- else
- myScaling = VISU::LINEAR;
-
-// myName = GenerateName();
- myMeshName = theMeshName;
- myEntity = theEntity;
- myFieldName =theFieldName;
- myScalarMode = 0;
- myIteration = theIteration;
- return Build(false);
-}
-
-
-
-VISU::Storable* VISU::ScalarMap_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding)
- throw(std::logic_error&)
-{
- Prs3d_i::Restore(theMap,false);
-
- myAddToStudy = false; //SRN Added 21/06/2003 SAL2983: to avoid addition of the new ScalarMap to study.
-
- myMeshName = (const char*)(VISU::Storable::FindValue(theMap,"myMeshName"));
- myEntity = VISU::Storable::FindValue(theMap,"myEntity").toInt();
- myFieldName = (const char*)(VISU::Storable::FindValue(theMap,"myFieldName"));
- myIteration = VISU::Storable::FindValue(theMap,"myIteration").toInt();
-
- myScalarMode = VISU::Storable::FindValue(theMap,"myScalarMode").toInt();
- myScalarRange[0] = VISU::Storable::FindValue(theMap,"myScalarRange[0]").toDouble();
- myScalarRange[1] = VISU::Storable::FindValue(theMap,"myScalarRange[1]").toDouble();
- myIsFixedRange = VISU::Storable::FindValue(theMap,"myIsFixedRange").toInt();
- myScaling = (VISU::Scaling)VISU::Storable::FindValue(theMap,"myScaling").toInt();
-
- myTitle = (const char*)(VISU::Storable::FindValue(theMap,"myTitle"));
- myOrientation = (VISU::ScalarMap::Orientation)VISU::Storable::FindValue(theMap,"myOrientation").toInt();
- myNumberOfColors = VISU::Storable::FindValue(theMap,"myNumberOfColors").toInt();
- myNumberOfLabels = VISU::Storable::FindValue(theMap,"myNumberOfLabels").toInt();
- myPosition[0] = VISU::Storable::FindValue(theMap,"myPosition[0]").toDouble();
- myPosition[1] = VISU::Storable::FindValue(theMap,"myPosition[1]").toDouble();
- myWidth = VISU::Storable::FindValue(theMap,"myWidth").toDouble();
- myHeight = VISU::Storable::FindValue(theMap,"myHeight").toDouble();
-
- if(theBuilding)
- return Build(true);
- return NULL;
-}
-
-void VISU::ScalarMap_i::ToStream(std::ostringstream& theStr){
- Prs3d_i::ToStream(theStr);
-
- Storable::DataToStream( theStr, "myMeshName", myMeshName.c_str() );
- Storable::DataToStream( theStr, "myEntity", myEntity );
- Storable::DataToStream( theStr, "myFieldName", myFieldName.c_str() );
- Storable::DataToStream( theStr, "myIteration", myIteration );
-
- Storable::DataToStream( theStr, "myScalarMode", myScalarMode );
- Storable::DataToStream( theStr, "myScalarRange[0]", myScalarRange[0] );
- Storable::DataToStream( theStr, "myScalarRange[1]", myScalarRange[1] );
- Storable::DataToStream( theStr, "myIsFixedRange", myIsFixedRange );
- Storable::DataToStream( theStr, "myScaling", myScaling );
-
- Storable::DataToStream( theStr, "myTitle", myTitle.c_str() );
- Storable::DataToStream( theStr, "myOrientation", myOrientation );
- Storable::DataToStream( theStr, "myNumberOfColors", myNumberOfColors );
- Storable::DataToStream( theStr, "myNumberOfLabels", myNumberOfLabels );
- Storable::DataToStream( theStr, "myPosition[0]", myPosition[0] );
- Storable::DataToStream( theStr, "myPosition[1]", myPosition[1] );
- Storable::DataToStream( theStr, "myWidth", myWidth );
- Storable::DataToStream( theStr, "myHeight", myHeight );
-}
-
-void VISU::ScalarMap_i::SetScaling(VISU::Scaling theScaling){
- VISU_FieldTransform::TTransformFun aFun;
- if(MYDEBUG) MESSAGE("ScalarMap_i::SetScaling - theScaling = "<<theScaling);
- switch(theScaling){
- case VISU::LOGARITHMIC :
- aFun = &Logarithmic10;
- break;
- default:
- aFun = &Identical;
- }
- myScaling = theScaling;
- vtkUnstructuredGrid *aDataSet = myInput->GetUnstructuredGridOutput();
- myFieldTransform->SetInput(aDataSet);
- myFieldTransform->SetTransformFunction(aFun);
- myFieldTransform->SetScalarRange(myScalarRange);
- if(MYDEBUGWITHFILES){
- string aFileName = string("/users/")+getenv("USER")+"/"+getenv("USER");
- aFileName += "-PrsScaling.vtk";
- WriteToFile(myFieldTransform->GetUnstructuredGridOutput(),aFileName.c_str());
- }
-}
-
-VISU::Scaling VISU::ScalarMap_i::GetScaling(){
- return myScaling;
-}
-
-
-void VISU::ScalarMap_i::SetRange(CORBA::Double theMin, CORBA::Double theMax) {
- if(theMin > theMax) return;
- myScalarRange[0] = theMin;
- myScalarRange[1] = theMax;
- myFieldTransform->SetScalarRange(myScalarRange);
- myIsFixedRange = true;
- if(MYDEBUG) MESSAGE("ScalarMap_i::SetRange = "<<myScalarRange[0]<<"; "<<myScalarRange[1]);
-}
-
-
-void VISU::ScalarMap_i::CalculateRange() {
- GetFieldRange(myScalarRange);
-}
-
-void VISU::ScalarMap_i::GetFieldRange(float theRange[2]) {
- myInput->Update();
- myInput->GetUnstructuredGridOutput()->GetScalarRange(theRange);
-}
-
-void VISU::ScalarMap_i::SetScalarMode(CORBA::Long theScalarMode){
- myScalarMode = theScalarMode;
- vtkUnstructuredGridReader* aReader =
- myResult->GetInput()->GetFieldOnMesh(myMeshName,(VISU::TEntity)myEntity,myFieldName,(int)myIteration);
- if(aReader != NULL) {
- if( MYDEBUG) MESSAGE("ScalarMap_i::SetScalarMode = "<<myIteration);
- string aFieldName = VISU_Convertor::GenerateName(myFieldName,(int)myIteration);
- myInput->Extract(aReader,aFieldName,myScalarMode,myField->myNbComp,myField->myEntity);
- if(MYDEBUGWITHFILES){
- string aFileName = string("/users/")+getenv("USER")+"/"+getenv("USER");
- aFileName += "-ScalarMode.vtk";
- WriteToFile(myInput->GetUnstructuredGridOutput(),aFileName.c_str());
- }
- }
-}
-
-VISU::Storable* VISU::ScalarMapRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&)
-{
- VISU::Result_i* pResult = GetResult(theSObject);
- if(pResult != NULL){
- VISU::ScalarMap_i* pResent = new VISU::ScalarMap_i(pResult);
- return pResent->Restore(theMap);
- }
- return NULL;
-}
-
-
-VISU::ScalarMap_i::~ScalarMap_i(){
- if(MYDEBUG) MESSAGE("ScalarMap_i::~ScalarMap_i()");
- myInput->Delete();
- myFieldTransform->Delete();
- myMapperTable->Delete();
- myBarTable->Delete();
-}
-
-
-VISU::Storable* VISU::ScalarMap_i::Build(int theRestoring){
- if(MYDEBUG)
- MESSAGE("ScalarMap_i::Build - "<<myFieldName<<"; theRestoring = "<<theRestoring);
- try{
- if(myResult->GetInput() == NULL)
- throw std::runtime_error("Mesh_i::Build - myResult->GetInput() == NULL !!!");
- myField = &(myResult->GetInput()->GetField(myMeshName,(VISU::TEntity)myEntity,myFieldName));
- if(myField == NULL) throw std::runtime_error("There is no Field with the parameters !!!");
- SetScalarMode(myScalarMode);
- if(myInput->GetInput() == NULL) throw std::runtime_error("Can't build build vtk representation !!!");
- vtkUnstructuredGrid *aDataSet = myInput->GetUnstructuredGridOutput();
- SetScaling(myScaling);
- aDataSet->GetBounds(myBounds);
- CORBA::String_var anIOR = GetID();
- const VISU::TField::TValField& aValField = myField->myValField;
- const VISU::TField::TValForTime& aValForTime = aValField.find((int)myIteration)->second;
- const VISU::TField::TTime& aTime = aValForTime.myTime;
- QString aComment;
- myName = "NoName";
- if(theRestoring == 0){
- if (!myIsFixedRange) aDataSet->GetScalarRange(myScalarRange);
- aComment.sprintf("%s %s",myFieldName.c_str(),VISU_Convertor::GenerateName(aValForTime.myTime).c_str());
- //aComment.sprintf("%s, %g",myFieldName.c_str(),aTime.first);
- myTitle = (const char*)(aComment.simplifyWhiteSpace());
- }
- if (myAddToStudy) {
- myName = (const char*)(GenerateName());
- aComment.sprintf("myComment=TIMESTAMP;myType=%d;myMeshName=%s;myEntityId=%d;myFieldName=%s;myTimeStampId=%d;myNumComponent=%d",
- VISU::TTIMESTAMP,myMeshName.c_str(),myEntity,myFieldName.c_str(),(int)myIteration,myField->myNbComp);
- string aResultEntry = myResult->GetEntry();
- string aRefFatherEntry = myResult->GetRefFatherEntry();
- string anEntry = FindEntryWithComment(myStudy,aResultEntry.c_str(),aComment.latin1());
- if(anEntry == "") throw std::runtime_error("There is no Entry for binding the presentation !!!");
- aComment.sprintf("myComment=%s;myMeshName=%s;myEntityId=%d;myFieldName=%s;myTimeStampId=%d;myNumComponent=%d;myComponentId=%d",
- GetComment(),myMeshName.c_str(),myEntity,myFieldName.c_str(),(int)myIteration,myField->myNbComp,myScalarMode);
- CreateAttributes(myStudy,anEntry.c_str(),aRefFatherEntry.c_str(),
- anIOR,myName.c_str(),"",aComment.latin1(),true);
- }
- if(MYDEBUG)
- MESSAGE("ScalarMap_i::Build - myFieldName = "<<myFieldName<<"; myName = "<<myName<<
- "; myScalarRange[0] = "<<myScalarRange[0]<<"; myScalarRange[1] = "<<myScalarRange[1]<<
- "; myNumberOfColors = "<<myNumberOfColors);
- myGeomFilter->SetInput(DoHook(theRestoring));
- myMapper->SetInput(myGeomFilter->GetOutput());
- myMapper->SetColorModeToMapScalars();
- myMapper->ScalarVisibilityOn();
- return this;
- }catch(std::runtime_error& exc){
- MESSAGE("Follow exception was accured :\n"<<exc.what());
- }catch(...){
- MESSAGE("Unknown exception was accured!");
- }
- return NULL;
-}
-
-
-VISU::ScalarMap_i::DataType* VISU::ScalarMap_i::DoHook(int theRestoring){
- myMapper->ScalarVisibilityOn();
- Update();
- return myFieldTransform->GetUnstructuredGridOutput();
-}
-
-void VISU::ScalarMap_i::Update() {
- if (!myIsFixedRange) CalculateRange();
-
- int aScaling = GetScaling() == VISU::LOGARITHMIC? VTK_SCALE_LOG10: VTK_SCALE_LINEAR;
- float aScalarRange[2] = {myScalarRange[0], myScalarRange[1]};
- myMapperTable->SetScale(VTK_SCALE_LINEAR);
- if(aScaling == VTK_SCALE_LOG10)
- VISU_LookupTable::ComputeLogRange(myScalarRange,aScalarRange);
- myMapperTable->SetRange(aScalarRange);
- myMapper->SetScalarRange(aScalarRange);
- myMapperTable->SetHueRange(0.667,0.0);
- myMapperTable->SetNumberOfColors(myNumberOfColors);
- myMapperTable->SetMapScale(myMapScale);
- myMapperTable->Build();
- myMapper->SetLookupTable(myMapperTable);
- myMapper->MapScalars(1.0f);
-
- myBarTable->SetHueRange(0.667,0.0);
- myBarTable->SetNumberOfColors(myNumberOfColors);
- myBarTable->SetRange(myScalarRange);
- myBarTable->SetScale(aScaling);
- myBarTable->Build();
-
- VISU::Prs3d_i::Update();
-}
-
-void VISU::ScalarMap_i::SetMapScale(double theMapScale){
- if(MYDEBUG) MESSAGE("ScalarMap_i::SetMapScale() - theMapScale = "<<theMapScale);
- myMapScale = theMapScale;
- Update();
-}
-
-VISU_Actor* VISU::ScalarMap_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO) {
- VISUScalarMap_Actor* anActor = VISUScalarMap_Actor::New();
- if(VISU::Prs3d_i::CreateActor(anActor,theIO)){
- anActor->SetBarVisibility(&myIsColored);
- anActor->myFieldName = myFieldName;
- anActor->GetProperty()->EdgeVisibilityOn();
- UpdateActor(anActor);
- return anActor;
- }else{
- anActor->Delete();
- return NULL;
- }
-}
-
-void VISU::ScalarMap_i::UpdateActor(VISU_Actor* theActor) {
- if(VISUScalarMap_Actor* anActor = dynamic_cast<VISUScalarMap_Actor*>(theActor)){
- VISU::Prs3d_i::UpdateActor(theActor);
- theActor->SetVisibility(theActor->GetVisibility());
- VISU_ScalarBarActor * aScalarBar = anActor->GetScalarBar();
- aScalarBar->SetLookupTable(myBarTable);
- aScalarBar->SetTitle(myTitle.c_str());
- aScalarBar->SetOrientation(myOrientation);
- aScalarBar->GetPositionCoordinate()->SetCoordinateSystemToNormalizedViewport();
- aScalarBar->GetPositionCoordinate()->SetValue(myPosition[0],myPosition[1]);
- aScalarBar->SetWidth(myWidth);
- aScalarBar->SetHeight(myHeight);
- aScalarBar->SetNumberOfLabels(myNumberOfLabels);
- aScalarBar->Modified();
- }
-}
-
-//==============================================================================
-int VISU::DeformedShape_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- try{
- if(!VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration)) return 0;
- const VISU::TField& aField = theResult->GetInput()->GetField(theMeshName,(VISU::TEntity)theEntity,theFieldName);
- return aField.myNbComp > 1;
- }catch(std::runtime_error& exc){
- MESSAGE("Follow exception was accured :\n"<<exc.what());
- }catch(...){
- MESSAGE("Unknown exception was accured!");
- }
- return 0;
-}
-
-int VISU::DeformedShape_i::myNbPresent = 0;
-QString VISU::DeformedShape_i::GenerateName() { return VISU::GenerateName("Def.Shape",myNbPresent++);}
-
-const string VISU::DeformedShape_i::myComment = "DEFORMEDSHAPE";
-const char* VISU::DeformedShape_i::GetComment() const { return myComment.c_str();}
-
-VISU::DeformedShape_i::DeformedShape_i(Result_i* theResult, bool theAddToStudy) :
- PrsObject_i(theResult->GetStudyDocument()),
- Prs3d_i(theResult),
- ScalarMap_i(theResult, theAddToStudy)
-{
- if(MYDEBUG) MESSAGE("DeformedShape_i::DeformedShape_i");
- myWarpVector = vtkWarpVector::New();
-}
-
-void VISU::DeformedShape_i::Destroy(){
- ScalarMap_i::Destroy();
-}
-
-void VISU::DeformedShape_i::SameAs(const DeformedShape_i* theOrigin)
-{
- DeformedShape_i* aDefShape = const_cast<DeformedShape_i*>(theOrigin);
- setColored(aDefShape->isColored());
- SetScale(aDefShape->GetScale());
- VISU::ScalarMap_i::SameAs(theOrigin);
-}
-
-
-VISU::Storable* VISU::DeformedShape_i::Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- myIsColored = false;
- return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
-}
-
-VISU::Storable* VISU::DeformedShape_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding)
- throw(std::logic_error&)
-{
- ScalarMap_i::Restore(theMap,false);
-
- myFactor = VISU::Storable::FindValue(theMap,"myFactor").toDouble();
- myIsColored = VISU::Storable::FindValue(theMap,"myIsColored").toInt();
-
- if(theBuilding)
- return Build(true);
- return NULL;
-}
-
-void VISU::DeformedShape_i::ToStream(std::ostringstream& theStr){
- ScalarMap_i::ToStream(theStr);
-
- Storable::DataToStream( theStr, "myFactor", myFactor );
- Storable::DataToStream( theStr, "myIsColored", myIsColored );
-}
-
-VISU::Storable* VISU::DeformedShapeRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&)
-{
- VISU::Result_i* pResult = GetResult(theSObject);
- if(pResult != NULL){
- VISU::DeformedShape_i* pResent = new VISU::DeformedShape_i(pResult);
- return pResent->Restore(theMap);
- }
- return NULL;
-}
-
-
-VISU::DeformedShape_i::~DeformedShape_i(){
- if(MYDEBUG) MESSAGE("DeformedShape_i::~DeformedShape_i()");
- myWarpVector->Delete();
-}
-
-
-VISU::ScalarMap_i::DataType* VISU::DeformedShape_i::DoHook(int theRestoring){
- if(theRestoring == 0)
- myFactor = ScaleFactor()/GetMax();
- if(MYDEBUG) MESSAGE("DeformedShape_i::DoHook() - myFactor = "<<myFactor);
- Update();
- return myWarpVector->GetOutput();
-}
-
-
-float VISU::DeformedShape_i::ScaleFactor() {
- vtkUnstructuredGrid *aDataSet = myInput->GetUnstructuredGridOutput();
- aDataSet->Update();
- int nbCells = aDataSet->GetNumberOfCells(), nbPoints = aDataSet->GetNumberOfPoints();
- return ::CalcScaleFactor(myBounds, nbCells? nbCells: nbPoints);
-}
-
-void VISU::DeformedShape_i::Update(){
- if(myField->myNbComp > 1){
- if(myField->myEntity == VISU::CELL_ENTITY){
- vtkCellDataToPointData *aFilter = vtkCellDataToPointData::New();
- aFilter->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- aFilter->PassCellDataOn();
- myWarpVector->SetInput(aFilter->GetUnstructuredGridOutput());
- aFilter->Delete();
- }else
- myWarpVector->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- myWarpVector->SetScaleFactor(myFactor*myMapScale);
- myMapper->SetScalarVisibility(myIsColored);
- }
- ScalarMap_i::Update();
-}
-
-void VISU::DeformedShape_i::SetColor(const SALOMEDS::Color& theColor){
- VISU::Prs3d_i::SetColor(theColor);
- myIsColored = false;
-}
-
-void VISU::DeformedShape_i::SetMapScale(double theMapScale){
- myMapScale = theMapScale;
- Update();
-}
-
-VISU_Actor* VISU::DeformedShape_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO) {
- VISU_Actor* anActor = VISU::ScalarMap_i::CreateActor(theIO);
- anActor->SetRepresentation(1);
- return anActor;
-}
-
-void VISU::DeformedShape_i::UpdateActor(VISU_Actor* theActor) {
- VISU::ScalarMap_i::UpdateActor(theActor);
- if(!myIsColored)
- theActor->GetProperty()->SetColor(myColor.R,myColor.G,myColor.B);
-}
-
-//==============================================================================
-int VISU::CutPlanes_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration);
-}
-
-int VISU::CutPlanes_i::myNbPresent = 0;
-QString VISU::CutPlanes_i::GenerateName() { return VISU::GenerateName("CutPlanes",myNbPresent++);}
-
-const string VISU::CutPlanes_i::myComment = "CUTPLANES";
-const char* VISU::CutPlanes_i::GetComment() const { return myComment.c_str();}
-
-VISU::CutPlanes_i::CutPlanes_i(Result_i* theResult, bool theAddToStudy) :
- PrsObject_i(theResult->GetStudyDocument()),
- Prs3d_i(theResult),
- ScalarMap_i(theResult, theAddToStudy)
-{
- if(MYDEBUG) MESSAGE("CutPlanes_i::CutPlanes_i");
- myAppendPolyData = vtkAppendPolyData::New();
-}
-
-void VISU::CutPlanes_i::Destroy(){
- ScalarMap_i::Destroy();
-}
-
-void VISU::CutPlanes_i::SameAs(const CutPlanes_i* theOrigin)
-{
- CutPlanes_i* aCutPlanes = const_cast<CutPlanes_i*>(theOrigin);
- SetNbPlanes(aCutPlanes->GetNbPlanes());
- SetDisplacement(aCutPlanes->GetDisplacement());
- SetOrientationType(aCutPlanes->GetOrientationType());
- SetRotateX(aCutPlanes->GetRotateX());
- SetRotateY(aCutPlanes->GetRotateY());
- VISU::ScalarMap_i::SameAs(theOrigin);
-}
-
-VISU::Storable* VISU::CutPlanes_i::Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
-}
-
-VISU::Storable* VISU::CutPlanes_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding)
- throw(std::logic_error&)
-{
- ScalarMap_i::Restore(theMap,false);
-
- myNbPlanes = VISU::Storable::FindValue(theMap,"myNbPlanes").toInt();
- myDisplacement = VISU::Storable::FindValue(theMap,"myDisplacement").toDouble();
- myBasePlane = (VISU::CutPlanes::Orientation)VISU::Storable::FindValue(theMap,"myBasePlane").toInt();
- SetOrientationType(myBasePlane);
- float aRot[2];
- aRot[0] = VISU::Storable::FindValue(theMap,"aRot[0]").toDouble();
- SetRotateX(aRot[0]);
- aRot[1] = VISU::Storable::FindValue(theMap,"aRot[1]").toDouble();
- SetRotateY(aRot[1]);
-
- if(theBuilding)
- return Build(true);
- return NULL;
-}
-
-void VISU::CutPlanes_i::ToStream(std::ostringstream& theStr){
- ScalarMap_i::ToStream(theStr);
-
- Storable::DataToStream( theStr, "myNbPlanes", myNbPlanes );
- Storable::DataToStream( theStr, "myDisplacement", myDisplacement );
- Storable::DataToStream( theStr, "myBasePlane", myBasePlane );
- Storable::DataToStream( theStr, "aRot[0]", GetRotateX() );
- Storable::DataToStream( theStr, "aRot[1]", GetRotateY() );
-}
-
-VISU::Storable* VISU::CutPlanesRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&)
-{
- VISU::Result_i* pResult = GetResult(theSObject);
- if(pResult != NULL){
- VISU::CutPlanes_i* pResent = new VISU::CutPlanes_i(pResult);
- return pResent->Restore(theMap);
- }
- return NULL;
-}
-
-
-VISU::CutPlanes_i::~CutPlanes_i(){
- if(MYDEBUG) MESSAGE("CutPlanes_i::~CutPlanes_i()");
- myAppendPolyData->Delete();
-}
-
-
-float* GetIdent(float theR[3][3]){
- for(int i = 0; i < 3; i++)
- for(int j = 0; j < 3; j++)
- theR[i][j] = (i==j? 1.0: 0.0);
- return theR[0];
-}
-
-
-float* GetRx(float theRx[3][3], float thaAng){
- theRx[0][0] = 1.0; theRx[0][1] = 0.0; theRx[0][2] = 0.0;
- theRx[1][0] = 0.0; theRx[1][1] = cos(thaAng); theRx[1][2] = -sin(thaAng);
- theRx[2][0] = 0.0; theRx[2][1] = sin(thaAng); theRx[2][2] = cos(thaAng);
- return theRx[0];
-}
-
-
-float* GetRy(float theRy[3][3], float thaAng){
- theRy[0][0] = cos(thaAng); theRy[0][1] = 0.0; theRy[0][2] = sin(thaAng);
- theRy[1][0] = 0.0; theRy[1][1] = 1.0; theRy[1][2] = 0.0;
- theRy[2][0] = -sin(thaAng); theRy[2][1] = 0.0; theRy[2][2] = cos(thaAng);
- return theRy[0];
-}
-
-
-float* GetRz(float theRz[3][3], float thaAng){
- theRz[0][0] = cos(thaAng); theRz[0][1] = -sin(thaAng); theRz[0][2] = 0.0;
- theRz[1][0] = sin(thaAng); theRz[1][1] = cos(thaAng); theRz[1][2] = 0.0;
- theRz[2][0] = 0.0; theRz[2][1] = 0.0; theRz[2][2] = 1.0;
- return theRz[0];
-}
-
-
-void MulMatrix(float C[3][3], const float A[3][3], const float B[3][3]){ // C = A*B;
- for(int i = 0; i < 3; i++)
- for(int j = 0; j < 3; j++){
- C[i][j] = 0.0;
- for(int k = 0; k < 3; k++)
- C[i][j] += A[i][k]*B[k][j];
- }
-}
-
-
-void Sub(float C[3], const float A[3], float B[3]){ // AxB;
- for(int i = 0; i < 3; i++) C[i] = B[i] - A[i];
-}
-
-float DotMul(const float A[3], const float B[3]){ // A*B;
- float C = 0.0;
- for(int i = 0; i < 3; i++) C += A[i]*B[i];
- return C;
-}
-
-void Mul(float C[3], const float A[3], float B[3]){ // AxB;
- C[0] = A[1]*B[2] - A[2]*B[1];
- C[1] = A[2]*B[0] - A[0]*B[2];
- C[2] = A[0]*B[1] - A[1]*B[0];
-}
-
-void Mul(float C[3], const float A[3], float B){ // A*B;
- for(int i = 0; i < 3; i++) C[i] = A[i]*B;
-}
-
-void CorrectPnt(float thePnt[3], const float BoundPrj[3]){
- for(int i = 0, j = 0; i < 3; ++i, j=2*i){
- if(thePnt[i] < BoundPrj[j]) thePnt[i] = BoundPrj[j];
- if(thePnt[i] > BoundPrj[j+1]) thePnt[i] = BoundPrj[j+1];
- }
-}
-
-void GetBoundProject(float BoundPrj[3], const float BoundBox[6], const float Dir[3]){
- float BoundPoints[8][3] = { {BoundBox[0],BoundBox[2],BoundBox[4]},
- {BoundBox[1],BoundBox[2],BoundBox[4]},
- {BoundBox[0],BoundBox[3],BoundBox[4]},
- {BoundBox[1],BoundBox[3],BoundBox[4]},
- {BoundBox[0],BoundBox[2],BoundBox[5]},
- {BoundBox[1],BoundBox[2],BoundBox[5]},
- {BoundBox[0],BoundBox[3],BoundBox[5]},
- {BoundBox[1],BoundBox[3],BoundBox[5]}};
- BoundPrj[0] = DotMul(Dir,BoundPoints[0]), BoundPrj[1] = BoundPrj[0];
- float tmp;
- for(int i = 1; i < 8; i++){
- tmp = DotMul(Dir,BoundPoints[i]);
- if(BoundPrj[1] < tmp) BoundPrj[1] = tmp;
- if(BoundPrj[0] > tmp) BoundPrj[0] = tmp;
- }
- BoundPrj[2] = BoundPrj[1] - BoundPrj[0];
- BoundPrj[1] = BoundPrj[0] + (1.0 - EPS)*BoundPrj[2];
- BoundPrj[0] = BoundPrj[0] + EPS*BoundPrj[2];
- BoundPrj[2] = BoundPrj[1] - BoundPrj[0];
-}
-
-void VISU::CutPlanes_i::SetRotateX(CORBA::Double theAng){
- if(myBasePlane == VISU::CutPlanes::XY)
- myAng[0] = theAng;
- else if(myBasePlane == VISU::CutPlanes::YZ)
- myAng[1] = theAng;
- else if(myBasePlane == VISU::CutPlanes::ZX)
- myAng[2] = theAng;
-}
-
-CORBA::Double VISU::CutPlanes_i::GetRotateX(){
- if(myBasePlane == VISU::CutPlanes::XY)
- return myAng[0];
- else if(myBasePlane == VISU::CutPlanes::YZ)
- return myAng[1];
- else if(myBasePlane == VISU::CutPlanes::ZX)
- return myAng[2];
-}
-
-void VISU::CutPlanes_i::SetRotateY(CORBA::Double theAng){
- if(myBasePlane == VISU::CutPlanes::XY)
- myAng[1] = theAng;
- else if(myBasePlane == VISU::CutPlanes::YZ)
- myAng[2] = theAng;
- else if(myBasePlane == VISU::CutPlanes::ZX)
- myAng[0] = theAng;
-}
-
-CORBA::Double VISU::CutPlanes_i::GetRotateY(){
- if(myBasePlane == VISU::CutPlanes::XY)
- return myAng[1];
- else if(myBasePlane == VISU::CutPlanes::YZ)
- return myAng[2];
- else if(myBasePlane == VISU::CutPlanes::ZX)
- return myAng[0];
-}
-
-void GetDir(float theDir[3], float theAng[3],
- const VISU::CutPlanes::Orientation& theBasePlane)
-{
- int iPlane = 0;
- float aRx[3][3], aRy[3][3], aRz[3][3], aRotation[3][3];
- if(theBasePlane == VISU::CutPlanes::XY){ // X-Y
- if(fabs(theAng[0]) > EPS) ::GetRx(aRx,theAng[0]); else ::GetIdent(aRx);
- if(fabs(theAng[1]) > EPS) ::GetRy(aRy,theAng[1]); else ::GetIdent(aRy);
- ::MulMatrix(aRotation,aRx,aRy);
- iPlane = 2;
- }else if(theBasePlane == VISU::CutPlanes::YZ){ // Y-Z
- if(fabs(theAng[1]) > EPS) ::GetRy(aRy,theAng[1]); else ::GetIdent(aRy);
- if(fabs(theAng[2]) > EPS) ::GetRz(aRz,theAng[2]); else ::GetIdent(aRz);
- ::MulMatrix(aRotation,aRy,aRz);
- iPlane = 0;
- }else if(theBasePlane == VISU::CutPlanes::ZX){ // Z-X
- if(fabs(theAng[2]) > EPS) ::GetRz(aRz,theAng[2]); else ::GetIdent(aRz);
- if(fabs(theAng[0]) > EPS) ::GetRx(aRx,theAng[0]); else ::GetIdent(aRx);
- ::MulMatrix(aRotation,aRz,aRx);
- iPlane = 1;
- }
- for(int i = 0; i < 3; i++) theDir[i] = aRotation[i][iPlane];
-}
-
-void CutWithPlane(vtkAppendPolyData* theAppendPolyData, vtkDataSet* theDataSet,
- float theDir[3], float theOrig[3])
-{
- vtkCutter *aCutPlane = vtkCutter::New();
- aCutPlane->SetInput(theDataSet);
- vtkPlane *aPlane = vtkPlane::New();
- aPlane->SetOrigin(theOrig);
-
- aPlane->SetNormal(theDir);
- aCutPlane->SetCutFunction(aPlane);
- aPlane->Delete();
- theAppendPolyData->AddInput(aCutPlane->GetOutput());
- aCutPlane->Delete();
-}
-
-void CutWithPlanes(vtkAppendPolyData* theAppendPolyData, vtkDataSet* theDataSet,
- int theNbPlanes, float theDir[3], float theBounds[6], float theDisplacement)
-{
- float aInvDir[3], aBoundPrj[3], aOrig[3], aPosition;
- ::Mul(aInvDir,theDir,-1.0);
- ::GetBoundProject(aBoundPrj, theBounds, theDir);
- if(theNbPlanes > 1){
- float aDBoundPrj = aBoundPrj[2]/(theNbPlanes - 1);
- float aDisplacement = aDBoundPrj*theDisplacement;
- float aStartPosition = aBoundPrj[0] - 0.5*aDBoundPrj + aDisplacement;
- for (int i = 0; i < theNbPlanes; i++){
- aPosition = aStartPosition + i*aDBoundPrj;
- float aDelta = (aBoundPrj[0] - aPosition) / aBoundPrj[2];
- if(aDelta > 0)
- aPosition = aBoundPrj[0];
- //if(fabs(aDelta) < EPS) aPosition = aBoundPrj[0]; else continue;
- aDelta = (aBoundPrj[2] - aPosition) / aBoundPrj[2];
- if(aDelta < 0)
- aPosition = aBoundPrj[2];
- //if(fabs(aDelta) < EPS) aPosition = aBoundPrj[2]; else continue;
- Mul(aOrig,theDir,aPosition);
- if(i != 0)
- CutWithPlane(theAppendPolyData,theDataSet,theDir,aOrig);
- else
- CutWithPlane(theAppendPolyData,theDataSet,aInvDir,aOrig);
- }
- }else{
- aPosition = aBoundPrj[0] + aBoundPrj[2]*theDisplacement;
- Mul(aOrig,theDir,aPosition);
- CutWithPlane(theAppendPolyData,theDataSet,theDir,aOrig);
- }
-}
-
-VISU::ScalarMap_i::DataType* VISU::CutPlanes_i::DoHook(int theRestoring){
- if(theRestoring == 0){
- myNbPlanes = 10;
- myDisplacement = 0.5;
- myBasePlane = VISU::CutPlanes::XY;
- myAng[0] = myAng[1] = myAng[2] = 0.0;
- }
- if(MYDEBUG)
- MESSAGE("CutPlanes_i::DoHook() - myNbPlanes = "<<myNbPlanes<<"; myBasePlane = "<<myBasePlane<<
- "; myAng[0] = "<<myAng[0]<<"; myAng[1] = "<<myAng[1]<<"; myAng[2] = "<<myAng[2]);
- Update();
- return myAppendPolyData->GetOutput();
-}
-
-void VISU::CutPlanes_i::Update(){
- int iEnd = myAppendPolyData->GetNumberOfInputs();
- if(MYDEBUG) MESSAGE("CutPlanes_i::Update - iEnd = "<<iEnd);
- for(int i = iEnd-1; i >= 0; i--)
- myAppendPolyData->RemoveInput(myAppendPolyData->GetInput(i));
- float aDir[3];
- ::GetDir(aDir,myAng,myBasePlane);
- vtkDataSet* aDataSet = myFieldTransform->GetUnstructuredGridOutput();
- ::CutWithPlanes(myAppendPolyData,aDataSet,GetNbPlanes(),aDir,myBounds,myDisplacement);
- myMapper->ScalarVisibilityOn();
- VISU::ScalarMap_i::Update();
-}
-
-//==============================================================================
-int VISU::CutLines_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration);
-}
-
-int VISU::CutLines_i::myNbPresent = 0;
-QString VISU::CutLines_i::GenerateName() { return VISU::GenerateName("CutLines",myNbPresent++);}
-
-const string VISU::CutLines_i::myComment = "CUTLINES";
-const char* VISU::CutLines_i::GetComment() const { return myComment.c_str();}
-
-VISU::CutLines_i::CutLines_i(Result_i* theResult, bool theAddToStudy) :
- PrsObject_i(theResult->GetStudyDocument()),
- Prs3d_i(theResult),
- ScalarMap_i(theResult, theAddToStudy)
-{
- if(MYDEBUG) MESSAGE("CutLines_i::CutLines_i");
- myAppendPolyData = vtkAppendPolyData::New();
-}
-
-void VISU::CutLines_i::Destroy(){
- ScalarMap_i::Destroy();
-}
-
-void VISU::CutLines_i::SameAs(const CutLines_i* theOrigin)
-{
- CutLines_i* aCutLines = const_cast<CutLines_i*>(theOrigin);
- SetNbLines(aCutLines->GetNbLines());
- SetDisplacement(aCutLines->GetDisplacement());
- SetDisplacement2(aCutLines->GetDisplacement2());
- SetOrientationType(aCutLines->GetOrientationType());
- SetOrientationType2(aCutLines->GetOrientationType2());
- SetRotateX(aCutLines->GetRotateX());
- SetRotateY(aCutLines->GetRotateY());
- SetRotateX2(aCutLines->GetRotateX2());
- SetRotateY2(aCutLines->GetRotateY2());
- VISU::ScalarMap_i::SameAs(theOrigin);
-}
-
-VISU::Storable* VISU::CutLines_i::Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
-}
-
-VISU::Storable* VISU::CutLines_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding)
- throw(std::logic_error&)
-{
- ScalarMap_i::Restore(theMap,false);
- myNbLines = VISU::Storable::FindValue(theMap,"myNbLines").toInt();
- myDisplacement[0] = VISU::Storable::FindValue(theMap,"myDisplacement[0]").toDouble();
- myDisplacement[1] = VISU::Storable::FindValue(theMap,"myDisplacement[1]").toDouble();
- myBasePlane[0] = (VISU::CutPlanes::Orientation)VISU::Storable::FindValue(theMap,"myBasePlane[0]").toInt();
- myBasePlane[1] = (VISU::CutPlanes::Orientation)VISU::Storable::FindValue(theMap,"myBasePlane[1]").toInt();
- SetOrientationType(myBasePlane[0]);
- SetOrientationType2(myBasePlane[1]);
- float aRot[2];
- aRot[0] = VISU::Storable::FindValue(theMap,"aRot[0][0]").toDouble();
- SetRotateX(aRot[0]);
- aRot[1] = VISU::Storable::FindValue(theMap,"aRot[0][1]").toDouble();
- SetRotateY(aRot[1]);
- aRot[0] = VISU::Storable::FindValue(theMap,"aRot[1][0]").toDouble();
- SetRotateX2(aRot[0]);
- aRot[1] = VISU::Storable::FindValue(theMap,"aRot[1][1]").toDouble();
- SetRotateY2(aRot[1]);
- if(theBuilding)
- return Build(true);
- return NULL;
-}
-
-void VISU::CutLines_i::ToStream(std::ostringstream& theStr){
- ScalarMap_i::ToStream(theStr);
- Storable::DataToStream( theStr, "myNbLines", myNbLines );
- Storable::DataToStream( theStr, "myDisplacement[0]", myDisplacement[0] );
- Storable::DataToStream( theStr, "myDisplacement[1]", myDisplacement[1] );
- Storable::DataToStream( theStr, "myBasePlane[0]", myBasePlane[0] );
- Storable::DataToStream( theStr, "myBasePlane[1]", myBasePlane[1] );
- Storable::DataToStream( theStr, "aRot[0][0]", GetRotateX() );
- Storable::DataToStream( theStr, "aRot[0][1]", GetRotateY() );
- Storable::DataToStream( theStr, "aRot[1][0]", GetRotateX2() );
- Storable::DataToStream( theStr, "aRot[1][1]", GetRotateY2() );
-}
-
-VISU::Storable* VISU::CutLinesRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&)
-{
- VISU::Result_i* pResult = GetResult(theSObject);
- if(pResult != NULL){
- VISU::CutLines_i* pResent = new VISU::CutLines_i(pResult);
- return pResent->Restore(theMap);
- }
- return NULL;
-}
-
-
-VISU::CutLines_i::~CutLines_i(){
- if(MYDEBUG) MESSAGE("CutLines_i::~CutLines_i()");
- myAppendPolyData->Delete();
-}
-
-void VISU::CutLines_i::SetRotateX(CORBA::Double theAng){
- if(myBasePlane[0] == VISU::CutPlanes::XY)
- myAng[0][0] = theAng;
- else if(myBasePlane[0] == VISU::CutPlanes::YZ)
- myAng[0][1] = theAng;
- else if(myBasePlane[0] == VISU::CutPlanes::ZX)
- myAng[0][2] = theAng;
-}
-
-CORBA::Double VISU::CutLines_i::GetRotateX(){
- if(myBasePlane[0] == VISU::CutPlanes::XY)
- return myAng[0][0];
- else if(myBasePlane[0] == VISU::CutPlanes::YZ)
- return myAng[0][1];
- else if(myBasePlane[0] == VISU::CutPlanes::ZX)
- return myAng[0][2];
-}
-
-void VISU::CutLines_i::SetRotateY(CORBA::Double theAng){
- if(myBasePlane[0] == VISU::CutPlanes::XY)
- myAng[0][1] = theAng;
- else if(myBasePlane[0] == VISU::CutPlanes::YZ)
- myAng[0][2] = theAng;
- else if(myBasePlane[0] == VISU::CutPlanes::ZX)
- myAng[0][0] = theAng;
-}
-
-CORBA::Double VISU::CutLines_i::GetRotateY(){
- if(myBasePlane[0] == VISU::CutPlanes::XY)
- return myAng[0][1];
- else if(myBasePlane[0] == VISU::CutPlanes::YZ)
- return myAng[0][2];
- else if(myBasePlane[0] == VISU::CutPlanes::ZX)
- return myAng[0][0];
-}
-
-void VISU::CutLines_i::SetRotateX2(CORBA::Double theAng){
- if(myBasePlane[1] == VISU::CutPlanes::XY)
- myAng[1][0] = theAng;
- else if(myBasePlane[1] == VISU::CutPlanes::YZ)
- myAng[1][1] = theAng;
- else if(myBasePlane[1] == VISU::CutPlanes::ZX)
- myAng[1][2] = theAng;
-}
-
-CORBA::Double VISU::CutLines_i::GetRotateX2(){
- if(myBasePlane[1] == VISU::CutPlanes::XY)
- return myAng[1][0];
- else if(myBasePlane[1] == VISU::CutPlanes::YZ)
- return myAng[1][1];
- else if(myBasePlane[1] == VISU::CutPlanes::ZX)
- return myAng[1][2];
-}
-
-void VISU::CutLines_i::SetRotateY2(CORBA::Double theAng){
- if(myBasePlane[1] == VISU::CutPlanes::XY)
- myAng[1][1] = theAng;
- else if(myBasePlane[1] == VISU::CutPlanes::YZ)
- myAng[1][2] = theAng;
- else if(myBasePlane[1] == VISU::CutPlanes::ZX)
- myAng[1][0] = theAng;
-}
-
-CORBA::Double VISU::CutLines_i::GetRotateY2(){
- if(myBasePlane[1] == VISU::CutPlanes::XY)
- return myAng[1][1];
- else if(myBasePlane[1] == VISU::CutPlanes::YZ)
- return myAng[1][2];
- else if(myBasePlane[1] == VISU::CutPlanes::ZX)
- return myAng[1][0];
-}
-
-VISU::ScalarMap_i::DataType* VISU::CutLines_i::DoHook(int theRestoring){
- if(theRestoring == 0){
- myNbLines = 10;
- myDisplacement[0] = myDisplacement[1] = 0.5;
- myAng[0][0] = myAng[0][1] = myAng[0][2] = 0.0;
- myAng[1][0] = myAng[1][1] = myAng[1][2] = 0.0;
- myBasePlane[0] = VISU::CutPlanes::ZX;
- myBasePlane[1] = VISU::CutPlanes::XY;
- }
- Update();
- return myAppendPolyData->GetOutput();
-}
-
-void ClearAppendPolyData(vtkAppendPolyData *theAppendPolyData){
- int iEnd = theAppendPolyData->GetNumberOfInputs();
- for(int i = iEnd-1; i >= 0; i--)
- theAppendPolyData->RemoveInput(theAppendPolyData->GetInput(i));
-}
-
-void VISU::CutLines_i::Update(){
- ::ClearAppendPolyData(myAppendPolyData);
- vtkAppendPolyData *anAppendPolyData = vtkAppendPolyData::New();
- //Build base plane
- float aDir[2][3];
- ::GetDir(aDir[0],myAng[0],myBasePlane[0]);
- ::CutWithPlanes(anAppendPolyData,myFieldTransform->GetUnstructuredGridOutput(),1,aDir[0],myBounds,myDisplacement[0]);
- anAppendPolyData->Update();
- vtkPolyData *aPolyData = anAppendPolyData->GetOutput();
- if(MYDEBUG) MESSAGE("CutPlanes_i::Update - aPolyData->GetNumberOfCells() = "<<aPolyData->GetNumberOfCells());
- if(aPolyData->GetNumberOfCells() == 0){
- ::ClearAppendPolyData(anAppendPolyData);
- vtkGeometryFilter *aGeomFilter = vtkGeometryFilter::New();
- aGeomFilter->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- anAppendPolyData->AddInput(aGeomFilter->GetOutput());
- aGeomFilter->Delete();
- anAppendPolyData->Update();
- }
- //Build lines
- float aBounds[6];
- aPolyData = anAppendPolyData->GetOutput();
- aPolyData->GetBounds(aBounds);
- ::GetDir(aDir[1],myAng[1],myBasePlane[1]);
- ::CutWithPlanes(myAppendPolyData,aPolyData,GetNbLines(),aDir[1],aBounds,myDisplacement[1]);
- anAppendPolyData->Delete();
- //Calculate values for building of table
- ::Mul(myDirLn,aDir[0],aDir[1]);
- ::GetBoundProject(myBoundPrjLn, myBounds, myDirLn);
- Mul(myBasePnt,myDirLn,myBoundPrjLn[0]);
- CorrectPnt(myBasePnt,myBounds);
- myMapper->ScalarVisibilityOn();
- VISU::ScalarMap_i::Update();
-}
-
-void VISU::CutLines_i::BuildTableOfReal(SALOMEDS::SObject_ptr theSObject){
- if(MYDEBUG) MESSAGE("CutPlanes_i::BuildTableOfReal");
- Update();
- SALOMEDS::GenericAttribute_var anAttr;
- SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
- anAttr = aStudyBuilder->FindOrCreateAttribute(theSObject, "AttributeTableOfReal");
- SALOMEDS::AttributeTableOfReal_var aTableOfReal = SALOMEDS::AttributeTableOfReal::_narrow(anAttr);
-
- typedef set<long> TLineCont;
- typedef map<float,TLineCont> TXMap;
- typedef map<float,float> TXYMap;
- typedef vector<TXYMap> TCurveVect;
-
- const VISU::TField::TValField& aValField = myField->myValField;
- const VISU::TField::TValForTime& aValForTime = aValField.find((int)myIteration)->second;
- const VISU::TField::TTime& aTime = aValForTime.myTime;
- QString aTitle;
- //aTitle.sprintf("%s %s",myTitle.c_str(),aTime.second.c_str());
- aTitle.sprintf("%s",myTitle.c_str());
- aTitle = aTitle.simplifyWhiteSpace();
- aTableOfReal->SetTitle(aTitle.latin1());
-
- myAppendPolyData->Update();
- int iLineEnd = myAppendPolyData->GetNumberOfInputs();
- if(MYDEBUG) MESSAGE("CutPlanes_i::BuildTableOfReal iLineEnd = "<<iLineEnd);
- TCurveVect aCurveVect(iLineEnd);
- TLineCont aLineCont;
- TXMap aXMap;
- for(int iLine = 0; iLine < iLineEnd; iLine++){
- vtkDataSet *aDataSet = myAppendPolyData->GetInput(iLine);
- aDataSet->Update();
- int aNbPoints = aDataSet->GetNumberOfPoints();
- if(MYDEBUG) MESSAGE("CutPlanes_i::BuildTableOfReal iLine = "<<iLine<<"; aNbPoints = "<<aNbPoints);
- vtkPointData *aPointData = aDataSet->GetPointData();
- vtkDataArray *aScalars = aPointData->GetScalars();
- vtkCellDataToPointData *aFilter = NULL;
- if(!aScalars) {
- aFilter = vtkCellDataToPointData::New();
- aFilter->SetInput(aDataSet);
- aFilter->PassCellDataOn();
- aDataSet = aFilter->GetOutput();
- aDataSet->Update();
- }
- aPointData = aDataSet->GetPointData();
- aScalars = aPointData->GetScalars();
- if(!aScalars) continue;
- aLineCont.insert(iLine);
- TXYMap& aXYMap = aCurveVect[iLine];
- float aPnt[3], aVect[3], aDist;
- for(int i = 0; i < aNbPoints; i++){
- aDataSet->GetPoint(i,aPnt);
- Sub(aVect,myBasePnt,aPnt);
- aDist = DotMul(aVect,myDirLn) / myBoundPrjLn[2];
- // the workaround
- if(aDist < 0.0) aDist = 0.0;
- if(aDist > 1.0) aDist = 1.0;
- aXYMap[aDist] = aScalars->GetTuple1(i);
- //aXMap[aDist].insert(iLine);
- }
- if(aFilter) aFilter->Delete();
- }
- iLineEnd = aLineCont.size();
- if(iLineEnd == 0){
- MESSAGE("CutPlanes_i::BuildTableOfReal aLineCont.size() == 0 !!!");
- return;
- }
- //Resorting of theXYMap
- for(int iLine = 0; iLine < iLineEnd; iLine++){
- TXYMap& aXYMap = aCurveVect[iLine], aNewXYMap;
- if(aXYMap.size() > 2){
- TXYMap::const_iterator aXYMapIter[2] = {aXYMap.begin(), ++aXYMap.begin()};
- aNewXYMap[aXYMapIter[0]->first] = aXYMapIter[0]->second;
- for(; aXYMapIter[1] != aXYMap.end(); aXYMapIter[0]++, aXYMapIter[1]++){
- float aY[3] = {aXYMapIter[0]->second, aXYMapIter[1]->second, 0.0};
- aY[2] = (aY[0] + aY[1])/2.0;
- float aX[3] = {aXYMapIter[0]->first, aXYMapIter[1]->first, 0.0};
- aX[2] = (aX[0] + aX[1])/2.0;
- aNewXYMap[aX[2]] = aY[2];
- aXMap[aX[2]].insert(iLine);
- }
- aNewXYMap[aXYMapIter[0]->first] = aXYMapIter[0]->second;
- aXYMap = aNewXYMap;
- }
- }
- QString aString;
- aTableOfReal->SetNbColumns(aXMap.size());
- TXMap::const_iterator aXMapIter = aXMap.begin();
- for(long i = 0; aXMapIter != aXMap.end(); aXMapIter++, i++){
- float aDist = aXMapIter->first;
- aTableOfReal->PutValue(aDist,1,i+1);
- aString.sprintf("%d",i);
- aTableOfReal->SetColumnTitle(i+1,aString.latin1());
- const TLineCont& aLineCont = aXMapIter->second;
- long jEnd = aLineCont.size();
- if(0&& MYDEBUG) MESSAGE("CutPlanes_i::BuildTableOfReal aDist = "<<aDist<<"; jEnd = "<<jEnd);
- TLineCont::const_iterator aLineContIter = aLineCont.begin();
- for(; aLineContIter != aLineCont.end(); aLineContIter++){
- long iLine = *aLineContIter;
- const TXYMap& aXYMap = aCurveVect[iLine];
- TXYMap::const_iterator aXYMapIter = aXYMap.find(aDist);
- if(aXYMapIter == aXYMap.end()) continue;
- float aVal = aXYMapIter->second;
- aTableOfReal->PutValue(aVal,iLine+2,i+1);
- }
- }
-
- aTableOfReal->SetRowTitle(1,"X");
- TLineCont::const_iterator aLineContIter = aLineCont.begin();
- QString aUnitName = myField->myUnitNames[0].c_str();
- if(myScalarMode != 0)
- aUnitName = myField->myUnitNames[myScalarMode-1].c_str();
- aUnitName = aUnitName.simplifyWhiteSpace();
- for(long i = 0; aLineContIter != aLineCont.end(); aLineContIter++, i++){
- long iLine = *aLineContIter;
- aString.sprintf("Y%d",iLine);
- aTableOfReal->SetRowTitle(i+2,aString.latin1());
- aTableOfReal->SetRowUnit(i+2,aUnitName.latin1());
- }
-}
-
-//==============================================================================
-int VISU::IsoSurfaces_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- return VISU::ScalarMap_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration);
-}
-
-int VISU::IsoSurfaces_i::myNbPresent = 0;
-QString VISU::IsoSurfaces_i::GenerateName() { return VISU::GenerateName("IsoSurfaces",myNbPresent++);}
-
-const string VISU::IsoSurfaces_i::myComment = "ISOSURFACES";
-const char* VISU::IsoSurfaces_i::GetComment() const { return myComment.c_str();}
-
-VISU::IsoSurfaces_i::IsoSurfaces_i(Result_i* theResult, bool theAddToStudy) :
- PrsObject_i(theResult->GetStudyDocument()),
- Prs3d_i(theResult),
- ScalarMap_i(theResult, theAddToStudy)
-{
- if(MYDEBUG) MESSAGE("IsoSurfaces_i::IsoSurfaces_i");
- myContourFilter = vtkContourFilter::New();
-}
-
-void VISU::IsoSurfaces_i::Destroy(){
- ScalarMap_i::Destroy();
-}
-
-void VISU::IsoSurfaces_i::SameAs(const IsoSurfaces_i* theOrigin) {
- IsoSurfaces_i* aIsoSurfaces = const_cast<IsoSurfaces_i*>(theOrigin);
- SetNbSurfaces(aIsoSurfaces->GetNbSurfaces());
- SetRange(aIsoSurfaces->GetRangeMin(), aIsoSurfaces->GetRangeMax());
- VISU::ScalarMap_i::SameAs(theOrigin);
-}
-
-VISU::Storable* VISU::IsoSurfaces_i::Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- myNbSurface = 10;
- myRange[0] = 0;
- myRange[1] = 0;
- return ScalarMap_i::Create(theMeshName,theEntity,theFieldName,theIteration);
-}
-
-VISU::Storable* VISU::IsoSurfaces_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding)
- throw(std::logic_error&)
-{
- ScalarMap_i::Restore(theMap,false);
-
- myNbSurface = VISU::Storable::FindValue(theMap,"myNbSurface").toInt();
- myRange[0] = VISU::Storable::FindValue(theMap,"myRange[0]").toDouble();
- myRange[1] = VISU::Storable::FindValue(theMap,"myRange[1]").toDouble();
-
- if(theBuilding)
- return Build(true);
- return NULL;
-}
-
-void VISU::IsoSurfaces_i::ToStream(std::ostringstream& theStr){
- ScalarMap_i::ToStream(theStr);
-
- Storable::DataToStream( theStr, "myNbSurface", myNbSurface );
- Storable::DataToStream( theStr, "myRange[0]", myRange[0] );
- Storable::DataToStream( theStr, "myRange[1]", myRange[1] );
-}
-
-VISU::Storable* VISU::IsoSurfacesRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&)
-{
- VISU::Result_i* pResult = GetResult(theSObject);
- if(pResult != NULL){
- VISU::IsoSurfaces_i* pResent = new VISU::IsoSurfaces_i(pResult);
- return pResent->Restore(theMap);
- }
- return NULL;
-}
-
-
-VISU::IsoSurfaces_i::~IsoSurfaces_i(){
- if(MYDEBUG) MESSAGE("IsoSurfaces_i::~IsoSurfaces_i()");
- myContourFilter->Delete();
-}
-
-void VISU::IsoSurfaces_i::SetRange(float theMin, float theMax){
- if(theMin <= theMax){
- myRange[0] = theMin; myRange[1] = theMax;
- }
-}
-
-VISU::ScalarMap_i::DataType* VISU::IsoSurfaces_i::DoHook(int theRestoring){
- if(MYDEBUG) MESSAGE("IsoSurfaces_i::DoHook() - myNbSurface = "<<myNbSurface);
- if(theRestoring == 0) {
- myRange[0] = myScalarRange[0];
- myRange[1] = myScalarRange[1];
- }
- Update();
- return myContourFilter->GetOutput();
-}
-
-
-void VISU::IsoSurfaces_i::Update(){
- if(myField->myEntity == VISU::CELL_ENTITY){
- vtkCellDataToPointData *aFilter = vtkCellDataToPointData::New();
- aFilter->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- aFilter->PassCellDataOn();
- myContourFilter->SetInput(aFilter->GetOutput());
- aFilter->Delete();
- } else
- myContourFilter->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- int aNbSurface = (int)(myMapScale*myNbSurface);
- if(aNbSurface < 1) aNbSurface = 1;
- if(GetScaling() == VISU::LOGARITHMIC){
- float aLogRange[2];
- VISU_LookupTable::ComputeLogRange(myRange,aLogRange);
- myContourFilter->GenerateValues(aNbSurface,aLogRange);
- }else
- myContourFilter->GenerateValues(aNbSurface,myRange);
- myMapper->ScalarVisibilityOn();
- VISU::ScalarMap_i::Update();
-}
-
-void VISU::IsoSurfaces_i::SetMapScale(double theMapScale){
- myMapScale = theMapScale;
- Update();
-}
-
-//==============================================================================
-int VISU::StreamLines_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- return DeformedShape_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration);
-}
-
-int VISU::StreamLines_i::myNbPresent = 0;
-QString VISU::StreamLines_i::GenerateName() { return VISU::GenerateName("StreamLines",myNbPresent++);}
-
-const string VISU::StreamLines_i::myComment = "STREAMLINES";
-const char* VISU::StreamLines_i::GetComment() const { return myComment.c_str();}
-
-VISU::StreamLines_i::StreamLines_i(Result_i* theResult, bool theAddToStudy) :
- PrsObject_i(theResult->GetStudyDocument()),
- Prs3d_i(theResult),
- ScalarMap_i(theResult, theAddToStudy),
- DeformedShape_i(theResult, theAddToStudy)
-{
- if(MYDEBUG) MESSAGE("StreamLines_i::StreamLines_i");
- myStream = vtkStreamLine::New();
-}
-
-void VISU::StreamLines_i::Destroy(){
- DeformedShape_i::Destroy();
-}
-
-VISU::Storable* VISU::StreamLines_i::Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration)
-{
- return DeformedShape_i::Create(theMeshName,theEntity,theFieldName,theIteration);
-}
-
-void VISU::StreamLines_i::SameAs(const StreamLines_i* theOrigin) {
- myPrs3di = NULL;
- StreamLines_i* aIsoLines = const_cast<StreamLines_i*>(theOrigin);
- SetDirection(aIsoLines->GetDirection());
- SetStepLength(aIsoLines->GetStepLength());
- SetIntegrationStep(aIsoLines->GetIntegrationStep());
- SetPropagationTime(aIsoLines->GetPropagationTime());
- VISU::DeformedShape_i::SameAs(theOrigin);
- SetUsedPoints(aIsoLines->GetUsedPoints());
-}
-
-VISU::Storable* VISU::StreamLines_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding)
- throw(std::logic_error&)
-{
- DeformedShape_i::Restore(theMap,false);
-
- myStepLength = VISU::Storable::FindValue(theMap,"myStepLength").toDouble();
- myIntegrationStep = VISU::Storable::FindValue(theMap,"myIntegrationStep").toDouble();
- myPropagationTime = VISU::Storable::FindValue(theMap,"myPropagationTime").toDouble();
- myDirection = (VISU::StreamLines::Direction) VISU::Storable::FindValue(theMap,"myDirection").toInt();
- mySourceEntry = VISU::Storable::FindValue(theMap,"mySourceEntry").latin1();
- myPercents = VISU::Storable::FindValue(theMap,"myPercents").toDouble();
- myPrs3di = NULL;
-
- if(theBuilding)
- return Build(true);
- return NULL;
-}
-
-void VISU::StreamLines_i::ToStream(std::ostringstream& theStr){
- DeformedShape_i::ToStream(theStr);
-
- Storable::DataToStream( theStr, "myStepLength", myStepLength );
- Storable::DataToStream( theStr, "myIntegrationStep", myIntegrationStep );
- Storable::DataToStream( theStr, "myPropagationTime", myPropagationTime );
- Storable::DataToStream( theStr, "myDirection", (int)myDirection );
- Storable::DataToStream( theStr, "mySourceEntry", mySourceEntry.c_str());
- Storable::DataToStream( theStr, "myPercents", myPercents );
-
-}
-
-VISU::Storable* VISU::StreamLinesRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&)
-{
- VISU::Result_i* pResult = GetResult(theSObject);
- if(pResult != NULL){
- VISU::StreamLines_i* pResent = new VISU::StreamLines_i(pResult);
- return pResent->Restore(theMap);
- }
- return NULL;
-}
-
-
-VISU::StreamLines_i::~StreamLines_i(){
- if(MYDEBUG) MESSAGE("StreamLines_i::~StreamLines_i()");
- myStream->Delete();
-}
-
-void VISU::StreamLines_i::SetSource(VISU::Prs3d_ptr thePrs3d){
- if(thePrs3d->_is_nil()) {
- myPrs3di = NULL;
- mySourceEntry = "";
- } else {
- myPrs3di = dynamic_cast<VISU::Prs3d_i*>(GetServant(thePrs3d));
- CORBA::String_var aString = thePrs3d->GetID();
- SALOMEDS::SObject_var aSObject = myStudy->FindObjectIOR(aString);
- aString = aSObject->GetID();
- mySourceEntry = aString.in();
- }
-}
-
-VISU::Prs3d_ptr VISU::StreamLines_i::GetSource(){
- VISU::Prs3d_var aPrs3d;
- if(MYDEBUG) MESSAGE("StreamLines_i::GetSource() mySourceEntry = '"<<mySourceEntry<<"'");
- if(mySourceEntry != ""){
- SALOMEDS::SObject_var aSObject = myStudy->FindObjectID(mySourceEntry.c_str());
- CORBA::Object_var anObj = SObjectToObject(aSObject);
- if(!CORBA::is_nil(anObj)){
- aPrs3d = VISU::Prs3d::_narrow(anObj);
- if(!aPrs3d->_is_nil())
- myPrs3di = dynamic_cast<VISU::Prs3d_i*>(GetServant(aPrs3d.in()));
- }
- }
- return aPrs3d._retn();
-}
-
-// in this method we calculate minimal width of the dataset
-// at least three integration steps could be in this width
-float VISU::StreamLines_i::GetMaxIntegrationStep() {
- float aMaxSizeY = fabs(myBounds[2] - myBounds[3]);
- float aMaxSizeZ = fabs(myBounds[4] - myBounds[5]);
- float aMinMax = fabs(myBounds[0] - myBounds[1]);
- if (aMinMax < 1.0e-20 || (aMaxSizeY < aMinMax && aMaxSizeY > 1.0e-20)) aMinMax = aMaxSizeY;
- if (aMinMax < 1.0e-20 || (aMaxSizeZ < aMinMax && aMaxSizeZ > 1.0e-20)) aMinMax = aMaxSizeZ;
- return aMinMax / 2.0;
-}
-
-float VISU::StreamLines_i::GetMinIntegrationStep() {
- float aVolume = 1;
- float degree = 0;
- if (fabs(myBounds[0] - myBounds[1]) > 1.0e-20 ) {
- aVolume *= fabs(myBounds[0] - myBounds[1]);
- degree+=1.0;
- }
- if (fabs(myBounds[2] - myBounds[3]) > 1.0e-20 ) {
- aVolume *= fabs(myBounds[2] - myBounds[3]);
- degree+=1.0;
- }
- if (fabs(myBounds[4] - myBounds[5]) > 1.0e-20 ) {
- aVolume *= fabs(myBounds[4] - myBounds[5]);
- degree+=1.0;
- }
- if (degree < 0.5) return 0.0; // absolutely empty object
- float anAverageVolume = aVolume / 1.0e+8; // we have to use no more, than 1GB memory (approx)
- return pow((double)(anAverageVolume), (double)(1.0 / degree));
-}
-
-float VISU::StreamLines_i::GetBasePropagationTime() {
- return myFieldTransform->GetUnstructuredGridOutput()->GetLength() / (GetMax() + GetMin()) * 2.0;
-}
-
-VISU::ScalarMap_i::DataType* VISU::StreamLines_i::DoHook(int theRestoring){
- if(theRestoring == 0){
- myDirection = VISU::StreamLines::BOTH;
- vtkDataSet *aDataSet = myFieldTransform->GetUnstructuredGridOutput();
- aDataSet->Update();
-
- myIntegrationStep = GetMaxIntegrationStep() / 10.0;
- float aMinMax = aDataSet->GetLength() /
- (sqrt((float)(aDataSet->GetNumberOfPoints() + aDataSet->GetNumberOfCells()))+1.0);
- if (aMinMax > myIntegrationStep) myIntegrationStep = (myIntegrationStep * 9.0 + aMinMax) / 10.0;
- if (myIntegrationStep < GetMinIntegrationStep()) myIntegrationStep = GetMinIntegrationStep();
-
- myPropagationTime = GetBasePropagationTime();
- myStepLength = myPropagationTime / 20.;
- if (myStepLength > myIntegrationStep * 2) myStepLength = myIntegrationStep * 2;
- if (myStepLength < myPropagationTime / 100.) myStepLength = myPropagationTime / 100.;
-
- myPrs3di = NULL;
- myPercents = 0.3;
- }
- Update();
- return myStream->GetOutput();
-}
-
-
-void SetStreamerSource(vtkStreamer *theStreamer, vtkDataSet* theDataSet,
- VISU::Prs3d_i* thePrs3di, float thePercents)
-{
- if(thePrs3di)
- theDataSet = thePrs3di->GetMapper()->GetInput();
- theDataSet->Modified();
- theDataSet->Update();
- vtkMaskPoints *aMaskPoints = vtkMaskPoints::New();
- aMaskPoints->SetInput(theDataSet);
- //aMaskPoints->RandomModeOn();
- int aNbPoints = (int)(theDataSet->GetNumberOfPoints()*thePercents);
- if(MYDEBUG) MESSAGE("SetStreamerSource aNbPoints = "<<theDataSet->GetNumberOfPoints()<<";\t"<<aNbPoints);
- aMaskPoints->SetMaximumNumberOfPoints(aNbPoints);
- theStreamer->SetSource(aMaskPoints->GetOutput());
- aMaskPoints->Delete();
-}
-
-void VISU::StreamLines_i::Update(){
- //apo - myStream->DebugOn();
- VISU::Prs3d_var aPrs3d = GetSource();
- if(myField->myNbComp > 1){
- myStream->SetStepLength(myStepLength);
- myStream->SetIntegrationStepLength(myIntegrationStep);
- myStream->SetMaximumPropagationTime(myPropagationTime);
- if(myField->myEntity == VISU::CELL_ENTITY){
- vtkCellDataToPointData *aFilter = vtkCellDataToPointData::New();
- aFilter->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- aFilter->PassCellDataOn();
- myStream->SetInput(aFilter->GetOutput());
- aFilter->Delete();
- vtkCellCenters *centers = vtkCellCenters::New(); // for vectors on cells
- centers->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- centers->VertexCellsOn();
- //myStream->SetSource(centers->GetOutput());
- SetStreamerSource(myStream,centers->GetOutput(),myPrs3di,myPercents);
- centers->Delete();
- }else{
- myStream->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- //myStream->SetSource(myFieldTransform->GetUnstructuredGridOutput());
- SetStreamerSource(myStream,myFieldTransform->GetUnstructuredGridOutput(),myPrs3di,myPercents);
- }
- switch (myDirection) {
- case VISU::StreamLines::FORWARD:
- myStream->SetIntegrationDirectionToForward();
- break;
- case VISU::StreamLines::BACKWARD:
- myStream->SetIntegrationDirectionToBackward();
- break;
- case VISU::StreamLines::BOTH:
- myStream->SetIntegrationDirectionToIntegrateBothDirections();
- }
- }
- myStream->Modified();
- VISU::DeformedShape_i::Update();
-}
-
-//==============================================================================
-int VISU::Vectors_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- return DeformedShape_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration);
-}
-
-int VISU::Vectors_i::myNbPresent = 0;
-QString VISU::Vectors_i::GenerateName() { return VISU::GenerateName("Vectors",myNbPresent++);}
-
-const string VISU::Vectors_i::myComment = "VECTORS";
-const char* VISU::Vectors_i::GetComment() const { return myComment.c_str();}
-
-VISU::Vectors_i::Vectors_i(Result_i* theResult, bool theAddToStudy) :
- PrsObject_i(theResult->GetStudyDocument()),
- Prs3d_i(theResult),
- ScalarMap_i(theResult, theAddToStudy),
- DeformedShape_i(theResult, theAddToStudy)
-{
- if(MYDEBUG) MESSAGE("Vectors_i::Vectors_i");
- myGlyph = vtkGlyph3D::New();
- myHog = vtkHedgeHog::New();
-}
-
-void VISU::Vectors_i::Destroy(){
- DeformedShape_i::Destroy();
-}
-
-void VISU::Vectors_i::SameAs(const VISU::Vectors_i* theOrigin) {
- Vectors_i* aVectors = const_cast<Vectors_i*>(theOrigin);
- SetLineWidth(aVectors->GetLineWidth());
- SetGlyphType(aVectors->GetGlyphType());
- SetGlyphPos(aVectors->GetGlyphPos());
- VISU::DeformedShape_i::SameAs(theOrigin);
-}
-
-VISU::Storable* VISU::Vectors_i::Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration){
- myLineWidth = 1.0;
- myTypeGlyph = VISU::Vectors::ARROW;
- myPosGlyph = VISU::Vectors::CENTER;
- return DeformedShape_i::Create(theMeshName,theEntity,theFieldName,theIteration);
-}
-
-VISU::Storable* VISU::Vectors_i::Restore(const Storable::TRestoringMap& theMap, int theBuilding)
- throw(std::logic_error&)
-{
- DeformedShape_i::Restore(theMap,false);
-
- myTypeGlyph = (VISU::Vectors::GlyphType)VISU::Storable::FindValue(theMap,"myTypeGlyph").toInt();
- myLineWidth = VISU::Storable::FindValue(theMap,"myLineWidth").toDouble();
- myPosGlyph = (VISU::Vectors::GlyphPos)VISU::Storable::FindValue(theMap,"myPosGlyph").toInt();
-
- if(theBuilding)
- return Build(true);
- return NULL;
-}
-
-void VISU::Vectors_i::ToStream(std::ostringstream& theStr){
- DeformedShape_i::ToStream(theStr);
-
- Storable::DataToStream( theStr, "myTypeGlyph", myTypeGlyph );
- Storable::DataToStream( theStr, "myLineWidth", myLineWidth );
- Storable::DataToStream( theStr, "myPosGlyph", myPosGlyph );
-}
-
-VISU::Storable* VISU::VectorsRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&)
-{
- VISU::Result_i* pResult = GetResult(theSObject);
- if(pResult != NULL){
- VISU::Vectors_i* pResent = new VISU::Vectors_i(pResult);
- return pResent->Restore(theMap);
- }
- return NULL;
-}
-
-
-VISU::ScalarMap_i::DataType* VISU::Vectors_i::DoHook(int theRestoring){
- if(theRestoring == 0){
- myTypeGlyph = VISU::Vectors::ARROW;
- myLineWidth = 1;
- myPosGlyph = VISU::Vectors::TAIL;
- myFactor = ScaleFactor()/GetMax();
- }
- if(MYDEBUG)
- MESSAGE("Vectors_i::DoHook() - myFactor = "<<myFactor<<"; myTypeGlyph = "<<myTypeGlyph<<
- "; myLineWidth = "<<myLineWidth<<"; myPosGlyph = "<<myPosGlyph);
- Update();
- if (myTypeGlyph == VISU::Vectors::NONE) return myHog->GetOutput();
- return myGlyph->GetOutput();
-}
-
-VISU::Vectors_i::~Vectors_i(){
- if(MYDEBUG) MESSAGE("Vectors_i::~Vectors_i()");
- myGlyph->Delete();
- myHog->Delete();
-}
-
-void VISU::Vectors_i::Update() {
- switch (myTypeGlyph) {
- case VISU::Vectors::ARROW:
- {
- vtkGlyphSource2D *aGlyphSource = vtkGlyphSource2D::New();
- aGlyphSource->SetGlyphTypeToArrow();
- aGlyphSource->SetFilled(0);
- if(myPosGlyph == VISU::Vectors::TAIL)
- aGlyphSource->SetCenter(0.5, 0.0, 0.0);
- else if(myPosGlyph == VISU::Vectors::HEAD)
- aGlyphSource->SetCenter(-0.5, 0.0, 0.0);
- myGlyph->SetSource(aGlyphSource->GetOutput());
- aGlyphSource->Delete();
- }
- break;
-
- case VISU::Vectors::CONE2:
- case VISU::Vectors::CONE6:
- {
- vtkConeSource *aGlyphSource = vtkConeSource::New(); //by default
- if (myTypeGlyph == VISU::Vectors::CONE6)
- aGlyphSource->SetResolution(7);
- else
- aGlyphSource->SetResolution(3);
- aGlyphSource->SetHeight(1.0);
- aGlyphSource->SetRadius(.1);
- vtkTransform *aTransform = vtkTransform::New();
-
- if(myPosGlyph == VISU::Vectors::TAIL)
- aGlyphSource->SetCenter(0.5, 0.0, 0.0);
- else if(myPosGlyph == VISU::Vectors::HEAD)
- aGlyphSource->SetCenter(-0.5, 0.0, 0.0);
-
- vtkTransformPolyDataFilter *aFilter = vtkTransformPolyDataFilter::New();
- aFilter->SetInput(aGlyphSource->GetOutput());
- aGlyphSource->Delete();
- aFilter->SetTransform(aTransform);
- aTransform->Delete();
- myGlyph->SetSource(aGlyphSource->GetOutput());
- aFilter->Delete();
- }
- break;
- case VISU::Vectors::NONE:
- {
- if(myField->myEntity == VISU::CELL_ENTITY){
- vtkCellCenters *centers = vtkCellCenters::New(); // for vectors on cells
- centers->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- centers->VertexCellsOn();
- myHog->SetInput(centers->GetOutput());
- centers->Delete();
- }else
- myHog->SetInput(myFieldTransform->GetInput());
-
- myHog->SetScaleFactor(myFactor);
- myHog->Update();
- myMapper->SetInput(myHog->GetOutput());
- myMapper->Update();
- return;
- }
- }
- if(myField->myNbComp > 1){
- if(myField->myEntity == VISU::CELL_ENTITY){
- vtkCellCenters *centers = vtkCellCenters::New(); // for vectors on cells
- centers->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- centers->VertexCellsOn();
- myGlyph->SetInput(centers->GetOutput());
- centers->Delete();
- }else
- myGlyph->SetInput(myFieldTransform->GetUnstructuredGridOutput());
- myGlyph->SetVectorModeToUseVector();
- myGlyph->SetScaleModeToScaleByVector();
- //myGlyph->SetColorModeToColorByVector();
- myGlyph->SetColorModeToColorByScalar();
- myGlyph->SetScaleFactor(2*myFactor);
- }
- myGlyph->Modified();
- VISU::DeformedShape_i::Update();
-}
-
-VISU_Actor* VISU::Vectors_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO) {
- VISU_Actor* anActor = VISU::DeformedShape_i::CreateActor(theIO);
- return anActor;
-}
-
-void VISU::Vectors_i::UpdateActor(VISU_Actor* theActor) {
- VISU::DeformedShape_i::UpdateActor(theActor);
- theActor->GetProperty()->SetLineWidth(myLineWidth);
- theActor->GetProperty()->SetRepresentation(2);
- theActor->SetShrinkable(false);
-}
-
-//==============================================================================
-
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
// File : VISU_PrsObject_i.hxx
#ifndef VISU_PrsObject_i_HeaderFile
#define VISU_PrsObject_i_HeaderFile
-#include "VISU_Result_i.hh"
-//#include "VISU_Convertor.hxx"
-#include "Handle_SALOME_InteractiveObject.hxx"
-
-class VISU_Extractor;
-class VISU_FieldTransform;
-class VISU_ScalarBarActor;
-class VISU_LookupTable;
-class VISU_Actor;
-
-class vtkDataSetMapper;
-class vtkDataSet;
-class vtkProperty;
-
-class vtkPolyDataMapper;
-class vtkPolyData;
-class vtkGeometryFilter;
-
-class vtkWarpVector;
-class vtkContourFilter;
-class vtkAppendPolyData;
-
-class vtkGlyph3D;
-class vtkHedgeHog;
-class vtkPolyDataSource;
-class vtkStreamLine;
+#include "VISUConfig.hh"
namespace VISU{
- struct TField;
- //==============================================================================
class PrsObject_i : public virtual POA_VISU::PrsObject,
public virtual Storable
{
PrsObject_i(const PrsObject_i&);
public:
- PrsObject_i(SALOMEDS::Study_ptr theStudy) :
- myStudy(SALOMEDS::Study::_duplicate(theStudy)) {};
+ PrsObject_i(SALOMEDS::Study_ptr theStudy) : myStudy(SALOMEDS::Study::_duplicate(theStudy)) {};
virtual ~PrsObject_i() {}
protected:
- string myName;
+ std::string myName;
SALOMEDS::Study_var myStudy;
public:
const SALOMEDS::Study_var& GetStudyDocument() const { return myStudy;}
QString GetEntry();
};
-
-
- //==============================================================================
- class Prs3d_i : public virtual POA_VISU::Prs3d,
- public virtual PrsObject_i
- {
- Prs3d_i();
- Prs3d_i(const Prs3d_i&);
- public:
- Prs3d_i(Result_i* theResult);
- virtual void SameAs(const Prs3d_i* theOrigin);
- virtual ~Prs3d_i();
- virtual void Destroy();
-
- typedef vtkPolyDataMapper MapperType;
- typedef vtkDataSet DataType;
-
- virtual SALOMEDS::Color GetColor() { return myColor;}
- virtual void SetColor(const SALOMEDS::Color& theColor);
-
- protected:
- Result_i* myResult;
- MapperType *myMapper;
- vtkGeometryFilter *myGeomFilter;
- float myBounds[6];
- struct SALOMEDS::Color myColor;
-
- bool myAddToStudy;
- bool CreateActor(VISU_Actor* theActor, const Handle(SALOME_InteractiveObject)& theIO = NULL);
-
- public:
- virtual void Update();
- virtual const char* GetComment() const = 0;
- virtual QString GenerateName() = 0;
- virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true)
- throw(std::logic_error&);
- virtual void ToStream(std::ostringstream& theStr);
- virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL) = 0;
- virtual void UpdateActor(VISU_Actor* theActor);
- MapperType* GetMapper() const { return myMapper;}
- Result_i* GetResult() const { return myResult; }
- };
-
-
- //==============================================================================
- class Mesh_i : public virtual POA_VISU::Mesh,
- public virtual Prs3d_i
- {
- static int myNbPresent;
- Mesh_i();
- Mesh_i(const Mesh_i&);
- public:
- Mesh_i(Result_i* theResult);
- virtual void SameAs(const Mesh_i* theOrigin);
- virtual ~Mesh_i();
- virtual void Destroy();
-
- virtual VISU::VISUType GetType() { return VISU::TMESH;};
-
- virtual void SetCellColor(const SALOMEDS::Color& theColor) { SetColor(theColor);}
- virtual SALOMEDS::Color GetCellColor() { return GetColor();}
-
- virtual void SetNodeColor(const SALOMEDS::Color& theColor) { myNodeColor = theColor;}
- virtual SALOMEDS::Color GetNodeColor() { return myNodeColor;}
-
- virtual void SetLinkColor(const SALOMEDS::Color& theColor) { myLinkColor = theColor;}
- virtual SALOMEDS::Color GetLinkColor() { return myLinkColor;}
-
- virtual void SetPresentationType(VISU::PresentationType theType) { myPresentType = theType;}
- virtual PresentationType GetPresentationType() { return myPresentType;}
-
- typedef VISU::Mesh InterfaceType;
- typedef vtkUnstructuredGridReader InputType;
-
- protected:
- Storable* Build(int theRestoring);
-
- InputType *myInput;
- VISU::VISUType myType;
- string myMeshName;
- int myEntity;
- string mySubMeshName;
- struct SALOMEDS::Color myNodeColor, myLinkColor;
- VISU::PresentationType myPresentType;
-
- public:
- virtual Storable* Create(const char* theMeshName, int theEntity);
- virtual Storable* Create(const char* theMeshName, int theEntity, const char* theFamilyName);
- virtual Storable* Create(const char* theMeshName, const char* theGroupName);
- virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true)
- throw(std::logic_error&);
- virtual void ToStream(std::ostringstream& theStr);
- static const string myComment;
- virtual const char* GetComment() const;
- virtual QString GenerateName();
- virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL);
- virtual void UpdateActor(VISU_Actor* theActor);
- virtual InputType* GetInput() const { return myInput;}
- };
- Storable* MeshRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&);
-
-
- //==============================================================================
- class ScalarMap_i : public virtual POA_VISU::ScalarMap,
- public virtual Prs3d_i
- {
- static int myNbPresent;
- ScalarMap_i();
- ScalarMap_i(const ScalarMap_i&);
-
- public:
- ScalarMap_i(Result_i* theResult, bool theAddToStudy = true);
- virtual void SameAs(const ScalarMap_i* theOrigin);
- virtual ~ScalarMap_i();
- virtual void Destroy();
-
- virtual VISU::VISUType GetType() { return VISU::TSCALARMAP;};
-
- virtual void SetScalarMode(CORBA::Long theScalarMode);
- virtual CORBA::Long GetScalarMode() { return myScalarMode;}
-
- virtual void SetScaling(VISU::Scaling theScaling);
- virtual VISU::Scaling GetScaling();
-
- virtual void SetRange(CORBA::Double theMin, CORBA::Double theMax);
- virtual CORBA::Double GetMin() { return myScalarRange[0];}
- virtual CORBA::Double GetMax() { return myScalarRange[1];}
-
- virtual void SetOrientation(VISU::ScalarMap::Orientation theOrientation) {
- myOrientation = theOrientation;
- }
- virtual VISU::ScalarMap::Orientation GetOrientation() { return myOrientation;}
-
- virtual void SetPosition(CORBA::Double X, CORBA::Double Y) { myPosition[0] = X; myPosition[1] = Y;}
- virtual CORBA::Double GetPosX() { return myPosition[0];}
- virtual CORBA::Double GetPosY() { return myPosition[1];}
-
- virtual void SetSize(CORBA::Double theWidth, CORBA::Double theHeight) {
- myWidth = theWidth; myHeight = theHeight;
- }
- virtual CORBA::Double GetWidth() { return myWidth;}
- virtual CORBA::Double GetHeight() { return myHeight;}
-
- virtual void SetNbColors(CORBA::Long theNbColors) { myNumberOfColors = theNbColors;}
- virtual CORBA::Long GetNbColors() { return myNumberOfColors;}
-
- virtual void SetLabels(CORBA::Long theNbLabels) { myNumberOfLabels = theNbLabels;}
- virtual CORBA::Long GetLabels() { return myNumberOfLabels;}
-
- virtual void SetTitle(const char* theName) { myTitle = theName;}
- virtual char* GetTitle() { return CORBA::string_dup(myTitle.c_str());}
-
- virtual void CalculateRange();
- virtual void GetFieldRange(float theRange[2]);
- virtual bool isRangeFixed() { return myIsFixedRange; }
-
- virtual double GetIteration() { return myIteration; }
-
- typedef VISU::ScalarMap InterfaceType;
- typedef VISU_Extractor InputType;
-
- protected:
- Storable* Build(int theRestoring);
- virtual DataType* DoHook(int theRestoring);
-
- InputType *myInput;
-
- string myMeshName;
- int myEntity;
- string myFieldName;
- int myScalarMode;
- double myIteration;
- VISU_LookupTable *myMapperTable, *myBarTable;
- VISU_FieldTransform *myFieldTransform;
- const TField* myField;
-
- float myScalarRange[2];
- bool myIsFixedRange;
- bool myIsColored;
- VISU::Scaling myScaling;
- float myMapScale;
-
- string myTitle;
- VISU::ScalarMap::Orientation myOrientation;
- int myNumberOfColors, myNumberOfLabels;
- float myPosition[2], myWidth, myHeight;
-
- public:
- virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true)
- throw(std::logic_error&);
- static const string myComment;
- virtual const char* GetComment() const;
- virtual QString GenerateName();
- virtual void ToStream(std::ostringstream& theStr);
- static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- InputType* GetInput() { return myInput;}
-
- virtual void Update();
- const VISU::TField* GetField() const { return myField;}
- const string& GetFieldName() const { return myFieldName;}
- int GetScalarMode() const { return myScalarMode;}
- virtual void SetMapScale(double theMapScale = 1.0);
-
- virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL);
- virtual void UpdateActor(VISU_Actor* theActor);
- };
- Storable* ScalarMapRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&);
-
-
- //==============================================================================
- class DeformedShape_i : public virtual POA_VISU::DeformedShape,
- public virtual ScalarMap_i
- {
- static int myNbPresent;
- DeformedShape_i();
- DeformedShape_i(const DeformedShape_i&);
- public:
- DeformedShape_i(Result_i* theResult, bool theAddToStudy = true);
- virtual void SameAs(const DeformedShape_i* theOrigin);
- virtual ~DeformedShape_i();
- virtual void Destroy();
-
- virtual VISU::VISUType GetType() { return VISU::TDEFORMEDSHAPE;};
-
- virtual void SetScale(CORBA::Double theScale) { myFactor = theScale;}
- virtual CORBA::Double GetScale() { return myFactor;}
-
- typedef VISU::DeformedShape InterfaceType;
-
- virtual bool isColored() { return myIsColored; }
- virtual void setColored(bool theColor) { myIsColored = theColor; }
- virtual void SetColor(const SALOMEDS::Color& theColor);
-
- protected:
- virtual DataType* DoHook(int theRestoring);
- float myFactor;
- vtkWarpVector *myWarpVector;
-
- public:
- virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true)
- throw(std::logic_error&);
- static const string myComment;
- virtual const char* GetComment() const;
- virtual QString GenerateName();
- virtual void Update();
- virtual void ToStream(std::ostringstream& theStr);
- static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- float ScaleFactor();
- virtual void SetMapScale(double theMapScale = 1.0);
-
- virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL);
- virtual void UpdateActor(VISU_Actor* theActor);
- };
- Storable* DeformedShapeRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&);
-
-
-
-
- //==============================================================================
- class CutPlanes_i : public virtual POA_VISU::CutPlanes,
- public virtual ScalarMap_i
- {
- static int myNbPresent;
- CutPlanes_i();
- CutPlanes_i(const CutPlanes_i&);
- public:
- CutPlanes_i(Result_i* theResult, bool theAddToStudy = true);
- virtual void SameAs(const CutPlanes_i* theOrigin);
- virtual ~CutPlanes_i();
- virtual void Destroy();
-
- virtual VISU::VISUType GetType() { return VISU::TCUTPLANES;};
-
- virtual void SetOrientationType(VISU::CutPlanes::Orientation theOrient) {
- myBasePlane = theOrient;
- }
- virtual VISU::CutPlanes::Orientation GetOrientationType() { return myBasePlane;}
-
- virtual void SetDisplacement(CORBA::Double theDisp) { myDisplacement = theDisp;}
- virtual CORBA::Double GetDisplacement() { return myDisplacement;}
-
- virtual void SetNbPlanes(CORBA::Long theNb) { myNbPlanes = theNb;}
- virtual CORBA::Long GetNbPlanes() { return myNbPlanes;}
-
- virtual void SetRotateX(CORBA::Double theAngle);
- virtual CORBA::Double GetRotateX();
- virtual void SetRotateY(CORBA::Double theAngle);
- virtual CORBA::Double GetRotateY();
-
- typedef VISU::CutPlanes InterfaceType;
-
- protected:
- virtual DataType* DoHook(int theRestoring);
-
- int myNbPlanes;
- float myAng[3], myDisplacement;
- vtkAppendPolyData *myAppendPolyData;
- VISU::CutPlanes::Orientation myBasePlane;
-
- public:
- virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true)
- throw(std::logic_error&);
- static const string myComment;
- virtual const char* GetComment() const;
- virtual QString GenerateName();
- virtual void Update();
- virtual void ToStream(std::ostringstream& theStr);
- static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- void SetPlane(int theId);
- };
- Storable* CutPlanesRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&);
-
-
-
- //==============================================================================
- class CutLines_i : public virtual POA_VISU::CutLines,
- public virtual ScalarMap_i
- {
- static int myNbPresent;
- CutLines_i();
- CutLines_i(const CutPlanes_i&);
- public:
- CutLines_i(Result_i* theResult, bool theAddToStudy = true);
- virtual void SameAs(const CutLines_i* theOrigin);
- virtual ~CutLines_i();
- virtual void Destroy();
-
- virtual VISU::VISUType GetType() { return VISU::TCUTLINES;};
-
- virtual void SetOrientationType(VISU::CutPlanes::Orientation theOrient) {
- myBasePlane[0] = theOrient;
- }
- virtual VISU::CutPlanes::Orientation GetOrientationType() { return myBasePlane[0];}
-
- virtual void SetOrientationType2(VISU::CutPlanes::Orientation theOrient) {
- myBasePlane[1] = theOrient;
- }
- virtual VISU::CutPlanes::Orientation GetOrientationType2() { return myBasePlane[1];}
-
- virtual void SetDisplacement(CORBA::Double theDisp) { myDisplacement[0] = theDisp;}
- virtual CORBA::Double GetDisplacement() { return myDisplacement[0];}
- virtual void SetDisplacement2(CORBA::Double theDisp) { myDisplacement[1] = theDisp;}
- virtual CORBA::Double GetDisplacement2() { return myDisplacement[1];}
-
- virtual void SetNbLines(CORBA::Long theNb) { myNbLines = theNb;}
- virtual CORBA::Long GetNbLines() { return myNbLines;}
-
- virtual void SetRotateX(CORBA::Double theAngle);
- virtual CORBA::Double GetRotateX();
- virtual void SetRotateY(CORBA::Double theAngle);
- virtual CORBA::Double GetRotateY();
-
- virtual void SetRotateX2(CORBA::Double theAngle);
- virtual CORBA::Double GetRotateX2();
- virtual void SetRotateY2(CORBA::Double theAngle);
- virtual CORBA::Double GetRotateY2();
-
- typedef VISU::CutLines InterfaceType;
-
- protected:
- virtual DataType* DoHook(int theRestoring);
-
- int myNbLines;
- vtkAppendPolyData *myAppendPolyData;
- float myAng[2][3], myDisplacement[2];
- VISU::CutPlanes::Orientation myBasePlane[2];
- float myDirLn[3], myBoundPrjLn[3], myBasePnt[3];
-
- public:
- virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true)
- throw(std::logic_error&);
- void BuildTableOfReal(SALOMEDS::SObject_ptr theSObject);
- static const string myComment;
- virtual const char* GetComment() const;
- virtual QString GenerateName();
- virtual void Update();
- virtual void ToStream(std::ostringstream& theStr);
- static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- };
- Storable* CutLinesRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&);
-
-
-
- //==============================================================================
- class IsoSurfaces_i : public virtual POA_VISU::IsoSurfaces,
- public virtual ScalarMap_i
- {
- static int myNbPresent;
- IsoSurfaces_i();
- IsoSurfaces_i(const IsoSurfaces_i&);
- public:
- IsoSurfaces_i(Result_i* theResult, bool theAddToStudy = true);
- virtual void SameAs(const IsoSurfaces_i* theOrigin);
- virtual ~IsoSurfaces_i();
- virtual void Destroy();
-
- virtual VISU::VISUType GetType() { return VISU::TISOSURFACE;};
-
- virtual void SetNbSurfaces(CORBA::Long theNb) { myNbSurface = theNb;}
- virtual CORBA::Long GetNbSurfaces() { return myNbSurface;}
-
- virtual void SetRange(float theMin, float theMax);
- virtual float GetRangeMin() { return myRange[0]; }
- virtual float GetRangeMax() { return myRange[1]; }
-
- typedef VISU::IsoSurfaces InterfaceType;
-
- protected:
- virtual DataType* DoHook(int theRestoring);
-
- vtkContourFilter *myContourFilter;
- int myNbSurface;
- float myRange[2];
-
- public:
- virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true)
- throw(std::logic_error&);
- static const string myComment;
- virtual const char* GetComment() const;
- virtual QString GenerateName();
- virtual void Update();
- virtual void ToStream(std::ostringstream& theStr);
- static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- virtual void SetMapScale(double theMapScale = 1.0);
- };
- Storable* IsoSurfacesRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&);
-
-
-
- //==============================================================================
- class StreamLines_i : public virtual POA_VISU::StreamLines,
- public virtual DeformedShape_i
- {
- static int myNbPresent;
- StreamLines_i();
- StreamLines_i(const StreamLines_i&);
- public:
- StreamLines_i(Result_i* theResult, bool theAddToStudy = true);
- virtual void SameAs(const StreamLines_i* theOriginal);
- virtual ~StreamLines_i();
- virtual void Destroy();
-
- virtual VISU::VISUType GetType() { return VISU::TSTREAMLINES;}
-
- typedef VISU::StreamLines InterfaceType;
-
- virtual void SetDirection(VISU::StreamLines::Direction theDirection)
- { myDirection = theDirection; }
- virtual VISU::StreamLines::Direction GetDirection() { return myDirection;}
-
- virtual void SetStepLength(CORBA::Double theStep) { myStepLength = theStep; }
- virtual CORBA::Double GetStepLength() { return myStepLength; }
-
- virtual void SetPropagationTime(CORBA::Double theTime) { myPropagationTime = theTime; }
- virtual CORBA::Double GetPropagationTime() { return myPropagationTime; }
-
- virtual void SetIntegrationStep(CORBA::Double theStep) { myIntegrationStep = theStep; }
- virtual CORBA::Double GetIntegrationStep() { return myIntegrationStep; }
-
- virtual void SetSource(VISU::Prs3d_ptr thePrs3d);
- virtual VISU::Prs3d_ptr GetSource();
-
- virtual void SetUsedPoints(CORBA::Double thePercents) { myPercents = thePercents; }
- virtual CORBA::Double GetUsedPoints() { return myPercents; }
-
- protected:
- virtual DataType* DoHook(int theRestoring);
- vtkStreamLine* myStream;
-
- VISU::StreamLines::Direction myDirection;
- float myStepLength;
- float myIntegrationStep;
- float myPropagationTime;
- string mySourceEntry;
- VISU::Prs3d_i* myPrs3di;
- float myPercents;
-
- public:
- virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true)
- throw(std::logic_error&);
- static const string myComment;
- virtual const char* GetComment() const;
- virtual QString GenerateName();
-
- virtual float GetMinIntegrationStep();
- virtual float GetMaxIntegrationStep();
- virtual float GetBasePropagationTime();
-
- virtual void Update();
- virtual QString GetSourceEntry() { return QString(mySourceEntry.c_str()); }
- virtual void ToStream(std::ostringstream& theStr);
- static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- };
- Storable* StreamLinesRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&);
-
-
- //==============================================================================
- class Vectors_i : public virtual POA_VISU::Vectors,
- public virtual DeformedShape_i
- {
- static int myNbPresent;
- Vectors_i();
- Vectors_i(const Vectors_i&);
- public:
- Vectors_i(Result_i* theResult, bool theAddToStudy = true);
- virtual void SameAs(const Vectors_i* theOrigin);
- virtual ~Vectors_i();
- virtual void Destroy();
-
- virtual VISU::VISUType GetType() { return VISU::TVECTORS;};
-
- virtual void SetLineWidth(CORBA::Double theWidth) { myLineWidth = theWidth;}
- virtual CORBA::Double GetLineWidth() { return myLineWidth;}
-
- virtual void SetGlyphType(VISU::Vectors::GlyphType theType) { myTypeGlyph = theType;}
- virtual VISU::Vectors::GlyphType GetGlyphType() { return myTypeGlyph;}
-
- virtual void SetGlyphPos(VISU::Vectors::GlyphPos thePos) { myPosGlyph = thePos;}
- virtual VISU::Vectors::GlyphPos GetGlyphPos() { return myPosGlyph;}
-
- typedef VISU::Vectors InterfaceType;
-
- protected:
- virtual DataType* DoHook(int theRestoring);
-
- float myLineWidth;
- VISU::Vectors::GlyphType myTypeGlyph;
- VISU::Vectors::GlyphPos myPosGlyph;
- vtkGlyph3D *myGlyph;
- vtkHedgeHog *myHog;
-
- public:
- virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- virtual Storable* Restore(const Storable::TRestoringMap& theMap, int theBuilding = true)
- throw(std::logic_error&);
- static const string myComment;
- virtual const char* GetComment() const;
- virtual QString GenerateName();
- virtual void Update();
- virtual void ToStream(std::ostringstream& theStr);
- static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
- const char* theFieldName, double theIteration);
- virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL);
- virtual void UpdateActor(VISU_Actor* theActor);
- };
- Storable* VectorsRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&);
- //==============================================================================
}
+
#endif
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
// File : VISU_Result_i.cc
// Author : Alexey PETROV
// Module : VISU
-using namespace std;
#include "VISU_Result_i.hh"
#include "VISU_Convertor_impl.hxx"
#include "VISU_CorbaMedConvertor.hxx"
-#include "VISU_Extractor.hxx"
-using namespace VISU;
+#include "QAD_Config.h"
#include "SALOMEDS_Tool.hxx"
#include "HDFascii.hxx"
#include <vtkUnstructuredGridReader.h>
#include <vtkUnstructuredGridWriter.h>
+using namespace VISU;
using namespace std;
-#ifdef DEBUG
+#ifdef _DEBUG_
static int MYDEBUG = 0;
static int MYDEBUGWITHFILES = 0;
#else
return aResult;
}
-QString VISU::GenerateName(const string& theFmt, int theId){
- static QString aName;
- if(theId > 0)
- aName.sprintf("%s:%d",theFmt.c_str(),theId);
- else
- aName.sprintf("%s",theFmt.c_str());
- return aName;
-}
-
-void VISU::WriteToFile(vtkUnstructuredGrid* theDataSet, const string& theFileName){
- vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
- aWriter->SetFileName(theFileName.c_str());
- aWriter->SetInput(theDataSet);
- aWriter->Write();
- aWriter->Delete();
-}
-
QString GenerateName(const char* theName){
typedef map<string,int> TNameMap;
static TNameMap aMap;
VISU::Result_i::Result_i(SALOMEDS::Study_ptr theStudy) {
myStudyDocument = SALOMEDS::Study::_duplicate(theStudy);
myInput = NULL;
+ myIsDone = 0;
+}
+
+CORBA::Boolean VISU::Result_i::BuildAll(){
+ if(MYDEBUG) MESSAGE("Result_i::Build - myIsDone = "<<myIsDone);
+ if(myIsDone) return 1;
+ try{
+ const VISU::TMeshMap& aMeshMap = myInput->GetMeshMap();
+ VISU::TMeshMap::const_iterator aMeshMapIter = aMeshMap.begin();
+ for(; aMeshMapIter != aMeshMap.end(); aMeshMapIter++){
+ const string& aMeshName = aMeshMapIter->first;
+ const VISU::TMesh& aMesh = aMeshMapIter->second;
+ const VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh.myMeshOnEntityMap;
+ VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter;
+ //Import fields
+ aMeshOnEntityMapIter = aMeshOnEntityMap.begin();
+ for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){
+ const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first;
+ const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second;
+ const VISU::TFieldMap& aFieldMap = aMeshOnEntity.myFieldMap;
+ VISU::TFieldMap::const_iterator aFieldMapIter = aFieldMap.begin();
+ for(; aFieldMapIter != aFieldMap.end(); aFieldMapIter++){
+ const string& aFieldName = aFieldMapIter->first;
+ const VISU::TField& aField = aFieldMapIter->second;
+ const VISU::TField::TValField& aValField = aField.myValField;
+ VISU::TField::TValField::const_iterator aValFieldIter = aValField.begin();
+ for(; aValFieldIter != aValField.end(); aValFieldIter++){
+ int aTimeStamp = aValFieldIter->first;
+ myInput->GetTimeStampOnMesh(aMeshName,anEntity,aFieldName,aTimeStamp);
+ }
+ }
+ }
+ //Importing groups
+ const VISU::TGroupMap& aGroupMap = aMesh.myGroupMap;
+ VISU::TGroupMap::const_iterator aGroupMapIter = aGroupMap.begin();
+ for(; aGroupMapIter != aGroupMap.end(); aGroupMapIter++){
+ const string& aGroupName = aGroupMapIter->first;
+ myInput->GetMeshOnGroup(aMeshName,aGroupName);
+ }
+ //Import families
+ aMeshOnEntityMapIter = aMeshOnEntityMap.begin();
+ for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){
+ const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first;
+ const VISU::TMeshOnEntity& aMeshOnEntity = aMeshOnEntityMapIter->second;
+ const VISU::TFamilyMap& aFamilyMap = aMeshOnEntity.myFamilyMap;
+ VISU::TFamilyMap::const_iterator aFamilyMapIter = aFamilyMap.begin();
+ for(; aFamilyMapIter != aFamilyMap.end(); aFamilyMapIter++){
+ const string& aFamilyName = aFamilyMapIter->first;
+ myInput->GetMeshOnEntity(aMeshName,anEntity,aFamilyName);
+ }
+ }
+ //Import mesh on entity
+ aMeshOnEntityMapIter = aMeshOnEntityMap.begin();
+ for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++){
+ const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first;
+ myInput->GetMeshOnEntity(aMeshName,anEntity);
+ }
+ }
+ myIsDone = 1;
+ }catch(std::runtime_error& exc){
+ INFOS("Follow exception was accured :\n"<<exc.what());
+ }catch(...){
+ INFOS("Unknown exception was accured!");
+ }
+ return myIsDone;
}
VISU::Storable* VISU::Result_i::Build(SALOMEDS::SObject_ptr theSObject)
anIOR,myName.c_str(),"",aComment.latin1(),true);
mySObject = myStudyDocument->FindObjectID(aResultEntry.c_str());
if(mySObject->_is_nil()) throw std::runtime_error("Build - There is no SObject for the Result !!!");
- if(theSObject != NULL){
+ if(!CORBA::is_nil(theSObject)){
CORBA::String_var aString = theSObject->GetID();
CreateReference(myStudyDocument,aResultEntry,aString.in());
}
}
}
}
+ QString aIsBuild = QAD_CONFIG->getSetting("Visu:BuildResult");
+ if(aIsBuild.isEmpty()? 0 : aIsBuild.toInt()) BuildAll();
return this;
}
myInput = CreateConvertor(theFileName);
if(myInput == NULL) return NULL;
myFileInfo.setFile(theFileName);
- myName = (const char*)(::GenerateName(myFileInfo.fileName().latin1()));
+ myName = ::GenerateName(myFileInfo.fileName()).latin1();
VISU::Storable* aStorable = Build();
return aStorable;
}catch(std::runtime_error& exc){
- MESSAGE("Follow exception was accured :\n"<<exc.what());
+ INFOS("Follow exception was accured :\n"<<exc.what());
}catch(...){
- MESSAGE("Unknown exception was accured!");
+ INFOS("Unknown exception was accured!");
}
return NULL;
}
if(myInput == NULL) return NULL;
string aCompDataType = GetComponentDataType(theMedSObject);
myFileInfo.setFile(aCompDataType.c_str());
- myName = (const char*)(::GenerateName("aResult"));
+ myName = ::GenerateName("aResult").latin1();
VISU::Storable* aStorable = Build(theMedSObject);
return aStorable;
}catch(std::runtime_error& exc){
- MESSAGE("Follow exception was accured :\n"<<exc.what());
+ INFOS("Follow exception was accured :\n"<<exc.what());
}catch(...){
- MESSAGE("Unknown exception was accured!");
+ INFOS("Unknown exception was accured!");
}
return NULL;
}
if(myInput == NULL) return NULL;
string aCompDataType = "Med";
myFileInfo.setFile(aCompDataType.c_str());
- myName = (const char*)(::GenerateName("aResult"));
+ myName = ::GenerateName("aResult").latin1();
VISU::Storable* aStorable = Build();
return aStorable;
}catch(std::runtime_error& exc){
- MESSAGE("Follow exception was accured :\n"<<exc.what());
+ INFOS("Follow exception was accured :\n"<<exc.what());
}catch(...){
- MESSAGE("Unknown exception was accured!");
+ INFOS("Unknown exception was accured!");
}
return NULL;
}
VISU::Storable* VISU::Result_i::Restore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
+ const Storable::TRestoringMap& theMap, const string& thePrefix)
throw(std::logic_error&)
{
if(MYDEBUG) MESSAGE("Result_i::Restore - "<<thePrefix);
SALOMEDS::AttributeComment_var aCmnt = SALOMEDS::AttributeComment::_narrow(anAttr);
aCmnt->SetValue(aComment.latin1());
}
+ QString aIsBuild = QAD_CONFIG->getSetting("Visu:BuildResult");
+ if(aIsBuild.isEmpty()? 0 : aIsBuild.toInt()) BuildAll();
return this;
}catch(std::runtime_error& exc){
- MESSAGE("Follow exception was accured :\n"<<exc.what());
+ INFOS("Follow exception was accured :\n"<<exc.what());
}catch(...){
- MESSAGE("Unknown exception was accured!");
+ INFOS("Unknown exception was accured!");
}
return NULL;
}
-VISU::Result_i::InputType* VISU::Result_i::GetInput() {
+VISU::Result_i::TInput* VISU::Result_i::GetInput() {
return myInput;
}
Storable::DataToStream(theStr,"myName",myName.c_str());
}
-VISU::Storable* VISU::ResultRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
+VISU::Storable* VISU::Result_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
throw(std::logic_error&)
{
SALOMEDS::Study_var aStudy = theSObject->GetStudy();
VISU::Result_i* pResult = new VISU::Result_i(aStudy);
if(pResult == NULL) return NULL;
- return pResult->Restore(theSObject,thePrefix,theMap);
+ return pResult->Restore(theSObject,theMap,thePrefix);
}
string VISU::Result_i::GetRefFatherEntry() {
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
// File : VISU_Result_i.hh
#include "VISUConfig.hh"
-class vtkUnstructuredGridReader;
-class vtkUnstructuredGrid;
class VISU_Convertor;
-class FieldInfo;
-class QAD_Study;
namespace VISU{
class Result_i : public virtual POA_VISU::Result,
Result_i(SALOMEDS::Study_ptr theStudy);
virtual ~Result_i();
- virtual VISU::VISUType GetType() { return VISU::TRESULT;};
+ virtual VISU::VISUType GetType() { return VISU::TRESULT;}
+ virtual CORBA::Boolean BuildAll();
- typedef VISU_Convertor InputType;
- typedef vtkUnstructuredGridReader OutputType;
+ typedef VISU_Convertor TInput;
enum TSourceId {eRestoredComponent = -2, eRestoredFile = -1, eFile = 1, eComponent = 2};
private:
TSourceId mySourceId;
- InputType *myInput;
+ TInput *myInput;
+ CORBA::Boolean myIsDone;
string myName;
QFileInfo myFileInfo;
protected:
- virtual Storable* Build(SALOMEDS::SObject_ptr theSObject = NULL)
+ virtual Storable* Build(SALOMEDS::SObject_ptr theSObject = SALOMEDS::SObject::_nil())
throw (std::runtime_error&);
public:
virtual Storable* Create(const char* theFileName);
virtual Storable* Create(SALOMEDS::SObject_ptr theMedSObject);
virtual Storable* Create(SALOME_MED::FIELD_ptr theField);
virtual Storable* Restore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
+ const Storable::TRestoringMap& theMap, const string& thePrefix)
+ throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
throw(std::logic_error&);
virtual void ToStream(std::ostringstream& theStr);
virtual const char* GetComment() const;
static const string myComment;
- InputType* GetInput();
+ TInput* GetInput();
const string& GetName() const { return myName;}
const QFileInfo& GetFileInfo() const { return myFileInfo;}
Result_i::TSourceId GetSourceId() const { return mySourceId;}
const SALOMEDS::Study_var& GetStudyDocument() const;
const SALOMEDS::SComponent_var& GetSComponent() const;
};
- Storable* ResultRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
- throw(std::logic_error&);
Result_var FindResult(SALOMEDS::SObject_ptr theSObject);
- QString GenerateName(const string& theFmt, int theId);
- void WriteToFile(vtkUnstructuredGrid* theDataSet, const string& theFileName);
}
#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_ScalarMapPL.hxx"
+#include "VISU_Result_i.hh"
+#include "VISU_ScalarMap_i.hh"
+#include "VISU_ScalarMapAct.h"
+#include "QAD_Config.h"
+
+using namespace VISU;
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+static int INCMEMORY = 4;
+
+int VISU::ScalarMap_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ try{
+ vtkIdType aSize = INCMEMORY*
+ theResult->GetInput()->GetTimeStampSize(theMeshName,(VISU::TEntity)theEntity,theFieldName,theIteration);
+ if(MYDEBUG) MESSAGE("ScalarMap_i::IsPossible - CheckAvailableMemory = "<<aSize);
+ if(VISU_PipeLine::CheckAvailableMemory(aSize)) return true;
+ return false;
+ }catch(std::runtime_error& exc){
+ INFOS("Follow exception was accured :\n"<<exc.what());
+ }catch(...){
+ INFOS("Unknown exception was accured!");
+ }
+ return 0;
+}
+
+int VISU::ScalarMap_i::myNbPresent = 0;
+QString VISU::ScalarMap_i::GenerateName() { return VISU::GenerateName("ScalarMap",myNbPresent++);}
+
+const string VISU::ScalarMap_i::myComment = "SCALARMAP";
+const char* VISU::ScalarMap_i::GetComment() const { return myComment.c_str();}
+
+VISU::ScalarMap_i::ScalarMap_i(Result_i* theResult, bool theAddToStudy) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ Prs3d_i(theResult)
+{
+ myAddToStudy = theAddToStudy;
+ myScalarMapPL = NULL;
+}
+
+void VISU::ScalarMap_i::Destroy(){
+ if(myAddToStudy){
+ SALOMEDS::SObject_var aSObj = myStudy->FindObjectID(GetEntry());
+ if(!aSObj->_is_nil()){
+ SALOMEDS::StudyBuilder_var aStudyBuilder = myStudy->NewBuilder();
+ aStudyBuilder->RemoveObject(aSObj);
+ }
+ }
+ Prs3d_i::Destroy();
+}
+
+
+void VISU::ScalarMap_i::SameAs(const ScalarMap_i* theOrigin)
+{
+ ScalarMap_i* aScalarMap = const_cast<ScalarMap_i*>(theOrigin);
+ DoHook();
+ VISU::Prs3d_i::SameAs(aScalarMap);
+ myField = aScalarMap->GetField();
+ myMeshName = myField->myMeshName;
+ myEntity = myField->myEntity;
+ myIteration = aScalarMap->GetIteration();
+ myFieldName = aScalarMap->GetFieldName();
+
+ SetScalarMode(aScalarMap->GetScalarMode());
+
+ SetRange(aScalarMap->GetMin(), aScalarMap->GetMax());
+ myIsFixedRange = aScalarMap->IsRangeFixed();
+
+ SetScaling(aScalarMap->GetScaling());
+
+ SetOrientation(aScalarMap->GetOrientation());
+ SetPosition(aScalarMap->GetPosX(), aScalarMap->GetPosY());
+ SetSize(aScalarMap->GetWidth(), aScalarMap->GetHeight());
+ SetNbColors(aScalarMap->GetNbColors());
+ SetLabels(aScalarMap->GetLabels());
+ SetTitle(aScalarMap->GetTitle());
+
+ Build(-1);
+ Update();
+}
+
+
+/**
+ * Creates Scalar Map and initialises it from resources
+ */
+VISU::Storable* VISU::ScalarMap_i::Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ DoHook();
+
+ // Orientation
+ QString aOrient = QAD_CONFIG->getSetting("Visu:SBOrientation");
+ if ( !aOrient.isEmpty() )
+ myOrientation = (VISU::ScalarMap::Orientation) aOrient.toInt();
+ else
+ myOrientation = VISU::ScalarMap::VERTICAL;
+
+ // Scalar Bar origin
+ QString aXorigin = QAD_CONFIG->getSetting("Visu:SBXorigin");
+ if ( !aXorigin.isEmpty() )
+ myPosition[0] = aXorigin.toFloat();
+ else {
+ if(myOrientation == VISU::ScalarMap::VERTICAL) {
+ myPosition[0] = 0.03;
+ } else {
+ myPosition[0] = 0.2;
+ }
+ }
+
+ QString aYorigin = QAD_CONFIG->getSetting("Visu:SBYorigin");
+ if ( !aYorigin.isEmpty() )
+ myPosition[1] = aYorigin.toFloat();
+ else {
+ if(myOrientation == VISU::ScalarMap::VERTICAL) {
+ myPosition[1] = 0.1;
+ } else {
+ myPosition[1] = 0.012;
+ }
+ }
+
+ // Scalar Bar size
+ QString aWidth = QAD_CONFIG->getSetting("Visu:SBWidth");
+ if ( !aWidth.isEmpty() )
+ myWidth = aWidth.toFloat();
+ else {
+ myWidth =(myOrientation == VISU::ScalarMap::VERTICAL)? 0.17:0.6;
+ }
+ QString aHeight = QAD_CONFIG->getSetting("Visu:SBHeight");
+ if ( !aHeight.isEmpty() )
+ myHeight = aHeight.toFloat();
+ else {
+ myHeight =(myOrientation == VISU::ScalarMap::VERTICAL)? 0.8:0.12;
+ }
+
+ // Nb of Colors
+ QString aColors = QAD_CONFIG->getSetting("Visu:SBNumberOfColors");
+ int aNumberOfColors = (aColors.isEmpty())? 64 : aColors.toInt();
+ if (aNumberOfColors > 64)
+ aNumberOfColors = 64;
+ SetNbColors(aNumberOfColors);
+
+ // Nb of Labels
+ QString aLabels = QAD_CONFIG->getSetting("Visu:SBNumberOfLabels");
+ myNumberOfLabels = (aLabels.isEmpty())? 5 : aLabels.toInt();
+ if (myNumberOfLabels > 65)
+ myNumberOfLabels = 65;
+
+ // Scalar Range
+ QString aFixRange = QAD_CONFIG->getSetting("Visu:SBImposeRange");
+ myIsFixedRange = (aFixRange.compare("true") == 0);
+
+ if(myIsFixedRange){
+ float aScalarRange[2];
+ QString aRangeMin = QAD_CONFIG->getSetting("Visu:SBMinimumValue");
+ float aMin = (aRangeMin.isEmpty())? 0 : aRangeMin.toFloat();
+ QString aRangeMax = QAD_CONFIG->getSetting("Visu:SBMaximumValue");
+ float aMax = (aRangeMax.isEmpty())? 0 : aRangeMax.toFloat();
+ SetRange(aMin,aMax);
+ }
+
+ QString aScaling = QAD_CONFIG->getSetting("Visu:SBScaling");
+ if(aScaling.compare("LOGARITHMIC") == 0)
+ SetScaling(VISU::LOGARITHMIC);
+ else
+ SetScaling(VISU::LINEAR);
+
+ myMeshName = theMeshName;
+ myEntity = (VISU::TEntity)theEntity;
+ myFieldName =theFieldName;
+ myIteration = theIteration;
+
+ return Build(false);
+}
+
+
+VISU::Storable* VISU::ScalarMap_i::Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ DoHook();
+
+ Prs3d_i::Restore(theMap);
+
+ myAddToStudy = false; //SRN Added 21/06/2003 SAL2983: to avoid addition of the new ScalarMap to study.
+
+ myMeshName = VISU::Storable::FindValue(theMap,"myMeshName").latin1();
+ myEntity = (VISU::TEntity)VISU::Storable::FindValue(theMap,"myEntity").toInt();
+ myFieldName = VISU::Storable::FindValue(theMap,"myFieldName").latin1();
+ myIteration = VISU::Storable::FindValue(theMap,"myIteration").toInt();
+
+ SetScalarMode(VISU::Storable::FindValue(theMap,"myScalarMode").toInt());
+ SetScaling(VISU::Scaling(VISU::Storable::FindValue(theMap,"myScaling").toInt()));
+ float aMin = VISU::Storable::FindValue(theMap,"myScalarRange[0]").toDouble();
+ float aMax = VISU::Storable::FindValue(theMap,"myScalarRange[1]").toDouble();
+ SetRange(aMin,aMax);
+ myIsFixedRange = VISU::Storable::FindValue(theMap,"myIsFixedRange").toInt();
+
+ myTitle = VISU::Storable::FindValue(theMap,"myTitle").latin1();
+ myOrientation = (VISU::ScalarMap::Orientation)VISU::Storable::FindValue(theMap,"myOrientation").toInt();
+ SetNbColors(VISU::Storable::FindValue(theMap,"myNumberOfColors").toInt());
+ myNumberOfLabels = VISU::Storable::FindValue(theMap,"myNumberOfLabels").toInt();
+ myPosition[0] = VISU::Storable::FindValue(theMap,"myPosition[0]").toDouble();
+ myPosition[1] = VISU::Storable::FindValue(theMap,"myPosition[1]").toDouble();
+ myWidth = VISU::Storable::FindValue(theMap,"myWidth").toDouble();
+ myHeight = VISU::Storable::FindValue(theMap,"myHeight").toDouble();
+
+ return Build(true);
+}
+
+
+void VISU::ScalarMap_i::ToStream(std::ostringstream& theStr){
+ Prs3d_i::ToStream(theStr);
+
+ Storable::DataToStream( theStr, "myMeshName", myMeshName.c_str() );
+ Storable::DataToStream( theStr, "myEntity", myEntity );
+ Storable::DataToStream( theStr, "myFieldName", myFieldName.c_str() );
+ Storable::DataToStream( theStr, "myIteration", myIteration );
+
+ Storable::DataToStream( theStr, "myScalarMode", int(GetScalarMode()) );
+ Storable::DataToStream( theStr, "myScalarRange[0]", GetMin() );
+ Storable::DataToStream( theStr, "myScalarRange[1]", GetMax() );
+ Storable::DataToStream( theStr, "myIsFixedRange", myIsFixedRange );
+ Storable::DataToStream( theStr, "myScaling", GetScaling() );
+
+ Storable::DataToStream( theStr, "myTitle", myTitle.c_str() );
+ Storable::DataToStream( theStr, "myOrientation", myOrientation );
+ Storable::DataToStream( theStr, "myNumberOfColors", int(GetNbColors()) );
+ Storable::DataToStream( theStr, "myNumberOfLabels", myNumberOfLabels );
+ Storable::DataToStream( theStr, "myPosition[0]", myPosition[0] );
+ Storable::DataToStream( theStr, "myPosition[1]", myPosition[1] );
+ Storable::DataToStream( theStr, "myWidth", myWidth );
+ Storable::DataToStream( theStr, "myHeight", myHeight );
+}
+
+
+CORBA::Long VISU::ScalarMap_i::GetScalarMode(){
+ return myScalarMapPL->GetScalarMode();
+}
+void VISU::ScalarMap_i::SetScalarMode(CORBA::Long theScalarMode) {
+ myScalarMapPL->SetScalarMode(theScalarMode);
+}
+
+
+VISU::Scaling VISU::ScalarMap_i::GetScaling(){
+ return VISU::Scaling(myScalarMapPL->GetScaling());
+}
+void VISU::ScalarMap_i::SetScaling(VISU::Scaling theScaling){
+ myScalarMapPL->SetScaling(theScaling);
+}
+
+
+void VISU::ScalarMap_i::SetRange(CORBA::Double theMin, CORBA::Double theMax){
+ if(theMin > theMax) return;
+ float aScalarRange[2] = {theMin, theMax};
+ myScalarMapPL->SetScalarRange(aScalarRange);
+ myIsFixedRange = true;
+}
+
+CORBA::Double VISU::ScalarMap_i::GetMin(){
+ return myScalarMapPL->GetScalarRange()[0];
+}
+
+CORBA::Double VISU::ScalarMap_i::GetMax(){
+ return myScalarMapPL->GetScalarRange()[1];
+}
+
+
+void VISU::ScalarMap_i::SetNbColors(CORBA::Long theNbColors){
+ myScalarMapPL->SetNbColors(theNbColors);
+}
+
+CORBA::Long VISU::ScalarMap_i::GetNbColors(){
+ return myScalarMapPL->GetNbColors();
+}
+
+
+VISU::Storable* VISU::ScalarMap_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ if(VISU::Result_i* pResult = GetResult(theSObject)){
+ VISU::ScalarMap_i* pResent = new VISU::ScalarMap_i(pResult);
+ return pResent->Restore(theMap);
+ }
+ return NULL;
+}
+
+
+VISU::ScalarMap_i::~ScalarMap_i(){
+ if(MYDEBUG) MESSAGE("ScalarMap_i::~ScalarMap_i()");
+}
+
+
+VISU::Storable* VISU::ScalarMap_i::Build(int theRestoring){
+ if(MYDEBUG)
+ MESSAGE("ScalarMap_i::Build - "<<myFieldName<<"; theRestoring = "<<theRestoring);
+ try{
+ if(myResult->GetInput() == NULL)
+ throw std::runtime_error("Mesh_i::Build - myResult->GetInput() == NULL !!!");
+ myField = &(myResult->GetInput()->GetField(myMeshName,myEntity,myFieldName));
+ if(myField == NULL) throw std::runtime_error("There is no Field with the parameters !!!");
+ VISU_Convertor::TOutput *anOutput =
+ myResult->GetInput()->GetTimeStampOnMesh(myMeshName,myEntity,myFieldName,myIteration);
+ if(anOutput == NULL) throw std::runtime_error("There is no TimeStamp with the parameters !!!");
+ myScalarMapPL->SetInput(anOutput);
+ myScalarMapPL->Build();
+ QString aComment;
+ myName = "NoName";
+ if(theRestoring <= 0){
+ if(theRestoring == 0) myScalarMapPL->Init();
+ if(!myIsFixedRange) myScalarMapPL->SetSourceRange();
+ const VISU::TField::TValField& aValField = myField->myValField;
+ const VISU::TField::TValForTime& aValForTime = aValField.find(myIteration)->second;
+ aComment.sprintf("%s %s",myFieldName.c_str(),VISU_Convertor::GenerateName(aValForTime.myTime).c_str());
+ myTitle = aComment.simplifyWhiteSpace().latin1();
+ }
+ if(myAddToStudy){
+ myName = GenerateName().latin1();
+ aComment.sprintf("myComment=TIMESTAMP;myType=%d;myMeshName=%s;myEntityId=%d;myFieldName=%s;myTimeStampId=%d;myNumComponent=%d",
+ VISU::TTIMESTAMP,myMeshName.c_str(),myEntity,myFieldName.c_str(),myIteration,myField->myNbComp);
+ string aResultEntry = myResult->GetEntry();
+ string aRefFatherEntry = myResult->GetRefFatherEntry();
+ string anEntry = FindEntryWithComment(myStudy,aResultEntry.c_str(),aComment.latin1());
+ if(anEntry == "") throw std::runtime_error("There is no Entry for binding the presentation !!!");
+ aComment.sprintf("myComment=%s;myMeshName=%s;myEntityId=%d;myFieldName=%s;myTimeStampId=%d;myNumComponent=%d",
+ GetComment(),myMeshName.c_str(),myEntity,myFieldName.c_str(),myIteration,myField->myNbComp);
+ CORBA::String_var anIOR = GetID();
+ CreateAttributes(myStudy,anEntry.c_str(),aRefFatherEntry.c_str(),anIOR,myName.c_str(),"",aComment.latin1(),true);
+ }
+ return this;
+ }catch(std::runtime_error& exc){
+ INFOS("Follow exception was accured :\n"<<exc.what());
+ }catch(...){
+ INFOS("Unknown exception was accured!");
+ }
+ return NULL;
+}
+
+
+void VISU::ScalarMap_i::DoHook(){
+ if(MYDEBUG) MESSAGE("ScalarMap_i::DoHook() - "<<myPipeLine);
+ if(!myPipeLine) {
+ myPipeLine = VISU_ScalarMapPL::New();
+ myPipeLine->GetMapper()->SetScalarVisibility(1);
+ }
+ myScalarMapPL = dynamic_cast<VISU_ScalarMapPL*>(myPipeLine);
+}
+
+void VISU::ScalarMap_i::Update(){
+ VISU::Prs3d_i::Update();
+}
+
+void VISU::ScalarMap_i::SetMapScale(double theMapScale){
+ myScalarMapPL->SetMapScale(theMapScale);
+}
+
+VISU_Actor* VISU::ScalarMap_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
+ throw (std::runtime_error&)
+{
+ VISU_ScalarMapAct* anActor = VISU_ScalarMapAct::New();
+ try{
+ VISU::Prs3d_i::CreateActor(anActor,theIO);
+ anActor->SetBarVisibility(true);
+ anActor->SetRepresentation(2);
+ anActor->myFieldName = myFieldName;
+ UpdateActor(anActor);
+ }catch(std::runtime_error& exc){
+ anActor->Delete();
+ throw exc;
+ }
+ return anActor;
+}
+
+void VISU::ScalarMap_i::UpdateActor(VISU_Actor* theActor){
+ if(VISU_ScalarMapAct* anActor = dynamic_cast<VISU_ScalarMapAct*>(theActor)){
+ VISU::Prs3d_i::UpdateActor(theActor);
+ VISU_ScalarBarActor *aScalarBar = anActor->GetScalarBar();
+ aScalarBar->SetLookupTable(myScalarMapPL->GetBarTable());
+ aScalarBar->SetTitle(myTitle.c_str());
+ aScalarBar->SetOrientation(myOrientation);
+ aScalarBar->GetPositionCoordinate()->SetCoordinateSystemToNormalizedViewport();
+ aScalarBar->GetPositionCoordinate()->SetValue(myPosition[0],myPosition[1]);
+ aScalarBar->SetWidth(myWidth);
+ aScalarBar->SetHeight(myHeight);
+ aScalarBar->SetNumberOfLabels(myNumberOfLabels);
+ aScalarBar->Modified();
+ }
+}
+
+
+void VISU::ScalarMap_i::SetSourceRange(){
+ myScalarMapPL->SetSourceRange();
+ myIsFixedRange = false;
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_ScalarMap_i_HeaderFile
+#define VISU_ScalarMap_i_HeaderFile
+
+#include "VISU_Prs3d_i.hh"
+
+class VISU_ScalarMapPL;
+
+namespace VISU{
+ class ScalarMap_i : public virtual POA_VISU::ScalarMap,
+ public virtual Prs3d_i
+ {
+ static int myNbPresent;
+ ScalarMap_i();
+ ScalarMap_i(const ScalarMap_i&);
+
+ public:
+ ScalarMap_i(Result_i* theResult, bool theAddToStudy = true);
+ virtual void SameAs(const ScalarMap_i* theOrigin);
+ virtual ~ScalarMap_i();
+ virtual void Destroy();
+
+ virtual VISU::VISUType GetType() { return VISU::TSCALARMAP;};
+
+ virtual CORBA::Long GetScalarMode();
+ virtual void SetScalarMode(CORBA::Long theScalarMode);
+
+ virtual VISU::Scaling GetScaling();
+ virtual void SetScaling(VISU::Scaling theScaling);
+
+ virtual void SetRange(CORBA::Double theMin, CORBA::Double theMax);
+ virtual CORBA::Double GetMin();
+ virtual CORBA::Double GetMax();
+
+ virtual void SetNbColors(CORBA::Long theNbColors);
+ virtual CORBA::Long GetNbColors();
+
+ virtual void SetOrientation(VISU::ScalarMap::Orientation theOrientation){
+ myOrientation = theOrientation;
+ }
+ virtual VISU::ScalarMap::Orientation GetOrientation() { return myOrientation;}
+
+ virtual void SetPosition(CORBA::Double X, CORBA::Double Y) { myPosition[0] = X; myPosition[1] = Y;}
+ virtual CORBA::Double GetPosX() { return myPosition[0];}
+ virtual CORBA::Double GetPosY() { return myPosition[1];}
+
+ virtual void SetSize(CORBA::Double theWidth, CORBA::Double theHeight) {
+ myWidth = theWidth; myHeight = theHeight;
+ }
+ virtual CORBA::Double GetWidth() { return myWidth;}
+ virtual CORBA::Double GetHeight() { return myHeight;}
+
+ virtual void SetLabels(CORBA::Long theNbLabels) { myNumberOfLabels = theNbLabels;}
+ virtual CORBA::Long GetLabels() { return myNumberOfLabels;}
+
+ virtual void SetTitle(const char* theName) { myTitle = theName;}
+ virtual char* GetTitle() { return CORBA::string_dup(myTitle.c_str());}
+
+ typedef VISU::ScalarMap TInterface;
+ VISU_ScalarMapPL* GetScalarMapPL(){ return myScalarMapPL;}
+
+ protected:
+ Storable* Build(int theRestoring);
+ virtual void DoHook();
+
+ VISU_ScalarMapPL* myScalarMapPL;
+ const TField* myField;
+
+ string myMeshName;
+ TEntity myEntity;
+ string myFieldName;
+ int myIteration;
+
+ bool myIsFixedRange;
+
+ std::string myTitle;
+ int myNumberOfLabels;
+ float myPosition[2], myWidth, myHeight;
+ VISU::ScalarMap::Orientation myOrientation;
+
+ public:
+ static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+ virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+
+ virtual void ToStream(std::ostringstream& theStr);
+
+ static const string myComment;
+ virtual const char* GetComment() const;
+ virtual QString GenerateName();
+
+ virtual Storable* Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+
+ virtual void Update();
+ virtual void SetMapScale(double theMapScale = 1.0);
+
+ const VISU::TField* GetField() const { return myField;}
+ const string& GetFieldName() const { return myFieldName;}
+
+ virtual bool IsRangeFixed() { return myIsFixedRange; }
+ virtual void SetSourceRange();
+
+ virtual int GetIteration() { return myIteration; }
+
+ virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL)
+ throw (std::runtime_error&);
+ virtual void UpdateActor(VISU_Actor* theActor);
+ };
+}
+
+#endif
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_StreamLinesPL.hxx"
+#include "VISU_Result_i.hh"
+#include "VISU_StreamLines_i.hh"
+#include "VISU_Actor.h"
+
+#include <vtkAppendFilter.h>
+
+using namespace VISU;
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+static int INCMEMORY = 2;
+
+int VISU::StreamLines_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ try{
+ vtkIdType aSize =
+ (VISU_StreamLinesPL::myMaxIncrementMemorySize+INCMEMORY)*
+ theResult->GetInput()->GetTimeStampSize(theMeshName,(VISU::TEntity)theEntity,theFieldName,theIteration);
+ if(MYDEBUG) MESSAGE("StreamLines_i::IsPossible - CheckAvailableMemory = "<<aSize);
+ if(VISU_PipeLine::CheckAvailableMemory(aSize)) return true;
+ return false;
+ }catch(std::runtime_error& exc){
+ INFOS("Follow exception was accured :\n"<<exc.what());
+ }catch(...){
+ INFOS("Unknown exception was accured!");
+ }
+ return 0;
+}
+
+
+int VISU::StreamLines_i::myNbPresent = 0;
+QString VISU::StreamLines_i::GenerateName() { return VISU::GenerateName("StreamLines",myNbPresent++);}
+
+
+const string VISU::StreamLines_i::myComment = "STREAMLINES";
+const char* VISU::StreamLines_i::GetComment() const { return myComment.c_str();}
+
+
+VISU::StreamLines_i::StreamLines_i(Result_i* theResult, bool theAddToStudy) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ Prs3d_i(theResult),
+ ScalarMap_i(theResult, theAddToStudy),
+ DeformedShape_i(theResult, theAddToStudy)
+{
+ myStreamLinesPL = NULL;
+}
+
+void VISU::StreamLines_i::Destroy(){
+ DeformedShape_i::Destroy();
+}
+
+
+void VISU::StreamLines_i::SameAs(const StreamLines_i* theOrigin) {
+ StreamLines_i* aStreamLines = const_cast<StreamLines_i*>(theOrigin);
+ VISU::DeformedShape_i::SameAs(theOrigin);
+
+ //Order of setting of the values are important
+ //SetIntegrationStep(aStreamLines->GetIntegrationStep());
+ //SetPropagationTime(aStreamLines->GetPropagationTime());
+ //SetStepLength(aStreamLines->GetStepLength());
+
+ //SetUsedPoints(aStreamLines->GetUsedPoints());
+ //SetDirection(aStreamLines->GetDirection());
+
+ SetSource(aStreamLines->GetSource());
+}
+
+
+VISU::Storable* VISU::StreamLines_i::Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ return DeformedShape_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+}
+
+
+VISU::Storable* VISU::StreamLines_i::Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ DeformedShape_i::Restore(theMap);
+
+ //Order of setting of the values are important
+ SetIntegrationStep(VISU::Storable::FindValue(theMap,"myIntegrationStep").toDouble());
+ SetPropagationTime(VISU::Storable::FindValue(theMap,"myPropagationTime").toDouble());
+ SetStepLength(VISU::Storable::FindValue(theMap,"myStepLength").toDouble());
+
+ SetDirection(VISU::StreamLines::Direction(VISU::Storable::FindValue(theMap,"myDirection").toInt()));
+ SetUsedPoints(VISU::Storable::FindValue(theMap,"myPercents").toDouble());
+ mySourceEntry = VISU::Storable::FindValue(theMap,"mySourceEntry").latin1();
+
+ return Build(true);
+}
+
+
+void VISU::StreamLines_i::ToStream(std::ostringstream& theStr){
+ DeformedShape_i::ToStream(theStr);
+
+ Storable::DataToStream( theStr, "myIntegrationStep", GetIntegrationStep());
+ Storable::DataToStream( theStr, "myPropagationTime", GetPropagationTime());
+ Storable::DataToStream( theStr, "myStepLength", GetStepLength());
+
+ Storable::DataToStream( theStr, "myDirection", int(GetDirection()));
+ Storable::DataToStream( theStr, "myPercents", GetUsedPoints());
+
+ Storable::DataToStream( theStr, "mySourceEntry", mySourceEntry.c_str());
+}
+
+
+VISU::Storable* VISU::StreamLines_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ VISU::Result_i* pResult = GetResult(theSObject);
+ if(pResult != NULL){
+ VISU::StreamLines_i* pResent = new VISU::StreamLines_i(pResult);
+ return pResent->Restore(theMap);
+ }
+ return NULL;
+}
+
+
+VISU::StreamLines_i::~StreamLines_i(){
+ if(MYDEBUG) MESSAGE("StreamLines_i::~StreamLines_i()");
+}
+
+
+void VISU::StreamLines_i::SetDirection(VISU::StreamLines::Direction theDirection) {
+ myStreamLinesPL->SetDirection(theDirection);
+}
+VISU::StreamLines::Direction VISU::StreamLines_i::GetDirection() {
+ return VISU::StreamLines::Direction(myStreamLinesPL->GetDirection());
+}
+
+
+void VISU::StreamLines_i::SetStepLength(CORBA::Double theStep) {
+ myStreamLinesPL->SetStepLength(theStep);
+}
+CORBA::Double VISU::StreamLines_i::GetStepLength() {
+ return myStreamLinesPL->GetStepLength();
+}
+
+
+void VISU::StreamLines_i::SetPropagationTime(CORBA::Double theTime) {
+ myStreamLinesPL->SetPropagationTime(theTime);
+}
+CORBA::Double VISU::StreamLines_i::GetPropagationTime() {
+ return myStreamLinesPL->GetPropagationTime();
+}
+
+
+void VISU::StreamLines_i::SetIntegrationStep(CORBA::Double theStep) {
+ myStreamLinesPL->SetIntegrationStep(theStep);
+}
+CORBA::Double VISU::StreamLines_i::GetIntegrationStep() {
+ return myStreamLinesPL->GetIntegrationStep();
+}
+
+
+void VISU::StreamLines_i::SetUsedPoints(CORBA::Double thePercents) {
+ myStreamLinesPL->SetUsedPoints(thePercents);
+}
+CORBA::Double VISU::StreamLines_i::GetUsedPoints() {
+ return myStreamLinesPL->GetUsedPoints();
+}
+
+
+void VISU::StreamLines_i::SetSource(VISU::Prs3d_ptr thePrs3d){
+ if(!thePrs3d->_is_nil())
+ if(VISU::Prs3d_i* aPrs3di = dynamic_cast<VISU::Prs3d_i*>(VISU::GetServant(thePrs3d))){
+ CORBA::String_var aString = thePrs3d->GetID();
+ SALOMEDS::SObject_var aSObject = myStudy->FindObjectIOR(aString);
+ if(!CORBA::is_nil(aSObject)){
+ vtkAppendFilter* anAppendFilter = vtkAppendFilter::New();
+ anAppendFilter->AddInput(aPrs3di->GetPipeLine()->GetMapper()->GetInput());
+ myStreamLinesPL->SetSource(anAppendFilter->GetOutput());
+ anAppendFilter->Register(myStreamLinesPL);
+ anAppendFilter->Delete();
+ aString = aSObject->GetID();
+ mySourceEntry = aString.in();
+ return;
+ }
+ }
+ myStreamLinesPL->SetSource(NULL);
+ mySourceEntry = "";
+}
+VISU::Prs3d_ptr VISU::StreamLines_i::GetSource(){
+ VISU::Prs3d_var aPrs3d;
+ if(MYDEBUG) MESSAGE("StreamLines_i::GetSource() mySourceEntry = '"<<mySourceEntry<<"'");
+ if(mySourceEntry != ""){
+ SALOMEDS::SObject_var aSObject = myStudy->FindObjectID(mySourceEntry.c_str());
+ CORBA::Object_var anObj = SObjectToObject(aSObject);
+ if(!CORBA::is_nil(anObj)) aPrs3d = VISU::Prs3d::_narrow(anObj);
+ }
+ return aPrs3d._retn();
+}
+
+
+float VISU::StreamLines_i::GetMaxIntegrationStep(){
+ return myStreamLinesPL->GetMaxIntegrationStep();
+}
+
+
+float VISU::StreamLines_i::GetMinIntegrationStep(){
+ return myStreamLinesPL->GetMinIntegrationStep();
+}
+
+
+float VISU::StreamLines_i::GetBasePropagationTime(){
+ return myStreamLinesPL->GetBasePropagationTime();
+}
+
+
+void VISU::StreamLines_i::DoHook(){
+ if(!myPipeLine) myPipeLine = VISU_StreamLinesPL::New();
+ myStreamLinesPL = dynamic_cast<VISU_StreamLinesPL*>(myPipeLine);
+
+ DeformedShape_i::DoHook();
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_StreamLines_i_HeaderFile
+#define VISU_StreamLines_i_HeaderFile
+
+#include "VISU_DeformedShape_i.hh"
+
+class VISU_StreamLinesPL;
+
+namespace VISU{
+ class StreamLines_i : public virtual POA_VISU::StreamLines,
+ public virtual DeformedShape_i
+ {
+ static int myNbPresent;
+ StreamLines_i();
+ StreamLines_i(const StreamLines_i&);
+ public:
+ StreamLines_i(Result_i* theResult, bool theAddToStudy = true);
+ virtual void SameAs(const StreamLines_i* theOriginal);
+ virtual ~StreamLines_i();
+ virtual void Destroy();
+
+ virtual VISU::VISUType GetType() { return VISU::TSTREAMLINES;}
+
+ virtual void SetDirection(VISU::StreamLines::Direction theDirection);
+ virtual VISU::StreamLines::Direction GetDirection();
+
+ virtual void SetStepLength(CORBA::Double theStep);
+ virtual CORBA::Double GetStepLength();
+
+ virtual void SetPropagationTime(CORBA::Double theTime);
+ virtual CORBA::Double GetPropagationTime();
+
+ virtual void SetIntegrationStep(CORBA::Double theStep);
+ virtual CORBA::Double GetIntegrationStep();
+
+ virtual void SetUsedPoints(CORBA::Double thePercents);
+ virtual CORBA::Double GetUsedPoints();
+
+ virtual void SetSource(VISU::Prs3d_ptr thePrs3d);
+ virtual VISU::Prs3d_ptr GetSource();
+
+ typedef VISU::StreamLines TInterface;
+ VISU_StreamLinesPL* GetStreamLinesPL(){ return myStreamLinesPL;}
+
+ protected:
+ virtual void DoHook();
+
+ VISU_StreamLinesPL* myStreamLinesPL;
+ string mySourceEntry;
+
+ public:
+ static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+ virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+
+ virtual void ToStream(std::ostringstream& theStr);
+
+ virtual Storable* Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+
+ static const string myComment;
+ virtual const char* GetComment() const;
+ virtual QString GenerateName();
+
+ virtual float GetMinIntegrationStep();
+ virtual float GetMaxIntegrationStep();
+ virtual float GetBasePropagationTime();
+
+ virtual QString GetSourceEntry() { return QString(mySourceEntry.c_str()); }
+ };
+}
+#endif
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
// File : VISU_Table_i.cc
// Author : Vadim SANDLER
// Module : VISU
-using namespace std;
#include "VISU_Table_i.hh"
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include "QAD_Study.h"
+
+#include "VISU_CutLines_i.hh"
+
+#include <memory>
#include <fstream>
#include <strstream>
+
#include <qfileinfo.h>
-#include <qstringlist.h>
-#include <memory>
-#ifdef DEBUG
-static int MYDEBUG = 1;
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
#else
static int MYDEBUG = 0;
#endif
/*!
Called from engine to restore table from the file
*/
-VISU::Storable* VISU::TableRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
+VISU::Storable* VISU::Table_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
{
SALOMEDS::Study_var aStudy = theSObject->GetStudy();
VISU::Table_i* pResent = new VISU::Table_i( aStudy, "" );
/*!
Called from engine to restore curve from the file
*/
-VISU::Storable* VISU::CurveRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
+VISU::Storable* VISU::Curve_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
{
SALOMEDS::Study_var aStudy = theSObject->GetStudy();
VISU::Table_i* pTable = GetTable( aStudy, theMap );
/*!
Called from engine to restore container from the file
*/
-VISU::Storable* VISU::ContainerRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap)
+VISU::Storable* VISU::Container_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
{
SALOMEDS::Study_var aStudy = theSObject->GetStudy();
VISU::Container_i* pResent = new VISU::Container_i( aStudy );
//-------------------------------------------------------------
// Implementation of reading from file
//-------------------------------------------------------------
-typedef vector<float> TValues;
+typedef double TValue;
+typedef vector<TValue> TValues;
struct TRow{
string myTitle;
if(myColumnUnits.size() != iEnd) myColumnUnits.resize(iEnd);
int jEnd = myRows.size();
for(int j = 0; j < jEnd; j++)
- if(myRows[j].myValues.size() != iEnd) return 0;
+ if(myRows[j].myValues.size() != iEnd)
+ return 0;
return 1;
}
void getColumns(TTable2D& theTable2D) const {
if(tmp == '\n') break;
}
aStrOut<<ends;
- auto_ptr<char> aRet(aStrOut.str());
- theString = aRet.get();
+ theString = aStrOut.str();
return !theStmIn.eof();
}
void ImportTables(const char* theFileName, TTableCont& theTableCont){
+ static int STRPRECISION = 12;
ifstream aStmIn;
QFileInfo aFileInfo(theFileName);
if(!aFileInfo.isFile() || !aFileInfo.isReadable() || !aFileInfo.size()) return;
do{
//Find beginning of Table
while(getLine(aStmIn,aTmp) && aTmp == "\n");
- //cout<<"\n There is new Table2D with Title = ";
+ if(MYDEBUG) cout<<"\n There is new Table2D with Title = ";
TTable2D aTable2D;
while(!aStmIn.eof() && aTmp != "\n"){
if(aTmp.find("#TITLE:") == 0){
int aLen = aTmp.find(":") + 1;
aTmp.remove(0,aLen);
QString aTitle = aTmp.stripWhiteSpace();
- aTable2D.myTitle = (const char*)aTitle;
+ aTable2D.myTitle = aTitle.latin1();
+
if(MYDEBUG) cout<<aTitle<<endl;
}else if(aTmp.find("#COLUMN_TITLES:") == 0){
int aLen = aTmp.find(":") + 1;
aTmp.remove(0,aLen);
QStringList aStrList = QStringList::split("|",aTmp);
- //cout<<"Its Column Titles : ";
+ if(MYDEBUG) cout<<"Its Column Titles : ";
for(int i = 0; i < aStrList.count(); i++){
aTmp = aStrList[i].stripWhiteSpace();
aTable2D.myColumnTitles.push_back(aTmp.latin1());
+
if(MYDEBUG) cout<<"\t"<<aTmp;
}
- //cout<<endl;
+ if(MYDEBUG) cout<<endl;
}else if(aTmp.find("#COLUMN_UNITS:") == 0){
int aLen = aTmp.find(":") + 1;
aTmp.remove(0,aLen);
QStringList aStrList = QStringList::split(" ",aTmp);
- //cout<<"Its Column Units : ";
+ if(MYDEBUG) cout<<"Its Column Units : ";
for(int i = 0; i < aStrList.count(); i++){
aTmp = aStrList[i].stripWhiteSpace();
aTable2D.myColumnUnits.push_back(aTmp.latin1());
+
if(MYDEBUG) cout<<"\t"<<aTmp;
}
- //cout<<endl;
+ if(MYDEBUG) cout<<endl;
}else if(aTmp.find("#") == 0){
//It is a comment
}else if(aTmp.find("#TITLE:") > 0){
QStringList aStrList = QStringList::split("#TITLE:",aTmp);
QString aTitle = aStrList[1].stripWhiteSpace();
TRow aRow;
- aRow.myTitle = (const char*)aTitle;
+ aRow.myTitle = aTitle.latin1();
+
if(MYDEBUG) cout<<aTitle<<" : ";
QStringList aValList = QStringList::split(" ",aStrList[0]);
for(int i = 0; i < aValList.count(); i++){
float aVal = aValList[i].toFloat();
aRow.myValues.push_back(aVal);
+
if(MYDEBUG) cout<<"\t"<<aVal;
}
aTable2D.myRows.push_back(aRow);
- //cout<<endl;
+ if(MYDEBUG) cout<<endl;
}else{
- QStringList aValList = QStringList::split(" ",aTmp);
- TRow aRow;
- for(int i = 0; i < aValList.count(); i++){
- float aVal = aValList[i].toFloat();
+ TRow aRow;
+ TValue aVal;
+ istrstream aStream(aTmp);
+ aStream.precision(STRPRECISION);
+ while(aStream>>aVal){
aRow.myValues.push_back(aVal);
+
if(MYDEBUG) cout<<"\t"<<aVal;
}
- aTable2D.myRows.push_back(aRow);
- //cout<<endl;
+ if(aRow.myValues.size() > 0)
+ aTable2D.myRows.push_back(aRow);
+ if(MYDEBUG) cout<<endl;
}
getLine(aStmIn,aTmp);
}
if(aTable2D.Check()){
-
//cout<<"aTable2D checked "<<aTable2D.myTitle<<endl;
+
if(MYDEBUG) cout<<"aTable2D checked "<<aTable2D.myTitle<<endl;
theTableCont.push_back(aTable2D);
}
}while(!aStmIn.eof());
aStmIn.close();
- //cout<<"After close"<<endl;
+ if(MYDEBUG) cout<<"After close"<<endl;
}
SALOMEDS::SObject_var VISU::ImportTables(const char* theFileName, SALOMEDS::Study_ptr theStudy){
QFileInfo aFileInfo(theFileName);
aName->SetValue(aFileInfo.fileName().latin1());
int iEnd = aTableCont.size();
- /*
for(int i = 0, iEnd = aTableCont.size(); i < iEnd; i++){
const TTable2D& aTable2D = aTableCont[i];
SALOMEDS::SObject_var aRealObject = aStudyBuilder->NewObject(aFileObject);
anAttr = aStudyBuilder->FindOrCreateAttribute(aRealObject, "AttributeName");
aName = SALOMEDS::AttributeName::_narrow(anAttr);
- cout<<"aTable2D.myTitle = "<<aTable2D.myTitle<<endl;
- if(aTable2D.myTitle != "")
- aName->SetValue(aTable2D.myTitle.c_str());
- else{
- QString aNewName;
- aNewName.sprintf("Table:%d",i);
- aName->SetValue(aNewName.latin1());
- }
- anAttr = aStudyBuilder->FindOrCreateAttribute(aRealObject, "AttributeTableOfReal");
- SALOMEDS::AttributeTableOfReal_var aTableOfReal = SALOMEDS::AttributeTableOfReal::_narrow(anAttr);
- aTableOfReal->SetTitle(aTable2D.myTitle.c_str());
- const TRows& aRows = aTable2D.myRows;
- //aTable2D.getColumns(aRows);
- int kEnd = aRows[0].myValues.size();
- aTableOfReal->SetNbColumns(kEnd);
- for(int j = 0, jEnd = aRows.size(); j < jEnd; j++){
- cout<<"j = "<<j<<endl;
- const TRow& aRow = aRows[j];
- SALOMEDS::DoubleSeq_var aDoubleSeq = new SALOMEDS::DoubleSeq();
- int kEnd = aRow.myValues.size();
- aDoubleSeq->length(kEnd);
- cout<<"kEnd = "<<kEnd<<endl;
- for(int k = 0; k < kEnd; k++) aDoubleSeq[k] = aRow.myValues[k];
- aTableOfReal->AddRow(aDoubleSeq.in());
- aTableOfReal->SetRowTitle(j+1,aRow.myTitle.c_str());
- aTableOfReal->SetRowUnit(j+1,aRow.myUnit.c_str());
- }
- for(int k = 0; k < kEnd; k++){
- aTableOfReal->SetColumnTitle(k+1,aTable2D.myColumnTitles[k].c_str());
- //aTableOfReal->SetColumnUnit(k+1,aTable2D.myColumnUnits[k].c_str());
- }
- }
- */
- for(int i = 0, iEnd = aTableCont.size(); i < iEnd; i++){
- const TTable2D& aTable2D = aTableCont[i];
- SALOMEDS::SObject_var aRealObject = aStudyBuilder->NewObject(aFileObject);
- anAttr = aStudyBuilder->FindOrCreateAttribute(aRealObject, "AttributeName");
- aName = SALOMEDS::AttributeName::_narrow(anAttr);
- //cout<<"aTable2D.myTitle = "<<aTable2D.myTitle<<endl;
+ if(MYDEBUG) cout<<"aTable2D.myTitle = "<<aTable2D.myTitle<<endl;
if(aTable2D.myTitle != "")
aName->SetValue(aTable2D.myTitle.c_str());
else{
int kEnd = aNewTable2D.myRows[0].myValues.size();
aTableOfReal->SetNbColumns(kEnd);
for(int j = 0, jEnd = aNewTable2D.myRows.size(); j < jEnd; j++){
- //cout<<"j = "<<j<<endl;
+ if(MYDEBUG) cout<<"j = "<<j<<endl;
SALOMEDS::DoubleSeq_var aDoubleSeq = new SALOMEDS::DoubleSeq();
aDoubleSeq->length(kEnd);
- //cout<<"kEnd = "<<kEnd<<endl;
+ if(MYDEBUG) cout<<"kEnd = "<<kEnd<<endl;
for(int k = 0; k < kEnd; k++) aDoubleSeq[k] = aNewTable2D.myRows[j].myValues[k];
aTableOfReal->AddRow(aDoubleSeq.in());
aTableOfReal->SetRowTitle(j+1,aNewTable2D.myRows[j].myTitle.c_str());
aTableOfReal->SetRowUnit(j+1,aNewTable2D.myRows[j].myUnit.c_str());
}
- for(int k = 0; k < kEnd; k++){
+ for(int k = 0; k < kEnd; k++)
aTableOfReal->SetColumnTitle(k+1,aNewTable2D.myColumnTitles[k].c_str());
- //aTableOfReal->SetColumnUnit(k+1,aTable2D.myColumnUnits[k].c_str());
- }
}
return aFileObject;
}
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
// File : VISU_Table_i.hh
#define VISU_Table_i_HeaderFile
#include "VISU_PrsObject_i.hh"
-#include <qstringlist.h>
#include "Plot2d_Curve.h"
+#include <qstringlist.h>
+
namespace VISU{
//==============================================================================
class Table_i : public virtual POA_VISU::Table,
virtual Storable* Create();
virtual Storable* Restore( const Storable::TRestoringMap& theMap )
throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
virtual void ToStream( std::ostringstream& theStr );
static const string myComment;
virtual const char* GetComment() const;
virtual char* GetObjectEntry() { return CORBA::string_dup( myObjectEntry.c_str() ); }
};
- Storable* TableRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap);
SALOMEDS::SObject_var ImportTables(const char* theFileName, SALOMEDS::Study_ptr theStudy);
//==============================================================================
virtual Storable* Create();
virtual Storable* Restore( const Storable::TRestoringMap& theMap )
throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
virtual void ToStream( std::ostringstream& theStr );
static const string myComment;
virtual const char* GetComment() const;
virtual Plot2d_Curve* CreatePresentation();
};
- Storable* CurveRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap);
//==============================================================================
class Container_i : public virtual POA_VISU::Container,
virtual Storable* Create();
virtual Storable* Restore( const Storable::TRestoringMap& theMap )
throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
virtual void ToStream( std::ostringstream& theStr );
static const string myComment;
virtual const char* GetComment() const;
VISU::Curve_i* GetCurve( CORBA::Long theIndex );
};
- Storable* ContainerRestore(SALOMEDS::SObject_ptr theSObject,
- const string& thePrefix, const Storable::TRestoringMap& theMap);
}
-#endif // (#ifndef VISU_Table_i_HeaderFile)
+#endif
// Module : VISU
#include "VISU_TimeAnimation.h"
+#include "VISU_Result_i.hh"
+#include "VISU_Prs3d_i.hh"
+#include "VISU_Mesh_i.hh"
+#include "VISU_ScalarMap_i.hh"
+#include "VISU_IsoSurfaces_i.hh"
+#include "VISU_DeformedShape_i.hh"
+#include "VISU_CutPlanes_i.hh"
+#include "VISU_CutLines_i.hh"
+#include "VISU_Vectors_i.hh"
+#include "VISU_StreamLines_i.hh"
+#include "VISU_ViewManager_i.hh"
#include "VISU_ScalarBarActor.hxx"
+#include "VISU_Actor.h"
+
+#include "VTKViewer_ViewFrame.h"
+
+#include "QAD_Config.h"
+
+using namespace std;
//QWaitCondition myCondition;
static int MYDELAY = 1;
QString aMeshName = VISU::Storable::FindValue(aTimeMap,"myMeshName");
VISU::Entity anEntity = (VISU::Entity) VISU::Storable::FindValue(aTimeMap,"myEntityId").toInt();
QString aFieldName = VISU::Storable::FindValue(aTimeMap,"myFieldName");
- double aTimeStampId = VISU::Storable::FindValue(aTimeMap,"myTimeStampId").toDouble();
+ int aTimeStampId = VISU::Storable::FindValue(aTimeMap,"myTimeStampId").toInt();
switch (aData.myPrsType) {
case VISU::TSCALARMAP: // ScalarMap
case VISU::TVECTORS: // Vectors
{
VISU::Vectors_i* aPresent = new VISU::Vectors_i(pResult, false);
- aPresent->Create(aMeshName.latin1(), anEntity,
+ aPresent->Create(aMeshName.latin1(), anEntity,
aFieldName.latin1(), aTimeStampId);
//VISU::Vectors_var aTmp = aPresent->_this();
//aPresent->_remove_ref();
i++;
}
aData.myNbFrames = i;
- for (i = 0; i < aData.myNbFrames; i++)
- aData.myPrs[i]->SetRange(aMin, aMax);
+ QString aFixRange = QAD_CONFIG->getSetting("Visu:SBImposeRange");
+ if (aFixRange.compare("true") != 0) {
+ for (i = 0; i < aData.myNbFrames; i++)
+ aData.myPrs[i]->SetRange(aMin, aMax);
+ }
}
FieldData& aData = myFieldsLst[i];
aData.myActors = (VISU_Actor**) malloc(aData.myNbFrames * sizeof(VISU_Actor*));
for (long j = 0; j < aData.myNbFrames; j++) {
- VISU_Actor* aActor = aData.myPrs[j]->CreateActor();
- if (aActor == NULL) {
- aNoError = false;
- aActor = 0;
- myLastError += QString("%1 ").arg(aData.myTiming[j]);
- } else {
+ VISU_Actor* aActor = NULL;
+ try{
+ aActor = aData.myPrs[j]->CreateActor();
myView->AddActor(aActor);
- if (j == 0) {
+ if(j == 0)
aActor->VisibilityOn();
- } else
+ else
aActor->VisibilityOff();
+ }catch(std::runtime_error& exc){
+ aNoError = false;
+ myLastError += QString("%1 ").arg(aData.myTiming[j]);
}
aData.myActors[j] = aActor;
}
#ifndef VISU_TIMEANIMATION_H
#define VISU_TIMEANIMATION_H
+#include "VISUConfig.hh"
+
+class VTKViewer_ViewFrame;
+class VISU_Actor;
+
#include <qobject.h>
#include <qvaluelist.h>
#include <qthread.h>
-#include "VISU_Actor.h"
-#include "VISU_PrsObject_i.hh"
-#include "VISU_ViewManager_i.hh"
-#include "VTKViewer_ViewFrame.h"
+namespace VISU{
+ class Result_i;
+ class ScalarMap_i;
+}
struct FieldData
{
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Vectors_i.cc
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_VectorsPL.hxx"
+#include "VISU_Result_i.hh"
+#include "VISU_Vectors_i.hh"
+#include "VISU_VectorsAct.h"
+
+using namespace VISU;
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+int VISU::Vectors_i::IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ return DeformedShape_i::IsPossible(theResult,theMeshName,theEntity,theFieldName,theIteration);
+}
+
+
+int VISU::Vectors_i::myNbPresent = 0;
+QString VISU::Vectors_i::GenerateName() { return VISU::GenerateName("Vectors",myNbPresent++);}
+
+
+const string VISU::Vectors_i::myComment = "VECTORS";
+const char* VISU::Vectors_i::GetComment() const { return myComment.c_str();}
+
+
+VISU::Vectors_i::Vectors_i(Result_i* theResult, bool theAddToStudy) :
+ PrsObject_i(theResult->GetStudyDocument()),
+ Prs3d_i(theResult),
+ ScalarMap_i(theResult, theAddToStudy),
+ DeformedShape_i(theResult, theAddToStudy)
+{
+ myVectorsPL = NULL;
+}
+
+
+void VISU::Vectors_i::Destroy(){
+ DeformedShape_i::Destroy();
+}
+
+
+void VISU::Vectors_i::SameAs(const VISU::Vectors_i* theOrigin) {
+ Vectors_i* aVectors = const_cast<Vectors_i*>(theOrigin);
+ VISU::DeformedShape_i::SameAs(theOrigin);
+
+ SetLineWidth(aVectors->GetLineWidth());
+ //SetGlyphType(aVectors->GetGlyphType());
+ //SetGlyphPos(aVectors->GetGlyphPos());
+}
+
+
+VISU::Storable* VISU::Vectors_i::Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration)
+{
+ myLineWidth = 1.0;
+ return DeformedShape_i::Create(theMeshName,theEntity,theFieldName,theIteration);
+}
+
+
+VISU::Storable* VISU::Vectors_i::Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ DeformedShape_i::Restore(theMap);
+
+ SetGlyphType(VISU::Vectors::GlyphType(VISU::Storable::FindValue(theMap,"myTypeGlyph").toInt()));
+ SetGlyphPos(VISU::Vectors::GlyphPos(VISU::Storable::FindValue(theMap,"myPosGlyph").toInt()));
+ SetLineWidth(VISU::Storable::FindValue(theMap,"myLineWidth").toDouble());
+
+ return Build(true);
+}
+
+void VISU::Vectors_i::ToStream(std::ostringstream& theStr){
+ DeformedShape_i::ToStream(theStr);
+
+ Storable::DataToStream( theStr, "myTypeGlyph", int(GetGlyphType()));
+ Storable::DataToStream( theStr, "myPosGlyph", int(GetGlyphPos()));
+ Storable::DataToStream( theStr, "myLineWidth", GetLineWidth());
+}
+
+VISU::Storable* VISU::Vectors_i::Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&)
+{
+ VISU::Result_i* pResult = GetResult(theSObject);
+ if(pResult != NULL){
+ VISU::Vectors_i* pResent = new VISU::Vectors_i(pResult);
+ return pResent->Restore(theMap);
+ }
+ return NULL;
+}
+
+
+VISU::Vectors_i::~Vectors_i(){
+ if(MYDEBUG) MESSAGE("Vectors_i::~Vectors_i()");
+}
+
+
+void VISU::Vectors_i::SetLineWidth(CORBA::Double theWidth) {
+ myLineWidth = theWidth;
+}
+CORBA::Double VISU::Vectors_i::GetLineWidth() {
+ return myLineWidth;
+}
+
+
+void VISU::Vectors_i::SetGlyphType(VISU::Vectors::GlyphType theType) {
+ myVectorsPL->SetGlyphType(VISU_VectorsPL::GlyphType(theType));
+}
+VISU::Vectors::GlyphType VISU::Vectors_i::GetGlyphType() {
+ return VISU::Vectors::GlyphType(myVectorsPL->GetGlyphType());
+}
+
+
+void VISU::Vectors_i::SetGlyphPos(VISU::Vectors::GlyphPos thePos) {
+ myVectorsPL->SetGlyphPos(VISU_VectorsPL::GlyphPos(thePos));
+}
+VISU::Vectors::GlyphPos VISU::Vectors_i::GetGlyphPos() {
+ return VISU::Vectors::GlyphPos(myVectorsPL->GetGlyphPos());
+}
+
+
+void VISU::Vectors_i::DoHook(){
+ if(!myPipeLine) myPipeLine = VISU_VectorsPL::New();
+ myVectorsPL = dynamic_cast<VISU_VectorsPL*>(myPipeLine);
+
+ DeformedShape_i::DoHook();
+}
+
+
+VISU_PipeLine* VISU::Vectors_i::GetPipeLine(){
+ VISU_PipeLine* aPipeLine = VISU_VectorsPL::New();
+ aPipeLine->ShallowCopy(myPipeLine);
+ aPipeLine->Update();
+ return aPipeLine;
+}
+
+
+VISU_Actor* VISU::Vectors_i::CreateActor(const Handle(SALOME_InteractiveObject)& theIO)
+ throw (std::runtime_error&)
+{
+ VISU_VectorsAct* anActor = VISU_VectorsAct::New();
+ try{
+ VISU::Prs3d_i::CreateActor(anActor,theIO);
+ anActor->SetBarVisibility(true);
+ anActor->myFieldName = myFieldName;
+ anActor->GetProperty()->SetColor(myColor.R,myColor.G,myColor.B);
+ anActor->GetProperty()->SetLineWidth(GetLineWidth());
+ UpdateActor(anActor);
+ }catch(std::runtime_error& exc){
+ anActor->Delete();
+ throw exc;
+ }
+ return anActor;
+}
+
+
+void VISU::Vectors_i::UpdateActor(VISU_Actor* theActor){
+ if(VISU_VectorsAct* anActor = dynamic_cast<VISU_VectorsAct*>(theActor)){
+ VISU::DeformedShape_i::UpdateActor(anActor);
+ anActor->GetProperty()->SetLineWidth(GetLineWidth());
+ if(VISU_VectorsPL* aVectorsPL = dynamic_cast<VISU_VectorsPL*>(anActor->GetPipeLine())){
+ aVectorsPL->ShallowCopy(myPipeLine);
+ aVectorsPL->Update();
+ aVectorsPL->SetMapScale(myVectorsPL->GetMapScale());
+ }
+ }
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_PrsObject_i.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef VISU_Vectors_i_HeaderFile
+#define VISU_Vectors_i_HeaderFile
+
+#include "VISU_DeformedShape_i.hh"
+
+class VISU_VectorsPL;
+
+namespace VISU{
+ class Vectors_i : public virtual POA_VISU::Vectors,
+ public virtual DeformedShape_i
+ {
+ static int myNbPresent;
+ Vectors_i();
+ Vectors_i(const Vectors_i&);
+ public:
+ Vectors_i(Result_i* theResult, bool theAddToStudy = true);
+ virtual void SameAs(const Vectors_i* theOrigin);
+ virtual ~Vectors_i();
+ virtual void Destroy();
+
+ virtual VISU::VISUType GetType() { return VISU::TVECTORS;};
+
+ virtual void SetLineWidth(CORBA::Double theWidth);
+ virtual CORBA::Double GetLineWidth();
+
+ virtual void SetGlyphType(VISU::Vectors::GlyphType theType);
+ virtual VISU::Vectors::GlyphType GetGlyphType();
+
+ virtual void SetGlyphPos(VISU::Vectors::GlyphPos thePos);
+ virtual VISU::Vectors::GlyphPos GetGlyphPos();
+
+ typedef VISU::Vectors TInterface;
+ VISU_VectorsPL* GetVectorsPL(){ return myVectorsPL;}
+
+ protected:
+ virtual void DoHook();
+ virtual VISU_PipeLine* GetPipeLine();
+
+ VISU_VectorsPL *myVectorsPL;
+ float myLineWidth;
+
+ public:
+ static int IsPossible(Result_i* theResult, const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+ virtual Storable* Create(const char* theMeshName, VISU::Entity theEntity,
+ const char* theFieldName, int theIteration);
+
+ virtual void ToStream(std::ostringstream& theStr);
+
+ virtual Storable* Restore(const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+ static Storable* Restore(SALOMEDS::SObject_ptr theSObject,
+ const string& thePrefix, const Storable::TRestoringMap& theMap)
+ throw(std::logic_error&);
+
+
+ static const string myComment;
+ virtual const char* GetComment() const;
+ virtual QString GenerateName();
+
+ virtual VISU_Actor* CreateActor(const Handle(SALOME_InteractiveObject)& theIO = NULL)
+ throw (std::runtime_error&);
+ virtual void UpdateActor(VISU_Actor* theActor);
+ };
+}
+#endif
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
-// File : VISU_ViewManager_i.cxx
+// File : VISU_ViewManager_i.cc
// Author : Alexey PETROV
// Module : VISU
-using namespace std;
#include "VISU_ViewManager_i.hh"
+
#include "VISU_PrsObject_i.hh"
+#include "VISU_Result_i.hh"
+
+#include "VISU_Prs3d_i.hh"
+#include "VISU_Mesh_i.hh"
+#include "VISU_ScalarMap_i.hh"
+#include "VISU_IsoSurfaces_i.hh"
+#include "VISU_DeformedShape_i.hh"
+#include "VISU_CutPlanes_i.hh"
+#include "VISU_CutLines_i.hh"
+#include "VISU_Vectors_i.hh"
+#include "VISU_StreamLines_i.hh"
+
#include "VISU_Table_i.hh"
#include "VISU_ScalarBarActor.hxx"
#include "VISU_Actor.h"
#include "QAD_Study.h"
#include "QAD_RightFrame.h"
#include "QAD_StudyFrame.h"
-#include <qstring.h>
-#include <qfileinfo.h>
+#include "VTKViewer_ViewFrame.h"
#include "SALOMEGUI_TableDlg.h"
#include "Plot2d_CurveContainer.h"
#include "Plot2d_ViewFrame.h"
-//#include "SALOMEGUI_SetupCurveDlg.h"
-//#include "SALOMEGUI_SetupPlot2dDlg.h"
-#include "VTKViewer_ViewFrame.h"
+#include <memory>
+
+#include <qstring.h>
+#include <qfileinfo.h>
+
#include <vtkTransformPolyDataFilter.h>
#include <vtkDataSetMapper.h>
#include <vtkRenderer.h>
#include <vtkCamera.h>
-#include <memory>
+using namespace std;
-#ifdef DEBUG
+#ifdef _DEBUG_
static int MYDEBUG = 0;
#else
static int MYDEBUG = 0;
for(anActColl->InitTraversal(); (anActor = anActColl->GetNextActor()) != NULL;){
if(anActor->IsA("VISU_Actor")){
anVISUActor = VISU_Actor::SafeDownCast(anActor);
- if (thePrs == anVISUActor->getPrs3d()) {
+ if (thePrs == anVISUActor->GetPrs3d()) {
aResActor = anVISUActor->GetParent();
if(theDisplaing < eErase)
aResActor->VisibilityOn();
return aResActor;
}
if(thePrs != NULL && theDisplaing < eErase){
- anVISUActor = thePrs->CreateActor();
- if(anVISUActor)
+ try{
+ anVISUActor = thePrs->CreateActor();
vf->AddActor(anVISUActor);
- else{
- MESSAGE ("Null actor is created");
+ }catch(std::runtime_error& exc){
+ INFOS("Null actor is created");
return NULL;
}
}
return;
}
}
+
+
+ void ViewManager_i::ProcessEvents() {
+ while (true) {
+ qApp->lock();
+ qApp->syncX();
+ qApp->flushX();
+ qApp->processEvents();
+ qApp->unlock();
+ //sleep(1);
+ }
+ }
+
+
//===========================================================================
View_i::View_i(SALOMEDS::Study_ptr theStudy) {
if(MYDEBUG) MESSAGE("View_i::View_i");
void XYPlot_i::Update() {
if(MYDEBUG) MESSAGE("XYPlot_i::Update");
Mutex mt(myMutex,qApp,MYDELAY);
- myName = myStudyFrame->title();
+ myName = (const char*)(myStudyFrame->title());
myView->Repaint();
}
void XYPlot_i::Close(){
vtkActor *actor;
while(actor = theActors->GetNextActor()){
if(VISU_Actor* anActor = dynamic_cast<VISU_Actor*>(actor)){
- VISU::Prs3d_i* aPrs3d = anActor->getPrs3d();
+ VISU::Prs3d_i* aPrs3d = anActor->GetPrs3d();
if(anActor->GetVisibility() && aPrs3d){
aPrs3d->Update();
aPrs3d->UpdateActor(anActor);
-// Copyright (C) 2003 CEA/DEN, EDF R&D
+// VISU OBJECT : interactive object for VISU entities implementation
//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
-// File : VISU_ViewManager_i.hxx
+// File : VISU_ViewManager_i.hh
// Author : Alexey PETROV
// Module : VISU
#define VISU_ViewManager_i_HeaderFile
#include "VISUConfig.hh"
+
class QAD_Study;
class QAD_StudyFrame;
+
class VTKViewer_ViewFrame;
-class Plot2d_ViewFrame;
class SALOMEGUI_TableDlg;
+class Plot2d_ViewFrame;
+
class VISU_Actor;
+
class vtkRenderer;
class vtkCamera;
virtual TableView_ptr CreateTableView(VISU::Table_ptr theTable);
virtual XYPlot_ptr CreateXYPlot();
virtual void Destroy(View_ptr theView);
+ virtual void ProcessEvents();
protected:
SALOMEDS::Study_var myStudyDocument;
# Libraries targets
-LIB = libVisuGUI_Swigcmodule.la
-LIB_SRC =
+LIB = libVISU_Swigcmodule.la
+LIB_SRC = VISU_Gen_s.cc
+SWIG_FLAGS +=
-#SWIG_DEF = libVisuGUI_Swig.i
-#EXPORT_PYSCRIPTS = libVisuGUI_Swig.py visu.py visu_view3d.py batchmode_visu.py
-EXPORT_PYSCRIPTS = batchmode_visu.py batchmode_visu_table.py batchmode_visu_view3d.py \
+SWIG_DEF = libVISU_Swig.i
+EXPORT_PYSCRIPTS = libVISU_Swig.py batchmode_visu.py batchmode_visu_table.py batchmode_visu_view3d.py \
visu_med.py visu_view3d.py visu.py visu_gui.py visu_prs_example.py\
- visu_table.py visu_big_table.py visu_view.py
+ visu_table.py visu_big_table.py visu_view.py \
+ visu_swig_test.py
LIB_CLIENT_IDL =
-CPPFLAGS += $(PYTHON_INCLUDES) -DHAVE_CONFIG_H
-LDFLAGS += $(PYTHON_LIBS) -lVisuGUI
+CPPFLAGS += -ftemplate-depth-32 $(PYTHON_INCLUDES) $(QT_INCLUDES) \
+ $(VTK_INCLUDES) $(MED2_INCLUDES) $(HDF5_INCLUDES)
+LDFLAGS += $(PYTHON_LIBS) -lVisuConvertor -lVisuPipeLine
@CONCLUDE@
+
\ No newline at end of file
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Gen_s.cc
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_Gen_s.hh"
+
+#include "VISU_Convertor.hxx"
+#include "VISU_ScalarMapPL.hxx"
+
+#include <vtkUnstructuredGrid.h>
+#include <vtkDataSetMapper.h>
+
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderer.h>
+#include <vtkCamera.h>
+#include <vtkActor.h>
+
+using namespace std;
+
+Convertor::Convertor(const char* theFileName) : myConvertor(CreateConvertor(theFileName)){}
+
+
+ScalarMap::ScalarMap(Convertor* theConvertor, const char* theMeshName, int theEntity,
+ const char* theFieldName, int theIteration)
+ : myScalarMap(NULL)
+{
+ if(VISU_Convertor* aConvertor = theConvertor->GetImpl()){
+ vtkUnstructuredGrid* aDataSet =
+ aConvertor->GetTimeStampOnMesh(theMeshName,VISU::TEntity(theEntity),theFieldName,theIteration);
+ if(aDataSet){
+ myScalarMap = VISU_ScalarMapPL::New();
+ myScalarMap->SetInput(aDataSet);
+ myScalarMap->Build();
+ myScalarMap->Init();
+ myScalarMap->SetSourceRange();
+ }
+ }
+}
+
+
+View3D::View3D(){
+ myRen = vtkRenderer::New();
+ myRenWin = vtkRenderWindow::New();
+ myRenWin->AddRenderer(myRen);
+ myRenWin->SetSize(300, 300);
+ myRen->Delete();
+ myRen->GetActiveCamera()->ParallelProjectionOn();
+ myIRen = vtkRenderWindowInteractor::New();
+ myIRen->SetRenderWindow(myRenWin);
+ myRenWin->Delete();
+}
+
+void View3D::SetPosition(int theX, int theY) {
+ myRenWin->SetPosition(theX, theY);
+}
+
+View3D::~View3D(){
+ myIRen->Delete();
+}
+
+void View3D::Display(ScalarMap* theScalarMap){
+ if(VISU_ScalarMapPL* aScalarMap = theScalarMap->GetImpl()){
+ aScalarMap->Update();
+
+ myRen->RemoveAllProps();
+ vtkActor* anActor = vtkActor::New();
+ anActor->SetMapper(aScalarMap->GetMapper());
+
+ VISU_ScalarBarActor * aScalarBar = VISU_ScalarBarActor::New();
+ aScalarBar->SetLookupTable(aScalarMap->GetBarTable());
+
+ aScalarMap->Build();
+
+ myRen->AddActor(anActor);
+ myRen->AddActor2D(aScalarBar);
+ myRen->ResetCameraClippingRange();
+
+ myRenWin->Render();
+ }
+}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+// File : VISU_Gen_s.hh
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef __VISU_VISU_Gen_s_H__
+#define __VISU_VISU_Gen_s_H__
+
+class VISU_Convertor;
+class Convertor{
+ VISU_Convertor* myConvertor;
+public:
+ Convertor() : myConvertor(0) {};
+ Convertor(const char* theFileName);
+
+ VISU_Convertor* GetImpl(){ return myConvertor;}
+};
+
+class VISU_ScalarMapPL;
+class ScalarMap{
+ VISU_ScalarMapPL* myScalarMap;
+public:
+ ScalarMap() : myScalarMap(0) {};
+ ScalarMap(Convertor* theConvertor, const char* theMeshName, int theEntity,
+ const char* theFieldName, int theIteration);
+
+ VISU_ScalarMapPL* GetImpl(){ return myScalarMap;}
+};
+
+class vtkRenderer;
+class vtkRenderWindow;
+class vtkRenderWindowInteractor;
+class View3D{
+ vtkRenderer *myRen;
+ vtkRenderWindow *myRenWin;
+ vtkRenderWindowInteractor *myIRen;
+public:
+ View3D();
+ ~View3D();
+
+ void SetPosition(int theX, int theY);
+ void Display(ScalarMap* theScalarMap);
+};
+
+
+#endif
myVisu = visu.Initialize(orb,naming_service,lcc,myStudyManager,myStudy,10)
if myVisu is None:
raise RuntimeError, "myVisu is none, VISU component is not loaded or found"
+
+def try_mesh_parameters(theMeshPattern):
+ aResult = []
+ if theMeshPattern is None : return aResult ;
+ theMeshPattern = theMeshPattern._narrow(VISU.Mesh)
+ if theMeshPattern is None : return aResult ;
+
+ aTYPES = [VISU.POINT, VISU.WIREFRAME, VISU.SHADED, VISU.INSIDEFRAME, VISU.SHRINK]
+ import copy; import os;
+ for ind in aTYPES:
+ aNewMesh = copy.deepcopy(theMeshPattern);
+ aNewMesh.SetPresentationType(ind)
+ aResult.append(aNewMesh)
+
+ return aResult
+
+def try_scalarmap_parameters(thePattern, theNum):
+ aList = []
+ if thePattern is None : return aList
+ thePattern = thePattern._narrow(VISU.ScalarMap)
+ if thePattern is None : return aList
+ SCALING = [VISU.LINEAR, VISU.LOGARITHMIC]
+ import copy
+ import random
+ for ind in range(0,theNum):
+ anObj = copy.deepcopy(thePattern);
+ if ind%2 :
+ #try incorrect value deliberately (but allowed by idl description)
+ #try SetScalarMode(long)
+ mode = random.randint(-100000,100000); #incorrect value deliberately
+ else:
+ #correct value of ScalarMode
+ mode = random.randint(0, 3)
+
+ print "\tSetScalarMode(" + str(mode) +")"
+ anObj.SetScalarMode(mode)
+
+ # --- SCALING ---
+ scal = random.randint(0,1)
+ print "\tSetScaling(" + str(SCALING[scal]) +")"
+ anObj.SetScaling(SCALING[scal])
+
+ # --- BOUNDARIES ---
+ if ind%2 :
+ alfa = random.random()*random.randint(-100000,100000)
+ betta = random.random()*random.randint(-100000,100000)
+ aMin = alfa; aMax = betta
+ else:
+ #more correct set
+ aPMin = thePattern.GetMin()
+ aPMax = thePattern.GetMax()
+ aLen = aPMax - aPMin
+ alfa = random.random()%0.5
+ betta = random.random()%0.5
+ aMin = alfa*aLen*random.randint(-1,1) + aPMin
+ aMax = betta*aLen*random.randint(-1,1) + aPMax
+ print "\tSetRange(" + str(aMin) + ", " + str(aMax) + ")"
+ anObj.SetRange(aMin, aMax)
+ aList.append(anObj)
+
+ return aList
#medFile = "brideResultats.dat"
#myFieldName = "VM_Elem.";
-medFile = os.getenv('SALOME_ROOT_DIR') + '/../SALOME_ROOT/data/' + medFile
+medFile = os.getenv('SALOME_ROOT_DIR') + '/data/' + medFile
myResult = myVisu.ImportFile(medFile)
// $Header$
%module libVISU_Swig
+%{
+#include "VISU_Gen_s.hh"
+%}
-//%include "VisuGUI_Swig.i"
+
+class Convertor{
+public:
+ Convertor(){};
+ Convertor(const char* theFileName);
+};
+
+
+class ScalarMap{
+public:
+ ScalarMap(){};
+ ScalarMap(Convertor* theConvertor, const char* theMeshName, int theEntity,
+ const char* theFieldName, int theIteration);
+};
+
+class View3D{
+public:
+ View3D();
+ void Display(ScalarMap* theScalarMap);
+ void SetPosition(int theX, int theY);
+};
\ No newline at end of file
anAttr = aMeshSObj.FindAttribute("AttributeName")[1]
anAttr = anAttr._narrow(SALOMEDS.AttributeName);
aMeshName = anAttr.Value()
+ aMeshNamePic = re.sub(".","_",aMeshName)
print " ", aMeshName
aFolderIter = myLocalStudy.NewChildIterator(aMeshSObj);
anEntityId = "3"
if HasValue(thePrsTypeList,VISU.TMESH) :
- print " ", anEntityName,
+ print " ", anEntityName, aMeshName,
aMesh = theVisu.MeshOnEntity(theResult,aMeshName,anEntity)
if aMesh is None : print "Error"
else : print ",OK"
theView.DisplayOnly(aMesh)
theView.FitAll()
- aPictureName = thePictureDir + aMeshName + "_" + anEntityId + "." + thePictureExt
+ aPictureName = thePictureDir + aMeshNamePic + "_" + anEntityId + "." + thePictureExt
aPictureName = re.sub("\s+","_", aPictureName);
theView.SavePicture(aPictureName)
aVISUObjList.append(aMesh)
else : print ",OK"
theView.DisplayOnly(aMesh)
theView.FitAll()
- aPictureName = thePictureDir + aMeshName + "_" + anEntityId + "_" + anFamilyName + "." + thePictureExt
+ aPictureName = thePictureDir + aMeshNamePic + "_" + anEntityId + "_" + anFamilyName + "." + thePictureExt
aPictureName = re.sub("\s+","_", aPictureName);
theView.SavePicture(aPictureName)
aVISUObjList.append(aMesh)
else : print ",OK"
theView.DisplayOnly(aMesh)
theView.FitAll()
- aPictureName = thePictureDir + aMeshName + "_" + aGroupName + "." + thePictureExt
+ aPictureName = thePictureDir + aMeshNamePic + "_" + aGroupName + "." + thePictureExt
aPictureName = re.sub("\s+","_", aPictureName);
theView.SavePicture(aPictureName)
aVISUObjList.append(aMesh)
else : print ",OK"
theView.DisplayOnly(aPrsObj)
theView.FitAll()
- aPictureName = thePictureDir + aMeshName + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TSCALARMAP." + thePictureExt
+ aPictureName = thePictureDir + aMeshNamePic + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TSCALARMAP." + thePictureExt
aPictureName = re.sub("\s+","_", aPictureName);
theView.SavePicture(aPictureName)
aVISUObjList.append(aPrsObj)
else : print ",OK"
theView.DisplayOnly(aPrsObj)
theView.FitAll()
- aPictureName = thePictureDir + aMeshName + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TISOSURFACE." + thePictureExt
+ aPictureName = thePictureDir + aMeshNamePic + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TISOSURFACE." + thePictureExt
aPictureName = re.sub("\s+","_", aPictureName);
theView.SavePicture(aPictureName)
aVISUObjList.append(aPrsObj)
aPrsObj.SetOrientationType(VISU.CutPlanes.ZX)
theView.DisplayOnly(aPrsObj)
theView.FitAll()
- aPictureName = thePictureDir + aMeshName + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TCUTPLANES." + thePictureExt
+ aPictureName = thePictureDir + aMeshNamePic + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TCUTPLANES." + thePictureExt
aPictureName = re.sub("\s+","_", aPictureName)
theView.SavePicture(aPictureName)
aVISUObjList.append(aPrsObj)
aPrsObj.SetOrientationType2(VISU.CutPlanes.ZX)
theView.DisplayOnly(aPrsObj)
theView.FitAll()
- aPictureName = thePictureDir + aMeshName + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TCUTLINES." + thePictureExt
+ aPictureName = thePictureDir + aMeshNamePic + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TCUTLINES." + thePictureExt
aPictureName = re.sub("\s+","_", aPictureName)
theView.SavePicture(aPictureName)
aVISUObjList.append(aPrsObj)
else : print ",OK"
theView.DisplayOnly(aPrsObj)
theView.FitAll()
- aPictureName = thePictureDir + aMeshName + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TDEFORMEDSHAPE." + thePictureExt
+ aPictureName = thePictureDir + aMeshNamePic + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TDEFORMEDSHAPE." + thePictureExt
aPictureName = re.sub("\s+","_", aPictureName)
theView.SavePicture(aPictureName)
aVISUObjList.append(aPrsObj)
if HasValue(thePrsTypeList,VISU.TVECTORS) :
print " Creating VectorsOnField",
- aPrsObj = theVisu.VectorsOnField(theResult,aMeshName,anEntity,aFieldName,aTimeStampId)
+ aPrsObj = theVisu.VectorsOnField(theResult,aMeshNamePic,anEntity,aFieldName,aTimeStampId)
if aPrsObj is None : print "Error"
else : print ",OK"
theView.DisplayOnly(aPrsObj)
theView.FitAll()
- aPictureName = thePictureDir + aMeshName + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TVECTORS." + thePictureExt
+ aPictureName = thePictureDir + aMeshNamePic + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TVECTORS." + thePictureExt
aPictureName = re.sub("\s+","_", aPictureName)
theView.SavePicture(aPictureName)
aVISUObjList.append(aPrsObj)
else : print ",OK"
theView.DisplayOnly(aPrsObj)
theView.FitAll()
- aPictureName = thePictureDir + aMeshName + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TSTREAMLINES." + thePictureExt
+ aPictureName = thePictureDir + aMeshNamePic + "_" + anEntityId + "_" + aFieldName + "_" + str(aTimeStampId) + "_TSTREAMLINES." + thePictureExt
aPictureName = re.sub("\s+","_", aPictureName)
theView.SavePicture(aPictureName)
aVISUObjList.append(aPrsObj)
return "Study" + str(int)
else :
return prefix + str(int)
+
+
+
+# ----------------------
+# MESH
+# ----------------------
+def try_mesh_parameters(theMeshPattern):
+ aResult = []
+ if theMeshPattern is None : return aResult ;
+ theMeshPattern = theMeshPattern._narrow(VISU.Mesh)
+ if theMeshPattern is None : return aResult ;
+
+ aTYPES = [VISU.POINT, VISU.WIREFRAME, VISU.SHADED, VISU.INSIDEFRAME, VISU.SHRINK]
+ import copy; import os;
+ for ind in aTYPES:
+ aNewMesh = copy.deepcopy(theMeshPattern);
+ aNewMesh.SetPresentationType(ind)
+ aResult.append(aNewMesh)
+
+ return aResult
+
+
+# ----------------------------
+# SCALAR MAP
+# ----------------------------
+ind=1 #try safe way
+def try_scalarmap_parameters(thePattern, dump = 0):
+
+ if thePattern is None : return None
+
+ SCALING = [VISU.LINEAR, VISU.LOGARITHMIC]
+ import copy
+ import random
+
+ anObj = thePattern#copy.deepcopy(thePattern);
+ #ind = random.randint(1,2)
+ if ind%2 :
+ #try incorrect value deliberately (but allowed by idl description)
+ #try SetScalarMode(long)
+ mode = random.randint(-100000,100000); #incorrect value deliberately
+ else:
+ #correct value of ScalarMode
+ mode = random.randint(0, 3)
+
+ if dump : print "\tSetScalarMode(" + str(mode) +")"
+ anObj.SetScalarMode(mode)
+
+ # --- SCALING ---
+ scal = random.randint(0,1)
+ if dump : print "\tSetScaling(" + str(SCALING[scal]) +")"
+ anObj.SetScaling(SCALING[scal])
+
+ # --- BOUNDARIES ---
+ if ind%2 :
+ alfa = random.random()*random.randint(-100000,100000)
+ betta = random.random()*random.randint(-100000,100000)
+ aMin = alfa; aMax = betta
+ else:
+ #more correct set
+ aPMin = thePattern.GetMin()
+ aPMax = thePattern.GetMax()
+ aLen = aPMax - aPMin
+ alfa = random.random()%0.5
+ betta = random.random()%0.5
+ aMin = alfa*aLen*random.randint(-1,1) + aPMin
+ aMax = betta*aLen*random.randint(-1,1) + aPMax
+ if dump : print "\tSetRange(" + str(aMin) + ", " + str(aMax) + ")"
+ anObj.SetRange(aMin, aMax)
+
+ # --- POSITION ---
+ if ind%2:
+ X=random.random()*random.randint(-100000,100000)
+ Y=random.random()*random.randint(-100000,100000)
+ else :
+ X=random.random()
+ Y=random.random()
+ if dump : print "SetPosition("+ str(X) + ", " + str(Y) + " )"
+ anObj.SetPosition(X, Y)
+
+ # --- SCALAR BAR SIZE ---
+ if ind%2:
+ aWidth=random.random()*random.randint(-100000,100000)
+ aHeight=random.random()*random.randint(-100000,100000)
+ else :
+ aWidth=random.random()
+ aHeight=random.random()
+ if dump : print " SCALAR BAR Width = " + str(aWidth) + " Height = ", str(aHeight)
+ anObj.SetSize(aWidth, aHeight)
+
+ return anObj
+
+
+def dump_scalarmap_parameters(anObj):
+
+ print "\tGetScalarMode() = " + str(anObj.GetScalarMode())
+ print "\tGetScaling() = " + str(anObj.GetScaling())
+ print "\tGetMin() = " + str(anObj.GetMin()) + " GetMax() = " + str (anObj.GetMax())
+ print "\tGetOrientation() = " + str(anObj.GetOrientation())
+ print "\tGetPosX() = ", str(anObj.GetPosX()) + " GetPosY() = ", str(anObj.GetPosY())
+ print "\tGetWidth() = ", str ( anObj.GetWidth()) + " GetHeight() = " + str(anObj.GetHeight())
+
+# ----------------------
+# DEFORMED SHAPE
+# ----------------------
+def try_deformedshape_parameters(thePattern) :
+
+ if thePattern is None : return None
+ import copy
+ import random
+
+ anObj = try_scalarmap_parameters(thePattern)
+
+ # --- SCALING ---
+ if ind%2:
+ anObj.SetScale( random.random()*random.randint(-100000, 100000))
+ else :
+ anObj.SetScale( anObj.GetScale()*random.random())
+
+ return anObj
+
+
+def dump_deformedshape_parameters(theObject):
+ dump_scalarmap_parameters(theObject)
+ print "GetScale() = ", theObject.GetScale()
+
+# ----------------------
+# CUT PLANES
+# ----------------------
+def try_cutplanes_parameters(thePattern) :
+
+ if thePattern is None : return aList
+ import copy
+ import random
+
+ ORIENT = [VISU.CutPlanes.XY, VISU.CutPlanes.YZ, VISU.CutPlanes.ZX]
+
+ ind = random.randint(1,2)
+ anObj = try_scalarmap_parameters(thePattern)
+
+ # --- ORIENTATION ---
+ anObj.SetOrientationType(ORIENT[random.randint(0,2)])
+
+ # --- NUMBER OF PLANES ---
+ if ind%2 : anObj.SetNbPlanes(random.randint(-40,40))
+ else : anObj.SetNbPlanes(random.randint(0,10)) #try behaivor if NbPlanes=0
+
+ # --- DISPLACEMENT ---
+ anObj.SetDisplacement(random.randint(-100000,100000))
+
+ # --- PLANE POSITION ---
+ if ind%2:
+ PlaneNb = random.randint(-100000,100000) #incorrect value is possible
+ else : PlaneNb = random.randint(0, anObj.GetNbPlanes())
+
+ anObj.SetPlanePosition(PlaneNb, random.random()*random.randint(-100000,100000))
+
+ # --- SET DEFAULT ---
+ anObj.SetDefault(PlaneNb)
+
+ # --- SET X,Y,Z ROTATION ---
+ if ind%2 :
+ angle1 = random.random()*random.randint(-100000,100000)
+ angle2 = random.random()*random.randint(-100000,100000)
+ else :
+ angle1 = random.random()*3.14
+ angle2 = random.random()*3.14
+
+ anObj.SetRotateX(angle1)
+ anObj.SetRotateY(angle2)
+
+ return anObj
+
+def dump_cutplanes_parameters(theObject):
+ dump_saclarmap_parameters(theObject)
+
+ print "GetOrientationType = " + str(theObject.GetOrientationType())
+ PlanesNb = theObject.GetNbPlanes()
+ print "GetNbPlanes() = ", str(PlanesNb)
+ for i in range(0,PlanesNb+1):
+ if theObject.IsDefault(i) :
+ print "Default plane : "+str(i); break
+ print "GetPlanePosition(" + str(i) + ") = ", theObject.GetPlanePosition(i)
+ print "GetDisplacement() = ", str(theObject.GetDisplacement())
+ print "GetRotateX() = ", str(theObject.GetRotateX())
+ print "GetRotateY() = ", str(theObject.GetRotateY())
+ print "GetRotateZ() = ", str(theObject.GetRotateZ())
+
+# ----------------------
+# CUT LINES
+# ----------------------
+def try_cutlines_parameters(thePattern):
+
+ if thePattern is None : return None
+ import copy
+ import random
+
+ ORIENT = [VISU.CutPlanes.XY, VISU.CutPlanes.YZ, VISU.CutPlanes.ZX]
+ ind = random.randint(1,2)
+ anObj = try_scalarmap_parameters(thePattern)
+
+ # --- ORIENTATION ---
+ anObj.SetOrientationType(ORIENT[random.randint(0,2)])
+ anObj.SetOrientationType2(ORIENT[random.randint(0,2)])
+
+ # --- Base Plane Position ---
+ anObj.SetBasePlanePosition( random.random()*random.randint(-100000,100000))
+
+ # --- NUMBER OF LINES ---
+ if ind%2:
+ anObj.SetNbLines(random.randint(-5, 50))
+
+ # --- ROTATION ---
+ anObj.SetRotateX(random.randint(-100,100)*random.random())
+ anObj.SetRotateX2(random.randint(-100,100)*random.random())
+ anObj.SetRotateY(random.randint(-100,100)*random.random())
+ anObj.SetRotateY2(random.randint(-100,100)*random.random())
+
+ return anObj
+
+def dump_cutlines_parameters(theObject):
+ dump_scalarmap_parameters(theObject)
+
+ print "GetOrientationType() = " + str(theObject.GetOrientationType())
+ print "GetOrientationType2() = " + str(theObject.GetOrientationType2())
+ print "GetBasePlanePosition() = "+ str(theObject.GetBasePlanePosition())
+ print "GetNbLines() = " + str(theObject.GetNbLines())
+ print "GetRotateX() = ", str(theObject.GetRotateX())
+ print "GetRotateX2() = ", str(theObject.GetRotateX2())
+ print "GetRotateY() = ", str(theObject.GetRotateY())
+ print "GetRotateY2() = ", str(theObject.GetRotateY2())
+
+# ----------------------
+# STREAM LINES
+# ----------------------
+def try_streamlines_parameters(thePattern):
+
+ if thePattern is None : return None
+ import copy
+ import random
+
+ DIRECTION = [VISU.StreamLines.FORWARD, VISU.StreamLines.BACKWARD, VISU.StreamLines.BOTH]
+
+ ind = random.randint(1,2)
+ anObj = (try_deformedshape_parameters(thePattern))[0]
+
+ # --- DIREACTION ---
+ anObj.SetDirection(DIRECTION[random.randint(0,2)])
+
+ # --- STEP LENGTH ---
+ if ind%2 : anObj.SetStepLength(random.random()*random.randint(-1000,1000))
+ else :
+ aLen = anObj.GetMax() - anObj.GetMin()
+ anObj.SetStepLength(aLen/random.randint(1,100))
+
+ # --- PROPAGATION TIME ---
+ anObj.SetPropagationTime(random.random()*random.randint(1,100))
+
+ # --- INTEGRATION STEP ---
+ if ind%2 :
+ anObj.SetIntegrationStep(random.random()*random.randint(-1000,1000))
+ else:
+ anObj.SetIntegrationStep(random.random())
+
+ # --- USED POINT ---
+ anObj.SetUsedPoints(random.random()*random.randint(-10000,10000))
+
+ return anObj
+
+def dump_streamlines_parameters(theObject):
+
+ dump_deformedshape_parameters(theObject)
+
+ print "GetDirection() = " + str(theObject.GetDirection())
+ print "GetStepLength() = " + str(theObject.GetStepLength())
+ print "GetPropagationTime() =" + str(theObject.GetPropagationTime())
+ print "GetIntegrationStep() =" + str(theObject.GetIntegrationStep())
+ print "GetUsedPoints() =" + str(theObject.GetUsedPoints())
+
+# ----------------------
+# VECTORS
+# ----------------------
+def try_vectors_parameters(thePattern, theNum):
+
+ if thePattern is None : return None
+ import copy
+ import random
+ GLIPH_TYPE = [VISU.Vectors.ARROW, VISU.Vectors.CONE2, VISU.Vectors.CONE6, VISU.Vectors.NONE]
+ GLIPH_POS = [VISU.Vectors.CENTER, VISU.Vectors.TAIL, VISU.Vectors.HEAD]
+ ind = random.randint(1,2)
+ anObj = (try_deformedshape_parameters(thePattern))[0]
+
+ # --- LINE WIDTH ---
+ if ind%2 :
+ anObj.SetLineWidth(random.random()*random.randint(-10000,10000))
+ else :
+ anObj.SetLineWidth(random.randint(1, 10))
+
+ # --- GLIPH TYPE ---
+ anObj.SetGlyphType(GLIPH_TYPE[random.randint(0, len(GLIPH_TYPE)-1)])
+
+ # --- GLIPH POS ---
+ anObj.SetGlyphPos(GLIPH_POS[random.randint(0, len(GLIPH_POS)-1)])
+
+ return anObj
+
+def dump_vetctors_parameters(theObject):
+
+ dump_deformedshape_parameters(theObject)
+
+ print "GetLineWidth() = " +str(theObject.GetLineWidth())
+ print "GetGlyphType() = " +str(theObject.GetGlyphType())
+ print "GetGlyphPos() = " +str(theObject.GetGlyphPos())
+
+
+# ----------------------
+# ISO SURFACES
+# ----------------------
+
+def try_isosurfaces_parameters(thePattern) :
+ if thePattern is None : return None
+ import copy
+ import random
+
+ anObj = try_scalarmap_parameters(thePattern)
+ ind = random.randint(1,2)
+ # --- SURFACES NUMBER ---
+ if ind%2 :
+ anObj.SetNbSurfaces(random.randint(-100000,100000))
+ else:
+ anObj.SetNbSurfaces(random.randint(1, 50))
+
+ return anObj
+
+def dump_isosurfaces_parameters(theObject):
+
+ dump_scalarmap_parameters(theObject)
+ print "GetNbSurfaces() = "+ str(theObject.GetNbSurfaces())
med_comp = salome.lcc.FindOrLoadComponent("FactoryServer", "Med")
-medDir = os.getenv('SALOME_ROOT_DIR') + '/../SALOME_ROOT/data/'
+medDir = os.getenv('SALOME_ROOT_DIR') + '/data/'
def importMedFrom(medDir,medFile):
medFile = medDir + medFile
myVisu = visu_gui.myVisu
medFile = "pointe.med"
-medFile = os.getenv('SALOME_ROOT_DIR') + '/../SALOME_ROOT/data/' + medFile
+medFile = os.getenv('SALOME_ROOT_DIR') + '/data/' + medFile
print medFile
studyCurrent = salome.myStudyName
--- /dev/null
+from libVISU_Swig import *
+medFile = os.getenv('SALOME_ROOT_DIR') + '/data/fra.med'
+myCon=Convertor(medFile)
+myPrs=ScalarMap(myCon,"LE VOLUME",0,"VITESSE",1)
+myView=View3D()
+myView.Display(myPrs)
medFile = "fra.med"
myFieldName = "VITESSE";
-medFile = os.getenv('SALOME_ROOT_DIR') + '/../SALOME_ROOT/data/' + medFile
+medFile = os.getenv('SALOME_ROOT_DIR') + '/data/' + medFile
myResult = myVisu.ImportFile(medFile)
aMeshName ="LE VOLUME"
