From: nri Date: Tue, 14 Oct 2003 08:11:44 +0000 (+0000) Subject: sources v1.2c X-Git-Tag: V1_2c~3 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=17b175ff4b710fc93421509ffa7583edd1678a5d;p=modules%2Fvisu.git sources v1.2c --- diff --git a/src/CONVERTOR/Makefile.in b/src/CONVERTOR/Makefile.in new file mode 100644 index 00000000..69020189 --- /dev/null +++ b/src/CONVERTOR/Makefile.in @@ -0,0 +1,50 @@ +# 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@ diff --git a/src/CONVERTOR/VISUConvertor.cxx b/src/CONVERTOR/VISUConvertor.cxx new file mode 100644 index 00000000..c8b2e55a --- /dev/null +++ b/src/CONVERTOR/VISUConvertor.cxx @@ -0,0 +1,136 @@ +// 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 +#include +#include +#include +#include +#include +#include + +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<<"'"< 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"< 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"< + +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 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(); +} diff --git a/src/CONVERTOR/VISU_Convertor.hxx b/src/CONVERTOR/VISU_Convertor.hxx new file mode 100644 index 00000000..490ae99f --- /dev/null +++ b/src/CONVERTOR/VISU_Convertor.hxx @@ -0,0 +1,267 @@ +// 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef MESSAGE +#define MESSAGE(msg) std::cout< +#include +#include + +namespace VISU{ + class TVtkCellInfo{ + public: + TVtkCellInfo() {} + TVtkCellInfo(const char* theName, vtkIdType theSize) : + myName(theName), mySize(theSize) {} + const char* myName; + vtkIdType mySize; + }; + typedef std::map TVtkCellInfoMap; + extern TVtkCellInfoMap aVtkCellInfoMap; + + enum TEntity {NODE_ENTITY, EDGE_ENTITY, FACE_ENTITY, CELL_ENTITY}; + template 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 TVTKSource; + typedef vtk_ptr TVTKPoints; + + typedef std::set TBindGroups; + + struct TFamily{ + TVTKSource myStorage; + vtkIdType myId; + std::string myName; + TEntity myEntity; + TBindGroups myGroups; + vtkIdType myNbCells, myCellsSize; + typedef std::set TSubMeshOnCellType; + typedef std::map TSubMesh; + TSubMesh mySubMesh; + TFamily() : myNbCells(0), myCellsSize(0) {} + }; + typedef std::map TFamilyMap; + + struct TField{ + vtkIdType myId; + std::string myName; + TEntity myEntity; + std::string myMeshName; + vtkIdType myNbComp, myNbValField, myDataSize; + typedef std::vector TValForCellsWithType; + typedef std::map TValForCells; + typedef std::pair TTime; + typedef std::vector TCompNames; + typedef std::vector 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 TValField; + TValField myValField; + TCompNames myCompNames; + TUnitNames myUnitNames; + TField() : myNbComp(0), myNbValField(0), myDataSize(0) {} + void ShallowCopy(const TField& aField); + }; + typedef std::map TFieldMap; + + struct TMeshOnEntity{ + TVTKSource myStorage; + std::string myMeshName; + TEntity myEntity; + vtkIdType myNbCells, myCellsSize; + typedef std::vector TConnect; + typedef std::vector TConnForCellType; + typedef std::map TCellsConn; + TCellsConn myCellsConn; + TFamilyMap myFamilyMap; + TFieldMap myFieldMap; + TMeshOnEntity() : myNbCells(0), myCellsSize(0) {} + std::pair GetCellsDims(const std::string& theFamilyName = "") const + throw(std::runtime_error&); + }; + typedef std::map 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 TFamilyAndEntity; + typedef std::set TFamilyAndEntitySet; + struct TGroup{ + TVTKSource myStorage; + std::string myName; + std::string myMeshName; + vtkIdType myNbCells, myCellsSize; + TGroup() : myNbCells(0), myCellsSize(0) {} + TFamilyAndEntitySet myFamilyAndEntitySet; + }; + typedef std::map TGroupMap; + + struct TMesh{ + TVTKPoints myPoints; + vtkIdType myDim, myNbPoints; + std::string myName; + typedef float TCoord; + typedef std::vector TPointsCoord; + TPointsCoord myPointsCoord; + TMeshOnEntityMap myMeshOnEntityMap; + TGroupMap myGroupMap; + TMesh() : myDim(0), myNbPoints(0) {} + const TField* GetField(const std::string& theFieldName) const; + }; + typedef std::map 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 diff --git a/src/CONVERTOR/VISU_ConvertorUtils.cxx b/src/CONVERTOR/VISU_ConvertorUtils.cxx new file mode 100644 index 00000000..22cb5b2f --- /dev/null +++ b/src/CONVERTOR/VISU_ConvertorUtils.cxx @@ -0,0 +1,82 @@ +// 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 + +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; + } +} diff --git a/src/CONVERTOR/VISU_ConvertorUtils.hxx b/src/CONVERTOR/VISU_ConvertorUtils.hxx new file mode 100644 index 00000000..bc6dcad7 --- /dev/null +++ b/src/CONVERTOR/VISU_ConvertorUtils.hxx @@ -0,0 +1,67 @@ +// 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 +} + +#include +#include + +#include + +#include +#include + +template 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 diff --git a/src/CONVERTOR/VISU_Convertor_impl.cxx b/src/CONVERTOR/VISU_Convertor_impl.cxx new file mode 100644 index 00000000..8f6ed718 --- /dev/null +++ b/src/CONVERTOR/VISU_Convertor_impl.cxx @@ -0,0 +1,606 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +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 = '"<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 = '"<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 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 = "<second; + int aVtkType = aCellsConnIter->first; + if(MYDEBUG) MESSAGE("GetCellsOnEntity - aVtkType = "<> 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() = "<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 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 = "<> 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() = "<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 = "<SetName(aFieldName.c_str()); + if(MYDEBUG) MESSAGE("GetField - aNumberOfTuples = "<second; + int iEnd = anArray.size()/theField.myNbComp; + int aVtkType = aValForCellsIter->first; + if(MYDEBUG) MESSAGE("GetField - iEnd = "<> 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 = "<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 = "<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 = "<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 = "< +} + +#include +#include + +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 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 diff --git a/src/CONVERTOR/VISU_DatConvertor.cxx b/src/CONVERTOR/VISU_DatConvertor.cxx new file mode 100644 index 00000000..91151aff --- /dev/null +++ b/src/CONVERTOR/VISU_DatConvertor.cxx @@ -0,0 +1,253 @@ +// 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 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* pCellsType) + throw (std::runtime_error&) +{ + /* + ifstream &stmIn = *pStmIn; + vector& 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 = "<>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 = "< &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* pCellsType) + throw (std::runtime_error&) +{ + /* + ifstream &stmIn = *pStmIn; + vector& 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 - "<second; + if(MYDEBUG) MESSAGE("VISU_Convertor_impl::ToDatFile - aMeshName = "<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<first)<<"\t"; + const vector& aVector = anArray[j]; + int kEnd = aVector.size(); + for(int k = 0; k < kEnd; k++) + stmOut<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 = "<second; + VISU::TField::TValForTime::const_iterator jter = aValForTime.begin(); + stmOut<<(++i)<first).c_str(),i); + stmOut< + +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* aCellsType) + throw (std::runtime_error&); + int ImportField(ifstream*, int theNbPoints, vector* 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 diff --git a/src/CONVERTOR/VISU_MedConvertor.cxx b/src/CONVERTOR/VISU_MedConvertor.cxx new file mode 100644 index 00000000..9587f53f --- /dev/null +++ b/src/CONVERTOR/VISU_MedConvertor.cxx @@ -0,0 +1,711 @@ +// 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 +#include +#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 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 = "<> 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 num_elem(iNumElemEnd), num_fam_elem(iNumElemEnd); + valarray 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 = "<> 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 = "< anAttId(aNbAttrib), anAttVal(aNbAttrib); + valarray anAttDesc('\0',aNbAttrib*MED_TAILLE_DESC+1); + med_int aNbGroup = MEDnFam(fid,aMeshName,aFamInd,MED_GROUPE); + if(0 && MYDEBUG) + MESSAGE("ImportInfo - aFamInd = "<> MEDfamInfo"); + if(0 && MYDEBUG) + MESSAGE("ImportInfo - aFamilyNum = "<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() = "<second; + const string& aGroupName = aGroupMapIter->first; + if(MYDEBUG) MESSAGE("ImportInfo - aGroupName = '"<> MEDnChamp(fid,0)"); + if(MYDEBUG) MESSAGE("ImportInfo - iFieldEnd = "<> MEDnChamp(fid,i)"); + valarray aCompNames('\0',ncomp*MED_TAILLE_PNOM + 1); + valarray 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 = '"<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 = "<> MEDnEntMaa(...)"); + if(MYDEBUG) MESSAGE("LoadPoints - iNumElemEnd = "< num_elem(iNumElemEnd), num_fam_elem(iNumElemEnd); + valarray name_elem('\0',iNumElemEnd*MED_TAILLE_PNOM+1); + valarray name_coord('\0',theMesh.myDim*MED_TAILLE_PNOM+1); + valarray unit_coord('\0',theMesh.myDim*MED_TAILLE_PNOM+1); + valarray 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 = "< 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 = '"< 0) { + med_booleen iname_elem, inum_elem; + valarray num_elem(iNumElemEnd), num_fam_elem(iNumElemEnd); + valarray name_elem('\0',iNumElemEnd*MED_TAILLE_PNOM+1); + med_int aNbConnForElem = getNbMedConnect(aMedType,anEntity,aMesh.myDim); + if(MYDEBUG) MESSAGE("LoadCellsOnEntity - medName = "<> MEDelementsLire(...)"); + if(!isCellsLoaded){ + VISU::TMeshOnEntity::TConnForCellType& aConnForCellType = theMeshOnEntity.myCellsConn[aVtkType]; + aConnForCellType.resize(iNumElemEnd); + valarray 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 comp('\0',ncomp*MED_TAILLE_PNOM + 1); + valarray 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 = '"<> 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 = "< 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 valr(jEnd); + case MED_INT32 : //valarray valr(jEnd); + case MED_INT : { + valarray 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; +} diff --git a/src/CONVERTOR/VISU_MedConvertor.hxx b/src/CONVERTOR/VISU_MedConvertor.hxx new file mode 100644 index 00000000..742b0852 --- /dev/null +++ b/src/CONVERTOR/VISU_MedConvertor.hxx @@ -0,0 +1,50 @@ +// 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 +} + +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 diff --git a/src/Makefile.in b/src/Makefile.in index ec6a891e..c2cebf6e 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -32,6 +32,6 @@ VPATH=.:@srcdir@ @COMMENCE@ -SUBDIRS = OBJECT VISU_I VISUGUI VISU_SWIG +SUBDIRS = CONVERTOR PIPELINE OBJECT VISU_I VISUGUI VISU_SWIG @MODULE@ diff --git a/src/OBJECT/Makefile.in b/src/OBJECT/Makefile.in index 3e7a4fea..26a0b91b 100644 --- a/src/OBJECT/Makefile.in +++ b/src/OBJECT/Makefile.in @@ -32,13 +32,12 @@ VPATH=.:@srcdir@:@top_srcdir@/idl @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 = @@ -47,10 +46,6 @@ BIN = BIN_SRC = CPPFLAGS+= $(OCC_INCLUDES) $(VTK_INCLUDES) -LDFLAGS+= $(OCC_LIBS) $(VTK_LIBS) -lSalomeObject - -%_moc.cxx: %.h - $(MOC) $< -o $@ - +LDFLAGS+= $(VTK_LIBS) -lSalomeObject -lVisuPipeLine @CONCLUDE@ diff --git a/src/OBJECT/VISU_Actor.cxx b/src/OBJECT/VISU_Actor.cxx index 814ef814..6a2ccc10 100644 --- a/src/OBJECT/VISU_Actor.cxx +++ b/src/OBJECT/VISU_Actor.cxx @@ -26,32 +26,27 @@ // 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 #include +#include #include -#include #include -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; @@ -78,35 +73,57 @@ void VISU_Actor::setIO(const Handle(SALOME_InteractiveObject)& theIO){ 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(); @@ -137,16 +154,6 @@ float VISU_Actor::GetLineWidth(){ 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){ @@ -165,202 +172,3 @@ void VISU_Actor::highlight(Standard_Boolean highlight) { 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; -} - -//======================================================================= - diff --git a/src/OBJECT/VISU_Actor.h b/src/OBJECT/VISU_Actor.h index 641a9442..1d8b3418 100644 --- a/src/OBJECT/VISU_Actor.h +++ b/src/OBJECT/VISU_Actor.h @@ -26,23 +26,21 @@ // Module : VISU // $Header$ -using namespace std; - #ifndef VISU_ACTOR_H #define VISU_ACTOR_H #include "SALOME_Actor.h" + +#include #include 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) @@ -59,8 +57,11 @@ class VTKOCC_EXPORT VISU_Actor : public SALOME_Actor { 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); @@ -71,14 +72,12 @@ class VTKOCC_EXPORT VISU_Actor : public SALOME_Actor { 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(); @@ -89,9 +88,6 @@ class VTKOCC_EXPORT VISU_Actor : public SALOME_Actor { virtual void SetLineWidth(float theLineWidth); virtual float GetLineWidth(); - virtual void SetRepresentation(int theMode); - virtual int GetRepresentation(); - bool IsHighlighting; std::string myFieldName; @@ -100,82 +96,10 @@ class VTKOCC_EXPORT VISU_Actor : public SALOME_Actor { 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 - - diff --git a/src/OBJECT/VISU_MeshAct.cxx b/src/OBJECT/VISU_MeshAct.cxx new file mode 100644 index 00000000..eb9203b9 --- /dev/null +++ b/src/OBJECT/VISU_MeshAct.cxx @@ -0,0 +1,199 @@ +// 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 +#include +#include + +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(); + } +} diff --git a/src/OBJECT/VISU_MeshAct.h b/src/OBJECT/VISU_MeshAct.h new file mode 100644 index 00000000..ae5e6f51 --- /dev/null +++ b/src/OBJECT/VISU_MeshAct.h @@ -0,0 +1,76 @@ +// 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 diff --git a/src/OBJECT/VISU_ScalarMapAct.cxx b/src/OBJECT/VISU_ScalarMapAct.cxx new file mode 100644 index 00000000..30a7c4a7 --- /dev/null +++ b/src/OBJECT/VISU_ScalarMapAct.cxx @@ -0,0 +1,69 @@ +// 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); +} diff --git a/src/OBJECT/VISU_ScalarMapAct.h b/src/OBJECT/VISU_ScalarMapAct.h new file mode 100644 index 00000000..bae6e529 --- /dev/null +++ b/src/OBJECT/VISU_ScalarMapAct.h @@ -0,0 +1,59 @@ +// 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 diff --git a/src/OBJECT/VISU_VectorsAct.cxx b/src/OBJECT/VISU_VectorsAct.cxx new file mode 100644 index 00000000..2e823ab1 --- /dev/null +++ b/src/OBJECT/VISU_VectorsAct.cxx @@ -0,0 +1,79 @@ +// 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 + +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(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(theMapper)) + aMapper->SetInput(myPassFilter[3]->GetPolyDataOutput()); + else if(vtkPolyDataMapper* aMapper = dynamic_cast(theMapper)) + aMapper->SetInput(myPassFilter[3]->GetPolyDataOutput()); + } + vtkLODActor::SetMapper(theMapper); +} diff --git a/src/OBJECT/VISU_VectorsAct.h b/src/OBJECT/VISU_VectorsAct.h new file mode 100644 index 00000000..45e3c14f --- /dev/null +++ b/src/OBJECT/VISU_VectorsAct.h @@ -0,0 +1,55 @@ +// 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 diff --git a/src/PIPELINE/Makefile.in b/src/PIPELINE/Makefile.in new file mode 100644 index 00000000..ae6728c9 --- /dev/null +++ b/src/PIPELINE/Makefile.in @@ -0,0 +1,64 @@ +# 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@ diff --git a/src/PIPELINE/VISUPipeLine.cxx b/src/PIPELINE/VISUPipeLine.cxx new file mode 100644 index 00000000..1b5181a6 --- /dev/null +++ b/src/PIPELINE/VISUPipeLine.cxx @@ -0,0 +1,139 @@ +// 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 +#include + +#include +#include +#include +#include +#include + +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"< + +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(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 aPartPosition(1,thePartPosition); + vector aPartCondition(1,thePartCondition); + VISU_CutPlanesPL::CutWithPlanes(theAppendPolyData,theDataSet,theNbPlanes,theDir,theBounds, + aPartPosition,aPartCondition,theDisplacement); +} diff --git a/src/PIPELINE/VISU_CutLinesPL.hxx b/src/PIPELINE/VISU_CutLinesPL.hxx new file mode 100644 index 00000000..cc316781 --- /dev/null +++ b/src/PIPELINE/VISU_CutLinesPL.hxx @@ -0,0 +1,69 @@ +// 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 diff --git a/src/PIPELINE/VISU_CutPlanesPL.cxx b/src/PIPELINE/VISU_CutPlanesPL.cxx new file mode 100644 index 00000000..a6cb0665 --- /dev/null +++ b/src/PIPELINE/VISU_CutPlanesPL.cxx @@ -0,0 +1,311 @@ +// 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 +#include +#include + +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(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& thePlanePosition, + const vector& 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(); +} diff --git a/src/PIPELINE/VISU_CutPlanesPL.hxx b/src/PIPELINE/VISU_CutPlanesPL.hxx new file mode 100644 index 00000000..73b42cdf --- /dev/null +++ b/src/PIPELINE/VISU_CutPlanesPL.hxx @@ -0,0 +1,105 @@ +// 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 + +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& thePlanePosition, + const std::vector& 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 myPartPosition; + std::vector myPartCondition; +}; + +#endif diff --git a/src/PIPELINE/VISU_DeformedShapePL.cxx b/src/PIPELINE/VISU_DeformedShapePL.cxx new file mode 100644 index 00000000..e125c4f9 --- /dev/null +++ b/src/PIPELINE/VISU_DeformedShapePL.cxx @@ -0,0 +1,108 @@ +// 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 + +#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(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(); +} diff --git a/src/PIPELINE/VISU_DeformedShapePL.hxx b/src/PIPELINE/VISU_DeformedShapePL.hxx new file mode 100644 index 00000000..f555faef --- /dev/null +++ b/src/PIPELINE/VISU_DeformedShapePL.hxx @@ -0,0 +1,63 @@ +// 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 diff --git a/src/PIPELINE/VISU_Extractor.cxx b/src/PIPELINE/VISU_Extractor.cxx new file mode 100644 index 00000000..0b3f7859 --- /dev/null +++ b/src/PIPELINE/VISU_Extractor.cxx @@ -0,0 +1,107 @@ +// 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 +#include +#include +#include +#include + +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 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); + } +} diff --git a/src/PIPELINE/VISU_Extractor.hxx b/src/PIPELINE/VISU_Extractor.hxx new file mode 100644 index 00000000..6889b7a9 --- /dev/null +++ b/src/PIPELINE/VISU_Extractor.hxx @@ -0,0 +1,50 @@ +// 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 + +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 diff --git a/src/PIPELINE/VISU_FieldTransform.cxx b/src/PIPELINE/VISU_FieldTransform.cxx new file mode 100644 index 00000000..ea239eb2 --- /dev/null +++ b/src/PIPELINE/VISU_FieldTransform.cxx @@ -0,0 +1,159 @@ +// Copyright (C) 2003 CEA/DEN, EDF R&D +// +// +// +// File : VISU_FieldTransform.cxx +// Module : VISU + +#include "VISU_FieldTransform.hxx" +#include "SALOME_Transform.h" + +#include +#include +#include +#include +#include +#include + +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 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 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()); + } +} diff --git a/src/PIPELINE/VISU_FieldTransform.hxx b/src/PIPELINE/VISU_FieldTransform.hxx new file mode 100644 index 00000000..f1ce02de --- /dev/null +++ b/src/PIPELINE/VISU_FieldTransform.hxx @@ -0,0 +1,68 @@ +// 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 + +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 diff --git a/src/PIPELINE/VISU_IsoSurfacesPL.cxx b/src/PIPELINE/VISU_IsoSurfacesPL.cxx new file mode 100644 index 00000000..ecd27659 --- /dev/null +++ b/src/PIPELINE/VISU_IsoSurfacesPL.cxx @@ -0,0 +1,118 @@ +// 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 + +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(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(); +} diff --git a/src/PIPELINE/VISU_IsoSurfacesPL.hxx b/src/PIPELINE/VISU_IsoSurfacesPL.hxx new file mode 100644 index 00000000..6eeb4564 --- /dev/null +++ b/src/PIPELINE/VISU_IsoSurfacesPL.hxx @@ -0,0 +1,65 @@ +// 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 diff --git a/src/PIPELINE/VISU_LookupTable.cxx b/src/PIPELINE/VISU_LookupTable.cxx new file mode 100644 index 00000000..06f21c5a --- /dev/null +++ b/src/PIPELINE/VISU_LookupTable.cxx @@ -0,0 +1,579 @@ +// 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 +#include +#include + +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(v)); + } + else if (range[0] > range[1]) + { + v = logRange[0]; + } + else + { + v = logRange[1]; + } + } + else + { + if (v > 0) + { + v = log10(static_cast(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(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 +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(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(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(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(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((*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(cptr[0]*0.30 + cptr[1]*0.59 + + cptr[2]*0.11 + 0.5); + *output++ = static_cast(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(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((*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(cptr[0]*0.30 + cptr[1]*0.59 + + cptr[2]*0.11 + 0.5); + *output++ = static_cast(cptr[3]*alpha); + input += inIncr; + } + } + else // outFormat == VTK_LUMINANCE + { + while (--i >= 0) + { + cptr = VISU_LinearLookup(*input, table, maxIndex, shift, scale); + *output++ = static_cast(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 +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(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + return; + case VTK_UNSIGNED_CHAR: + VISU_LookupTableMapMag(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + return; + case VTK_SHORT: + VISU_LookupTableMapMag(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + return; + case VTK_UNSIGNED_SHORT: + VISU_LookupTableMapMag(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + return; + case VTK_INT: + VISU_LookupTableMapMag(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + return; + case VTK_UNSIGNED_INT: + VISU_LookupTableMapMag(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + return; + case VTK_LONG: + VISU_LookupTableMapMag(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + return; + case VTK_UNSIGNED_LONG: + VISU_LookupTableMapMag(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + return; + case VTK_FLOAT: + VISU_LookupTableMapMag(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + return; + case VTK_DOUBLE: + VISU_LookupTableMapMag(this,static_cast(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; iSetValue(i, bitArray->GetValue(id)); + } + VISU_LookupTableMapData(this, + static_cast(newInput->GetPointer(0)), + output,numberOfValues, + inputIncrement,outputFormat,myScale); + newInput->Delete(); + bitArray->Delete(); + } + break; + + case VTK_CHAR: + VISU_LookupTableMapData(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + break; + + case VTK_UNSIGNED_CHAR: + VISU_LookupTableMapData(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + break; + + case VTK_SHORT: + VISU_LookupTableMapData(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + break; + + case VTK_UNSIGNED_SHORT: + VISU_LookupTableMapData(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + break; + + case VTK_INT: + VISU_LookupTableMapData(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + break; + + case VTK_UNSIGNED_INT: + VISU_LookupTableMapData(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + break; + + case VTK_LONG: + VISU_LookupTableMapData(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + break; + + case VTK_UNSIGNED_LONG: + VISU_LookupTableMapData(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + break; + + case VTK_FLOAT: + VISU_LookupTableMapData(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + break; + + case VTK_DOUBLE: + VISU_LookupTableMapData(this,static_cast(input),output, + numberOfValues,inputIncrement,outputFormat,myScale); + break; + + default: + vtkErrorMacro(<< "MapImageThroughTable: Unknown input ScalarType"); + return; + } +} + diff --git a/src/PIPELINE/VISU_LookupTable.hxx b/src/PIPELINE/VISU_LookupTable.hxx new file mode 100644 index 00000000..769ba892 --- /dev/null +++ b/src/PIPELINE/VISU_LookupTable.hxx @@ -0,0 +1,35 @@ +// 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 + +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 diff --git a/src/PIPELINE/VISU_MeshPL.cxx b/src/PIPELINE/VISU_MeshPL.cxx new file mode 100644 index 00000000..4e3e92d2 --- /dev/null +++ b/src/PIPELINE/VISU_MeshPL.cxx @@ -0,0 +1,46 @@ +// 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 +#include +#include +#include + +vtkStandardNewMacro(VISU_MeshPL); + +VISU_MeshPL::VISU_MeshPL(){} + +void VISU_MeshPL::Build() { + myMapper->SetInput(myInput); +} + +void VISU_MeshPL::Init(){ +} diff --git a/src/PIPELINE/VISU_MeshPL.hxx b/src/PIPELINE/VISU_MeshPL.hxx new file mode 100644 index 00000000..27be219c --- /dev/null +++ b/src/PIPELINE/VISU_MeshPL.hxx @@ -0,0 +1,45 @@ +// 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 diff --git a/src/PIPELINE/VISU_PipeLine.cxx b/src/PIPELINE/VISU_PipeLine.cxx new file mode 100644 index 00000000..d4354e35 --- /dev/null +++ b/src/PIPELINE/VISU_PipeLine.cxx @@ -0,0 +1,110 @@ +// 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 +#include +#include + +#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("< theMinSize) + theSize /= 2; + else + return 0; + return theSize; +} diff --git a/src/PIPELINE/VISU_PipeLine.hxx b/src/PIPELINE/VISU_PipeLine.hxx new file mode 100644 index 00000000..21a8b24d --- /dev/null +++ b/src/PIPELINE/VISU_PipeLine.hxx @@ -0,0 +1,68 @@ +// 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 +#include +#include +#include + +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 diff --git a/src/PIPELINE/VISU_PipeLineUtils.cxx b/src/PIPELINE/VISU_PipeLineUtils.cxx new file mode 100644 index 00000000..f60c2cca --- /dev/null +++ b/src/PIPELINE/VISU_PipeLineUtils.cxx @@ -0,0 +1,36 @@ +// 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]; +} + diff --git a/src/PIPELINE/VISU_PipeLineUtils.hxx b/src/PIPELINE/VISU_PipeLineUtils.hxx new file mode 100644 index 00000000..a6242399 --- /dev/null +++ b/src/PIPELINE/VISU_PipeLineUtils.hxx @@ -0,0 +1,81 @@ +// 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 +#include +#include +#include + +#include +#include +#include +#include +#include + +#include + +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 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 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 + diff --git a/src/PIPELINE/VISU_ScalarBarActor.cxx b/src/PIPELINE/VISU_ScalarBarActor.cxx new file mode 100644 index 00000000..afa44bd7 --- /dev/null +++ b/src/PIPELINE/VISU_ScalarBarActor.cxx @@ -0,0 +1,607 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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; iNumberOfLabels; 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; iSetPoint(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; iSetPoint(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; iInsertNextCell(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; iNumberOfLabels; 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); +} diff --git a/src/PIPELINE/VISU_ScalarBarActor.hxx b/src/PIPELINE/VISU_ScalarBarActor.hxx new file mode 100644 index 00000000..be2f62ce --- /dev/null +++ b/src/PIPELINE/VISU_ScalarBarActor.hxx @@ -0,0 +1,164 @@ +// 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 + +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 diff --git a/src/PIPELINE/VISU_ScalarMapPL.cxx b/src/PIPELINE/VISU_ScalarMapPL.cxx new file mode 100644 index 00000000..5025d98e --- /dev/null +++ b/src/PIPELINE/VISU_ScalarMapPL.cxx @@ -0,0 +1,183 @@ +// 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(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); +} diff --git a/src/PIPELINE/VISU_ScalarMapPL.hxx b/src/PIPELINE/VISU_ScalarMapPL.hxx new file mode 100644 index 00000000..b5358285 --- /dev/null +++ b/src/PIPELINE/VISU_ScalarMapPL.hxx @@ -0,0 +1,86 @@ +// 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 diff --git a/src/PIPELINE/VISU_StreamLinesPL.cxx b/src/PIPELINE/VISU_StreamLinesPL.cxx new file mode 100644 index 00000000..fabf6993 --- /dev/null +++ b/src/PIPELINE/VISU_StreamLinesPL.cxx @@ -0,0 +1,260 @@ +// 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 +#include + +#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(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() = "<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); +} diff --git a/src/PIPELINE/VISU_StreamLinesPL.hxx b/src/PIPELINE/VISU_StreamLinesPL.hxx new file mode 100644 index 00000000..ab56a041 --- /dev/null +++ b/src/PIPELINE/VISU_StreamLinesPL.hxx @@ -0,0 +1,93 @@ +// 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 + +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 diff --git a/src/PIPELINE/VISU_UsedPointsFilter.cxx b/src/PIPELINE/VISU_UsedPointsFilter.cxx new file mode 100644 index 00000000..9e2e2612 --- /dev/null +++ b/src/PIPELINE/VISU_UsedPointsFilter.cxx @@ -0,0 +1,78 @@ +// 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 +#include +#include +#include +#include +#include + +#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(); +} diff --git a/src/PIPELINE/VISU_UsedPointsFilter.hxx b/src/PIPELINE/VISU_UsedPointsFilter.hxx new file mode 100644 index 00000000..273ab3d2 --- /dev/null +++ b/src/PIPELINE/VISU_UsedPointsFilter.hxx @@ -0,0 +1,49 @@ +// 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 + +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 diff --git a/src/PIPELINE/VISU_VectorsPL.cxx b/src/PIPELINE/VISU_VectorsPL.cxx new file mode 100644 index 00000000..786f7ec0 --- /dev/null +++ b/src/PIPELINE/VISU_VectorsPL.cxx @@ -0,0 +1,151 @@ +// 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 +#include +#include +#include + +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(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(); +} diff --git a/src/PIPELINE/VISU_VectorsPL.hxx b/src/PIPELINE/VISU_VectorsPL.hxx new file mode 100644 index 00000000..81a1f33b --- /dev/null +++ b/src/PIPELINE/VISU_VectorsPL.hxx @@ -0,0 +1,75 @@ +// 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 diff --git a/src/VISUGUI/Makefile.in b/src/VISUGUI/Makefile.in index 61fe864a..c8a519a8 100644 --- a/src/VISUGUI/Makefile.in +++ b/src/VISUGUI/Makefile.in @@ -65,7 +65,8 @@ LIB_SRC = VisuGUI.cxx \ VisuGUI_NonIsometricDlg.cxx \ VisuGUI_StreamLinesDlg.cxx \ VisuGUI_TimeAnimation.cxx \ - VisuGUI_CutLinesDlg.cxx + VisuGUI_CutLinesDlg.cxx \ + VisuGUI_FileDlg.cxx LIB_MOC = \ VisuGUI.h \ @@ -86,7 +87,8 @@ LIB_MOC = \ 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 \ @@ -104,8 +106,7 @@ LIB_SERVER_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@ diff --git a/src/VISUGUI/VisuGUI.cxx b/src/VISUGUI/VisuGUI.cxx index 104eb6f3..279b0a68 100644 --- a/src/VISUGUI/VisuGUI.cxx +++ b/src/VISUGUI/VisuGUI.cxx @@ -26,8 +26,29 @@ // 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" @@ -47,14 +68,6 @@ using namespace std; #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" @@ -81,6 +94,7 @@ using namespace std; #include "Plot2d_SetupPlot2dDlg.h" #include "Plot2d_ViewFrame.h" #include "VTKViewer_ViewFrame.h" +#include "VisuGUI_FileDlg.h" // QT Includes #define INCLUDE_MENUITEM_DEF @@ -122,7 +136,9 @@ static int MYCHECKTIME = 0; #endif #include -#ifdef DEBUG +using namespace std; + +#ifdef _DEBUG_ static int MYDEBUG = 0; static int MYDEBUGWITHFILES = 0; #else @@ -159,6 +175,75 @@ VISU::VISU_Gen_i* VisuGUI::GetVisuGen(){ 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() ; } @@ -273,23 +358,6 @@ int GetScalarMode(VISU::Result_i* theResult, const char* theFieldName){ 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 */ @@ -303,7 +371,7 @@ static int isStudyLocked(const SALOMEDS::Study_var& theStudy){ 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; @@ -316,22 +384,20 @@ static int checkLock(const SALOMEDS::Study_var& theStudy) { 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: @@ -532,22 +598,22 @@ bool VisuGUI::OnGUIEvent(int theCommandID, QAD_Desktop* parent) 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 @@ -587,7 +653,27 @@ bool VisuGUI::OnGUIEvent(int theCommandID, QAD_Desktop* parent) 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 { @@ -636,27 +722,6 @@ bool VisuGUI::OnGUIEvent(int theCommandID, QAD_Desktop* parent) } -/* ********************************************************************************* */ -/* 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 */ /* ********************************************************************************** */ @@ -675,7 +740,7 @@ void VisuGUI::ShowTrihedron(bool ShowThd){ /* ********************************************************************************** */ VisuGUI::~VisuGUI(){ - MESSAGE("VisuGUI::~VisuGUI"); + if(MYDEBUG) MESSAGE("VisuGUI::~VisuGUI"); } /* ********************************************************************************** */ @@ -684,34 +749,29 @@ 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; } @@ -719,7 +779,6 @@ bool VisuGUI::OnMousePress (QMouseEvent* pe, QAD_Desktop* parent, QAD_StudyFrame bool VisuGUI::OnMouseMove (QMouseEvent* pe, QAD_Desktop* parent, QAD_StudyFrame* studyFrame) { - VisuGUI::GetOrCreateVisuGUI(parent); return true; } @@ -727,17 +786,16 @@ bool VisuGUI::OnMouseMove (QMouseEvent* pe, QAD_Desktop* parent, QAD_StudyFrame* 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 : @@ -787,7 +845,21 @@ CREATEPRESENTATION(VisuGUI::CreateStreamLines); //===================================================================================== 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; } @@ -796,14 +868,14 @@ bool VisuGUI::setSettings(QAD_Desktop* parent) // 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::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(); @@ -815,21 +887,21 @@ void VisuGUI::DisplayPrs() { // is it Curve ? VISU::Curve_i* aCurve = dynamic_cast(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::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::GetServant(anObject)); if(aTable){ - MESSAGE("VisuGUI::DisplayPrs : Table object"); + if(MYDEBUG) MESSAGE("VisuGUI::DisplayPrs : Table object"); PlotTable(aTable, VISU::eDisplay ); return; } @@ -841,13 +913,13 @@ void VisuGUI::DisplayPrs() { // 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(aServant)){ - MESSAGE("VisuGUI::DisplayOnlyPrs : Prs3d object"); + if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyPrs : Prs3d object"); UpdateViewer(aPrsObject, true); VTKViewer_ViewFrame* vf = GetVtkViewFrame(); if (vf) { @@ -855,13 +927,13 @@ void VisuGUI::DisplayOnlyPrs() { vf->Repaint(); } }else if(VISU::Curve_i* aCurve = dynamic_cast(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(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(aServant)){ - MESSAGE("VisuGUI::DisplayOnlyPrs : Table object"); + if(MYDEBUG) MESSAGE("VisuGUI::DisplayOnlyPrs : Table object"); PlotTable(aTable, VISU::eDisplayOnly ); } } @@ -872,13 +944,13 @@ void VisuGUI::DisplayOnlyPrs() { // 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::GetServant(anObject)); if(aPrsObject){ - MESSAGE("VisuGUI::ErasePrs : Prs3d object"); + if(MYDEBUG) MESSAGE("VisuGUI::ErasePrs : Prs3d object"); ErasePrs(aPrsObject); VTKViewer_ViewFrame* vf = GetVtkViewFrame(); if (vf) { @@ -888,19 +960,19 @@ void VisuGUI::ErasePrs() { // is it Curve ? VISU::Curve_i* aCurve = dynamic_cast(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::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::GetServant(anObject)); if(aTable){ - MESSAGE("VisuGUI::ErasePrs : Table object"); + if(MYDEBUG) MESSAGE("VisuGUI::ErasePrs : Table object"); PlotTable(aTable, VISU::eErase ); } } @@ -912,7 +984,7 @@ void VisuGUI::ErasePrs() { //===================================================================================== 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() ) { @@ -927,7 +999,7 @@ void VisuGUI::DisplayManyPrs() // is it Prs3d object ? VISU::Prs3d_i* aPrsObject = dynamic_cast(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) { @@ -940,21 +1012,21 @@ void VisuGUI::DisplayManyPrs() // is it Curve ? VISU::Curve_i* aCurve = dynamic_cast(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::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::GetServant(aCORBAObject)); if(aTable){ - MESSAGE("VisuGUI::DisplayManyPrs : Table object"); + if(MYDEBUG) MESSAGE("VisuGUI::DisplayManyPrs : Table object"); PlotTable(aTable, VISU::eDisplay ); continue; } @@ -964,13 +1036,85 @@ void VisuGUI::DisplayManyPrs() } } +//===================================================================================== +// 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::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::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::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::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 ); @@ -986,7 +1130,7 @@ void VisuGUI::EraseManyPrs() // is it Prs3d object ? VISU::Prs3d_i* aPrsObject = dynamic_cast(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) { @@ -997,21 +1141,21 @@ void VisuGUI::EraseManyPrs() // is it Curve ? VISU::Curve_i* aCurve = dynamic_cast(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::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::GetServant(aCORBAObject)); if(aTable){ - MESSAGE("VisuGUI::EraseManyPrs : Table object"); + if(MYDEBUG) MESSAGE("VisuGUI::EraseManyPrs : Table object"); PlotTable(aTable, VISU::eErase ); continue; } @@ -1027,14 +1171,20 @@ void VisuGUI::EraseManyPrs() //===================================================================================== 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(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(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(); } @@ -1048,13 +1198,12 @@ void VisuGUI::RecreateActor(VISU::Prs3d_i* thePrs) { PrsName* aPrsObject = dynamic_cast(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(); \ @@ -1066,7 +1215,6 @@ void VisuGUI::RecreateActor(VISU::Prs3d_i* thePrs) { } \ } - void VisuGUI::EditPrs() { VISU::Prs3d_i* aPrs3d = GetSelectedPrs3d(); @@ -1099,7 +1247,15 @@ void VisuGUI::EditPrs() { 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); } @@ -1119,7 +1275,14 @@ void VisuGUI::EditScalarBar() { 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(); @@ -1158,7 +1321,6 @@ void VisuGUI::CreateMesh() { tr ("VISU_BUT_OK")); return; } - VISU::Storable::TRestoringMap aMap; SALOMEDS::GenericAttribute_var anAttr; if(aSObject->FindAttribute(anAttr, "AttributeComment")) { @@ -1176,20 +1338,24 @@ void VisuGUI::CreateMesh() { Utils_Timer timer; timer.Start(); #endif + VISU::Result_i* pResult = dynamic_cast(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 @@ -1205,92 +1371,90 @@ void VisuGUI::CreateMesh() { } 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::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::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"); } //===================================================================================== @@ -1299,48 +1463,54 @@ void VisuGUI::CreateManyMesh() //===================================================================================== 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(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); } @@ -1352,7 +1522,9 @@ void VisuGUI::MakeShrink() { 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::GetServant(anObject)); + PortableServer::Servant aServant = VISU::GetServant(anObject); + if(!aServant) return NULL; + return dynamic_cast(aServant); } void VisuGUI::ChageColor() { @@ -1364,13 +1536,13 @@ void VisuGUI::ChageColor() { NewColor(anActor); } -void VisuGUI::ChangeOutlineColor() { +void VisuGUI::ChangeWireframeColor() { VISU::Prs3d_i* aPrsObject = GetSelectedPrs3d(); if(!aPrsObject) return; - VISUMesh_Actor* anActor = dynamic_cast(GetActor(aPrsObject)); + VISU_MeshAct* anActor = dynamic_cast(GetActor(aPrsObject)); if (!anActor) return; - NewOutlineColor(anActor); + NewWireframeColor(anActor); } @@ -1394,7 +1566,6 @@ void VisuGUI::ChangeLines() { } 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 ) @@ -1463,7 +1634,6 @@ void VisuGUI::PlotTable( VISU::Table_i* table, int theDisplaying ) } 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 ) @@ -1519,7 +1689,6 @@ void VisuGUI::PlotCurve( VISU::Curve_i* theCurve, int theDisplaying ) } 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 ) @@ -1586,7 +1755,6 @@ void VisuGUI::PlotContainer( VISU::Container_i* container, int theDisplaying ) 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; @@ -1625,7 +1793,6 @@ void VisuGUI::ShowTable() { 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; @@ -1652,7 +1819,6 @@ void VisuGUI::CreateTable() { 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; @@ -1809,7 +1975,6 @@ void VisuGUI::PlotData() { 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; @@ -1867,7 +2032,6 @@ void VisuGUI::CurveProperties() { 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; @@ -1899,7 +2063,6 @@ void VisuGUI::DeletePrs() { 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; @@ -1931,7 +2094,6 @@ void VisuGUI::SaveViewParams() 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; @@ -2053,7 +2215,6 @@ void VisuGUI::TimeAnimation() { 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 ); @@ -2085,36 +2246,13 @@ void VisuGUI::ImportMedField() { 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; @@ -2154,6 +2292,99 @@ void VisuGUI::Rename() { } } +//===================================================================================== +// 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::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::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() @@ -2237,18 +2468,7 @@ void VisuGUI::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)); } //===================================================================================== @@ -2256,13 +2476,27 @@ void VisuGUI::InfoOnPoint(){ // 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"), @@ -2275,27 +2509,7 @@ void VisuGUI::InfoOnCell(){ // 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:"); } //===================================================================================== @@ -2303,27 +2517,44 @@ void VisuGUI::SelectPoint(){ // 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 ); - } } //===================================================================================== @@ -2332,7 +2563,6 @@ void VisuGUI::SelectCell(){ //===================================================================================== void VisuGUI::DefinePopup( QString & theContext, QString & theParent, QString & theObject ) { - VisuGUI::GetOrCreateVisuGUI(QAD_Application::getDesktop()); theObject = ""; theContext = ""; } @@ -2449,27 +2679,25 @@ bool VisuGUI::CustomPopup(QAD_Desktop* parent, QPopupMenu* thePopup, const QStri 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 = "<insertItem( "Erase", visuGUI, SLOT( EraseManyPrs () ) ); + thePopup->insertItem( "Display Only", visuGUI, SLOT( DisplayOnlyManyPrs() ) ); } } else if ( selMode == homoPresentations ) { @@ -2486,16 +2714,15 @@ bool VisuGUI::CustomPopup(QAD_Desktop* parent, QPopupMenu* thePopup, const QStri } 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 :: "<insertItem("Import From File", visuGUI, SLOT(ImportFromFile())); @@ -2508,6 +2735,7 @@ bool VisuGUI::CustomPopup(QAD_Desktop* parent, QPopupMenu* thePopup, const QStri 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 ) { @@ -2539,8 +2767,10 @@ bool VisuGUI::CustomPopup(QAD_Desktop* parent, QPopupMenu* thePopup, const QStri if( !CORBA::is_nil( aCnt ) ) { VISU::Container_i* container = dynamic_cast( 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 () ) ); @@ -2555,51 +2785,78 @@ bool VisuGUI::CustomPopup(QAD_Desktop* parent, QPopupMenu* thePopup, const QStri { VISU::Prs3d_i* aPrsObject = dynamic_cast(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) { @@ -2607,12 +2864,11 @@ bool VisuGUI::CustomPopup(QAD_Desktop* parent, QPopupMenu* thePopup, const QStri 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" && @@ -2620,18 +2876,24 @@ bool VisuGUI::CustomPopup(QAD_Desktop* parent, QPopupMenu* thePopup, const QStri 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())); @@ -2647,8 +2909,9 @@ bool VisuGUI::CustomPopup(QAD_Desktop* parent, QPopupMenu* thePopup, const QStri } 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() ) ); @@ -2734,14 +2997,10 @@ void VisuGUI::BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO) 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(); @@ -2752,34 +3011,28 @@ void VisuGUI::BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO) 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::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" @@ -2787,25 +3040,25 @@ 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); } @@ -2853,44 +3106,69 @@ extern "C" // 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(aPrs3d); + VISU::DeformedShape_i* aDeformedShape = dynamic_cast(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(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(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(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(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); + } } } } @@ -3054,7 +3332,6 @@ QString VisuGUI::getVisuOutputDir() /* ======================================================================================== */ 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; @@ -3074,7 +3351,7 @@ VISU::Result_i* VisuGUI::CreatePresent(SALOMEDS::SObject_var theField, VISU::Res #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){ \ @@ -3114,23 +3391,26 @@ bool FNAME(SALOMEDS::SObject_var theField) { \ 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; \ } \ @@ -3155,26 +3435,40 @@ void VisuGUI::ImportTablesFromFile(){ 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(); } } @@ -3187,32 +3481,46 @@ void VisuGUI::ImportFromFile(){ //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"), @@ -3265,7 +3573,7 @@ bool VisuGUI::TestObjectBrowser(SALOMEDS::SObject_var& objVisu ){ 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; @@ -3286,7 +3594,7 @@ VISU_Actor* VisuGUI::GetActor(VISU::Prs3d_i* thePrs, VTKViewer_ViewFrame* theVie vtkActorCollection *anActColl = vf->getRenderer()->GetActors(); for(anActColl->InitTraversal(); (anActor = anActColl->GetNextActor()) != NULL;) if(VISU_Actor* anVISUActor = dynamic_cast(anActor)) - if(thePrs == anVISUActor->getPrs3d()) + if(thePrs == anVISUActor->GetPrs3d()) return anVISUActor->GetParent(); return NULL; } @@ -3309,26 +3617,28 @@ VISU_Actor* VisuGUI::UpdateViewer(VISU::Prs3d_i* thePrs, bool theDispOnly){ 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() = "<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; } @@ -3375,27 +3685,26 @@ void VisuGUI::DeletePresentation(VISU::Prs3d_i* thePrs) { * 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(); diff --git a/src/VISUGUI/VisuGUI.h b/src/VISUGUI/VisuGUI.h index ad52d84f..1c97bbb9 100644 --- a/src/VISUGUI/VisuGUI.h +++ b/src/VISUGUI/VisuGUI.h @@ -39,31 +39,50 @@ #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 +class vtkRenderer; #include #include #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(); @@ -74,46 +93,53 @@ class VisuGUI : public QObject{ 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); @@ -135,12 +161,11 @@ class VisuGUI : public QObject{ 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 ); @@ -193,15 +218,18 @@ class VisuGUI : public QObject{ 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(); @@ -216,6 +244,8 @@ class VisuGUI : public QObject{ void DeletePrs(); void Rename(); + void RenameTable(); + void RenameContainer(); void Sweep(); void TimeAnimation(); @@ -227,9 +257,10 @@ class VisuGUI : public QObject{ void InfoOnPoint(); void InfoOnCell(); + void SelectPoint(); void SelectCell(); - + private : QDialog* myActiveDialogBox; int myState ; diff --git a/src/VISUGUI/VisuGUI_CutLinesDlg.cxx b/src/VISUGUI/VisuGUI_CutLinesDlg.cxx index ee1298cf..11b76c9a 100644 --- a/src/VISUGUI/VisuGUI_CutLinesDlg.cxx +++ b/src/VISUGUI/VisuGUI_CutLinesDlg.cxx @@ -9,44 +9,47 @@ // Module : VISU #include "VisuGUI_CutLinesDlg.h" -#include -#include -#include +#include "VISU_CutLines_i.hh" #include "QAD_Application.h" #include "QAD_Desktop.h" +#include +#include +#include +#include + +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 ); @@ -58,7 +61,16 @@ VisuGUI_CutLinesDlg::VisuGUI_CutLinesDlg() 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); @@ -66,20 +78,18 @@ VisuGUI_CutLinesDlg::VisuGUI_CutLinesDlg() 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 @@ -87,31 +97,44 @@ VisuGUI_CutLinesDlg::VisuGUI_CutLinesDlg() 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") ); @@ -127,86 +150,87 @@ VisuGUI_CutLinesDlg::VisuGUI_CutLinesDlg() 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++) @@ -232,9 +256,9 @@ void VisuGUI_CutLinesDlg::onPlaneSelect(int theId) { ((QRadioButton*)mySelPlane2->find(0))->setChecked(true); onCutSelect(0); } + setBaseDefault(); } - //------------------------------------------------------------------------------ void VisuGUI_CutLinesDlg::onCutSelect(int theId) { switch (theId) { @@ -250,4 +274,161 @@ void VisuGUI_CutLinesDlg::onCutSelect(int 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); + } } diff --git a/src/VISUGUI/VisuGUI_CutLinesDlg.h b/src/VISUGUI/VisuGUI_CutLinesDlg.h index fd2fdc64..9911d8da 100644 --- a/src/VISUGUI/VisuGUI_CutLinesDlg.h +++ b/src/VISUGUI/VisuGUI_CutLinesDlg.h @@ -11,10 +11,21 @@ #ifndef VISUGUI_CUTLINESDLG_H #define VISUGUI_CUTLINESDLG_H +#include "VisuGUI_ScalarBarDlg.h" + #include #include -#include "VISU_PrsObject_i.hh" -#include "VisuGUI_ScalarBarDlg.h" +#include +#include +#include +#include + +#include "SALOMEconfig.h" +#include CORBA_CLIENT_HEADER(VISU_Gen) + +namespace VISU{ + class CutLines_i; +} class VisuGUI_CutLinesDlg: public QDialog { @@ -22,7 +33,7 @@ class VisuGUI_CutLinesDlg: public QDialog public: VisuGUI_CutLinesDlg(); - ~VisuGUI_CutLinesDlg() {}; + ~VisuGUI_CutLinesDlg(); void initFromPrsObject(VISU::CutLines_i* thePrs); void storeToPrsObject(VISU::CutLines_i* thePrs); @@ -30,8 +41,10 @@ public: 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; @@ -39,6 +52,8 @@ private: QLabel* myRotXLbl; QLabel* myRotYLbl; QAD_SpinBoxDbl* myPosSpn; + QLineEdit* myBasePlanePos; + QCheckBox* myCBSetDef; QHButtonGroup* mySelPlane2; QAD_SpinBoxDbl* myNbSpn; @@ -47,5 +62,16 @@ private: 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 + diff --git a/src/VISUGUI/VisuGUI_CutPlanesDlg.cxx b/src/VISUGUI/VisuGUI_CutPlanesDlg.cxx index 0e87bf97..5b55f9cd 100644 --- a/src/VISUGUI/VisuGUI_CutPlanesDlg.cxx +++ b/src/VISUGUI/VisuGUI_CutPlanesDlg.cxx @@ -26,12 +26,21 @@ // Module : VISU // $Header$ -using namespace std; #include "VisuGUI_CutPlanesDlg.h" -#include +#include "VISU_CutPlanes_i.hh" + #include "QAD_Application.h" #include "QAD_Desktop.h" +#include +#include +#include +#include +#include +#include + +using namespace std; + /*! Constructor */ @@ -68,6 +77,17 @@ VisuGUI_CutPlanesDlg::VisuGUI_CutPlanesDlg() 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 ); @@ -117,26 +137,39 @@ VisuGUI_CutPlanesDlg::VisuGUI_CutPlanesDlg() 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 ); } @@ -145,6 +178,7 @@ VisuGUI_CutPlanesDlg::VisuGUI_CutPlanesDlg() */ VisuGUI_CutPlanesDlg::~VisuGUI_CutPlanesDlg() { + if(myCutPlanes) delete myCutPlanes; } @@ -153,6 +187,11 @@ void VisuGUI_CutPlanesDlg::initFromPrsObject(VISU::CutPlanes_i* thePrs) { 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) { @@ -161,7 +200,12 @@ 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); + } } /*! @@ -267,3 +311,87 @@ double VisuGUI_CutPlanesDlg::getRotation2() { 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); + } +} diff --git a/src/VISUGUI/VisuGUI_CutPlanesDlg.h b/src/VISUGUI/VisuGUI_CutPlanesDlg.h index 9432108f..c26532fa 100644 --- a/src/VISUGUI/VisuGUI_CutPlanesDlg.h +++ b/src/VISUGUI/VisuGUI_CutPlanesDlg.h @@ -29,6 +29,9 @@ #ifndef VISUGUI_CUTPLANESDLG_H #define VISUGUI_CUTPLANESDLG_H +#include "QAD_SpinBoxDbl.h" +#include "VisuGUI_ScalarBarDlg.h" + #include #include #include @@ -36,10 +39,13 @@ #include #include #include -#include "QAD_SpinBoxDbl.h" -#include "VISU_PrsObject_i.hh" -#include "VisuGUI_ScalarBarDlg.h" +#include +#include "SALOMEconfig.h" +#include CORBA_CLIENT_HEADER(VISU_Gen) +namespace VISU{ + class CutPlanes_i; +} class VisuGUI_CutPlanesDlg : public QDialog { @@ -62,8 +68,7 @@ public: void initFromPrsObject(VISU::CutPlanes_i* thePrs); void storeToPrsObject(VISU::CutPlanes_i* thePrs); - - + private: QLabel* LabelRot1; QLabel* LabelRot2; @@ -74,22 +79,18 @@ private: 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 - - - - - - - diff --git a/src/VISUGUI/VisuGUI_FileDlg.cxx b/src/VISUGUI/VisuGUI_FileDlg.cxx new file mode 100644 index 00000000..87672a24 --- /dev/null +++ b/src/VISUGUI/VisuGUI_FileDlg.cxx @@ -0,0 +1,106 @@ +// 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 +#include +#include +#include +#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(); +} + diff --git a/src/VISUGUI/VisuGUI_FileDlg.h b/src/VISUGUI/VisuGUI_FileDlg.h new file mode 100644 index 00000000..d3e2e59e --- /dev/null +++ b/src/VISUGUI/VisuGUI_FileDlg.h @@ -0,0 +1,43 @@ +// 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 + +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 diff --git a/src/VISUGUI/VisuGUI_IsoSurfacesDlg.cxx b/src/VISUGUI/VisuGUI_IsoSurfacesDlg.cxx index 3b3f8e3e..5977d5ee 100644 --- a/src/VISUGUI/VisuGUI_IsoSurfacesDlg.cxx +++ b/src/VISUGUI/VisuGUI_IsoSurfacesDlg.cxx @@ -26,25 +26,29 @@ // Module : VISU // $Header$ -using namespace std; #include "VisuGUI_IsoSurfacesDlg.h" -#include -#include +#include "VISU_IsoSurfaces_i.hh" + #include "QAD_Application.h" #include "QAD_Desktop.h" -#include #include "QAD_MessageBox.h" +#include + +#include +#include + +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 ); @@ -78,12 +82,21 @@ VisuGUI_IsoSurfacesDlg::VisuGUI_IsoSurfacesDlg() 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 ); @@ -93,7 +106,7 @@ VisuGUI_IsoSurfacesDlg::VisuGUI_IsoSurfacesDlg() GroupButtonsLayout->setAlignment( Qt::AlignTop ); GroupButtonsLayout->setSpacing( 6 ); GroupButtonsLayout->setMargin( 11 ); - + QPushButton* buttonOk = new QPushButton( tr( "&OK" ), GroupButtons, "buttonOk" ); buttonOk->setAutoDefault( TRUE ); buttonOk->setDefault( TRUE ); @@ -105,38 +118,66 @@ VisuGUI_IsoSurfacesDlg::VisuGUI_IsoSurfacesDlg() 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); } diff --git a/src/VISUGUI/VisuGUI_IsoSurfacesDlg.h b/src/VISUGUI/VisuGUI_IsoSurfacesDlg.h index b6658369..24e74cb8 100644 --- a/src/VISUGUI/VisuGUI_IsoSurfacesDlg.h +++ b/src/VISUGUI/VisuGUI_IsoSurfacesDlg.h @@ -34,9 +34,12 @@ #include #include #include -#include "VISU_PrsObject_i.hh" +#include #include +namespace VISU{ + class IsoSurfaces_i; +} class VisuGUI_IsoSurfacesDlg : public QDialog { @@ -45,17 +48,20 @@ 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 diff --git a/src/VISUGUI/VisuGUI_MagnitudeDlg.cxx b/src/VISUGUI/VisuGUI_MagnitudeDlg.cxx index 28c0f1af..c8f38d87 100644 --- a/src/VISUGUI/VisuGUI_MagnitudeDlg.cxx +++ b/src/VISUGUI/VisuGUI_MagnitudeDlg.cxx @@ -26,12 +26,16 @@ // Module : VISU // $Header$ -using namespace std; #include "VisuGUI_MagnitudeDlg.h" -#include +#include "VISU_DeformedShape_i.hh" + #include "QAD_Application.h" #include "QAD_Desktop.h" +#include + +using namespace std; + /*! Constructor */ @@ -104,12 +108,12 @@ VisuGUI_MagnitudeDlg::~VisuGUI_MagnitudeDlg() 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()); } diff --git a/src/VISUGUI/VisuGUI_MagnitudeDlg.h b/src/VISUGUI/VisuGUI_MagnitudeDlg.h index c1436aea..37c7609c 100644 --- a/src/VISUGUI/VisuGUI_MagnitudeDlg.h +++ b/src/VISUGUI/VisuGUI_MagnitudeDlg.h @@ -34,8 +34,12 @@ #include #include #include + #include "QAD_SpinBoxDbl.h" -#include "VISU_PrsObject_i.hh" + +namespace VISU{ + class DeformedShape_i; +} class VisuGUI_MagnitudeDlg : public QDialog { diff --git a/src/VISUGUI/VisuGUI_NonIsometricDlg.cxx b/src/VISUGUI/VisuGUI_NonIsometricDlg.cxx index df3f1c27..a6c14ba1 100644 --- a/src/VISUGUI/VisuGUI_NonIsometricDlg.cxx +++ b/src/VISUGUI/VisuGUI_NonIsometricDlg.cxx @@ -9,26 +9,29 @@ // Module : VISU // $Header$ -using namespace std; #include "VisuGUI_NonIsometricDlg.h" +#include "VISU_Actor.h" +#include "VISU_PipeLine.hxx" -#include -#include -#include -#include #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 +#include +#include +#include + +using namespace std; + /*! Constructor */ diff --git a/src/VISUGUI/VisuGUI_ScalarBarDlg.cxx b/src/VISUGUI/VisuGUI_ScalarBarDlg.cxx index 1694a48d..3a2691ce 100644 --- a/src/VISUGUI/VisuGUI_ScalarBarDlg.cxx +++ b/src/VISUGUI/VisuGUI_ScalarBarDlg.cxx @@ -26,17 +26,22 @@ // Module : VISU // $Header$ -using namespace std; #include "VisuGUI_ScalarBarDlg.h" -#include -#include -#include +#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 +#include +#include + +using namespace std; + /*! Constructor */ @@ -418,6 +423,7 @@ void VisuGUI_ScalarBarDlg::storeToResources() { * Initialise dialog box from presentation object */ void VisuGUI_ScalarBarDlg::initFromPrsObject(VISU::ScalarMap_i* thePrs) { + initFromResources(); myModeCombo->setCurrentItem(thePrs->GetScalarMode()); setPosAndSize( thePrs->GetPosX(), thePrs->GetPosY(), @@ -432,10 +438,10 @@ void VisuGUI_ScalarBarDlg::initFromPrsObject(VISU::ScalarMap_i* thePrs) { 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); @@ -451,19 +457,19 @@ void VisuGUI_ScalarBarDlg::storeToPrsObject(VISU::ScalarMap_i* thePrs) { 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(); } diff --git a/src/VISUGUI/VisuGUI_ScalarBarDlg.h b/src/VISUGUI/VisuGUI_ScalarBarDlg.h index a1706e82..7c2cf9bb 100644 --- a/src/VISUGUI/VisuGUI_ScalarBarDlg.h +++ b/src/VISUGUI/VisuGUI_ScalarBarDlg.h @@ -29,6 +29,8 @@ #ifndef VISUGUI_SCALARBARDLG_H #define VISUGUI_SCALARBARDLG_H +#include "QAD_SpinBoxDbl.h" + #include #include #include @@ -40,9 +42,9 @@ #include #include -#include "QAD_SpinBoxDbl.h" -#include "VISU_PrsObject_i.hh" - +namespace VISU{ + class ScalarMap_i; +} class VisuGUI_ScalarBarDlg : public QDialog { diff --git a/src/VISUGUI/VisuGUI_Selection.cxx b/src/VISUGUI/VisuGUI_Selection.cxx index ff359e22..4bd329a6 100644 --- a/src/VISUGUI/VisuGUI_Selection.cxx +++ b/src/VISUGUI/VisuGUI_Selection.cxx @@ -48,24 +48,6 @@ using namespace std; #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 void SetMessage(TData* theData, int theId, TDialog* theDialog){ // Scalar result QString Msg_1; @@ -90,12 +72,11 @@ template void SetMessage(TData* theData, int theId, // 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(); @@ -115,9 +96,9 @@ void VisuGUI_Selection::PickingCell(QAD_Study *theActiveStudy, vtkDataSet *theDa 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; @@ -129,20 +110,19 @@ void VisuGUI_Selection::PickingCell(QAD_Study *theActiveStudy, vtkDataSet *theDa // 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; @@ -152,6 +132,6 @@ void VisuGUI_Selection::PickingPoint(QAD_Study *theActiveStudy, vtkDataSet *theD 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); } diff --git a/src/VISUGUI/VisuGUI_Selection.h b/src/VISUGUI/VisuGUI_Selection.h index 09e43574..0148a53b 100644 --- a/src/VISUGUI/VisuGUI_Selection.h +++ b/src/VISUGUI/VisuGUI_Selection.h @@ -41,8 +41,8 @@ #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); }; diff --git a/src/VISUGUI/VisuGUI_StreamLinesDlg.cxx b/src/VISUGUI/VisuGUI_StreamLinesDlg.cxx index 44e46939..50334711 100644 --- a/src/VISUGUI/VisuGUI_StreamLinesDlg.cxx +++ b/src/VISUGUI/VisuGUI_StreamLinesDlg.cxx @@ -9,16 +9,26 @@ // Module : VISU #include "VisuGUI_StreamLinesDlg.h" -#include -#include -#include -#include +#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 +#include +#include +#include +using namespace std; extern VisuGUI *visuGUI; @@ -39,11 +49,18 @@ VisuGUI_StreamLinesDlg::VisuGUI_StreamLinesDlg() 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(); @@ -52,21 +69,67 @@ VisuGUI_StreamLinesDlg::VisuGUI_StreamLinesDlg() 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; + } } } } @@ -74,8 +137,7 @@ VisuGUI_StreamLinesDlg::VisuGUI_StreamLinesDlg() } } } - - 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); @@ -92,19 +154,20 @@ VisuGUI_StreamLinesDlg::VisuGUI_StreamLinesDlg() 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); @@ -151,9 +214,15 @@ VisuGUI_StreamLinesDlg::VisuGUI_StreamLinesDlg() 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); @@ -164,39 +233,48 @@ void VisuGUI_StreamLinesDlg::initFromPrsObject(VISU::StreamLines_i* thePrs) { 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::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::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); @@ -207,19 +285,51 @@ void VisuGUI_StreamLinesDlg::storeToPrsObject(VISU::StreamLines_i* thePrs) { 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()); } /*! @@ -260,8 +370,121 @@ void VisuGUI_StreamLinesDlg::enableSetColor() 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::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(); +} diff --git a/src/VISUGUI/VisuGUI_StreamLinesDlg.h b/src/VISUGUI/VisuGUI_StreamLinesDlg.h index 1e1d9788..0b9c78b6 100644 --- a/src/VISUGUI/VisuGUI_StreamLinesDlg.h +++ b/src/VISUGUI/VisuGUI_StreamLinesDlg.h @@ -11,12 +11,19 @@ #ifndef VISUGUI_STREAMLINESDLG_H #define VISUGUI_STREAMLINESDLG_H +#include "QAD_SpinBoxDbl.h" + #include #include #include -#include "QAD_SpinBoxDbl.h" -#include "VISU_PrsObject_i.hh" +#include +#include "SALOMEconfig.h" +#include CORBA_CLIENT_HEADER(VISU_Gen) + +namespace VISU{ + class StreamLines_i; +} class VisuGUI_StreamLinesDlg: public QDialog { @@ -32,9 +39,14 @@ public: 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; @@ -42,10 +54,19 @@ private: QCheckBox* myUseScalar; QPushButton* SelColor; QColor myColor; - QCheckBox* myUseSrcChk; + //QCheckBox* myUseSrcChk; + QComboBox* myUseSrcCombo; QAD_SpinBoxDbl* myPntPercent; QComboBox* mySrcCombo; QValueList myPrsList; + QValueList myEntityList; + QValueList myFamilyList; + QValueList myGroupList; + QStringList myEntitiesLst; + QStringList myFamilisLst; + QStringList myGroupsLst; + QStringList myPrsLst; + SALOMEDS::SObject_var mySelectionObj; private slots: void setVColor(); diff --git a/src/VISUGUI/VisuGUI_TimeAnimation.cxx b/src/VISUGUI/VisuGUI_TimeAnimation.cxx index 2c971c41..3d1f175d 100644 --- a/src/VISUGUI/VisuGUI_TimeAnimation.cxx +++ b/src/VISUGUI/VisuGUI_TimeAnimation.cxx @@ -35,8 +35,15 @@ #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) @@ -632,6 +639,12 @@ void VisuGUI_TimeAnimationDlg::createFrames() { 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()) { @@ -648,7 +661,7 @@ void VisuGUI_TimeAnimationDlg::createFrames() { //************************************************************************ void VisuGUI_TimeAnimationDlg::onPlayPressed() { - if (myPlayBtn->isOn()) { + if (myPlayBtn->isOn() && (!myAnimator->running())) { myPlayBtn->setIconSet(MYpausePixmap); if (mySaveCheck->isChecked()) myAnimator->dumpTo(myPathEdit->text()); diff --git a/src/VISUGUI/VisuGUI_TimeAnimation.h b/src/VISUGUI/VisuGUI_TimeAnimation.h index 9ae881e7..35f0d625 100644 --- a/src/VISUGUI/VisuGUI_TimeAnimation.h +++ b/src/VISUGUI/VisuGUI_TimeAnimation.h @@ -19,8 +19,12 @@ #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 diff --git a/src/VISUGUI/VisuGUI_VectorsDlg.cxx b/src/VISUGUI/VisuGUI_VectorsDlg.cxx index 174ee491..2e471d3f 100644 --- a/src/VISUGUI/VisuGUI_VectorsDlg.cxx +++ b/src/VISUGUI/VisuGUI_VectorsDlg.cxx @@ -26,13 +26,17 @@ // Module : VISU // $Header$ -using namespace std; #include "VisuGUI_VectorsDlg.h" -#include -#include +#include "VISU_Vectors_i.hh" + #include "QAD_Application.h" #include "QAD_Desktop.h" +#include +#include + +using namespace std; + /*! Constructor */ @@ -178,7 +182,7 @@ VisuGUI_VectorsDlg::~VisuGUI_VectorsDlg() 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); @@ -197,8 +201,8 @@ void VisuGUI_VectorsDlg::initFromPrsObject(VISU::Vectors_i* thePrs) { 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.; diff --git a/src/VISUGUI/VisuGUI_VectorsDlg.h b/src/VISUGUI/VisuGUI_VectorsDlg.h index 68f560f8..d66af017 100644 --- a/src/VISUGUI/VisuGUI_VectorsDlg.h +++ b/src/VISUGUI/VisuGUI_VectorsDlg.h @@ -29,6 +29,8 @@ #ifndef VISUGUI_VECTORSDLG_H #define VISUGUI_VECTORSDLG_H +#include "QAD_SpinBoxDbl.h" + #include #include #include @@ -37,9 +39,12 @@ #include #include #include -#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 { diff --git a/src/VISUGUI/VisuGUI_VisuAsDlg.cxx b/src/VISUGUI/VisuGUI_VisuAsDlg.cxx index 3de24794..9b0341c4 100644 --- a/src/VISUGUI/VisuGUI_VisuAsDlg.cxx +++ b/src/VISUGUI/VisuGUI_VisuAsDlg.cxx @@ -26,15 +26,20 @@ // 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 +using namespace std; + /*! Constructor */ @@ -175,7 +180,7 @@ void VisuGUI_VisuAsDlg::RefreshListActors( const QString &VAType ) */ 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()){ diff --git a/src/VISUGUI/VisuGUI_VisuAsDlg.h b/src/VISUGUI/VisuGUI_VisuAsDlg.h index 62fa0ff7..d166aace 100644 --- a/src/VISUGUI/VisuGUI_VisuAsDlg.h +++ b/src/VISUGUI/VisuGUI_VisuAsDlg.h @@ -29,8 +29,6 @@ #ifndef VISUGUI_VISUASDLG_H #define VISUGUI_VISUASDLG_H -#include "VISU_Actor.h" - #include #include #include @@ -38,6 +36,8 @@ #include #include +class VISU_Actor; + class VisuGUI_VisuAsDlg : public QDialog { Q_OBJECT diff --git a/src/VISUGUI/VisuGUI_msg_en.po b/src/VISUGUI/VisuGUI_msg_en.po index 7dfa1d8a..23a04a9d 100644 --- a/src/VISUGUI/VisuGUI_msg_en.po +++ b/src/VISUGUI/VisuGUI_msg_en.po @@ -121,6 +121,10 @@ msgstr "Iso Surface" 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" @@ -345,3 +349,9 @@ msgstr "Can't visualize current object" 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" diff --git a/src/VISU_I/Makefile.in b/src/VISU_I/Makefile.in index a26747c3..81a5bb7f 100644 --- a/src/VISU_I/Makefile.in +++ b/src/VISU_I/Makefile.in @@ -17,12 +17,13 @@ VPATH=.:@srcdir@:@top_srcdir@/idl # 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 @@ -30,21 +31,28 @@ LIB_SERVER_IDL = VISU_Gen.idl SALOME_Component.idl SALOME_Exception.idl SALOME_S 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 @@ -52,7 +60,4 @@ MOSTLYCLEAN = CLEAN = DISTCLEAN = -@CONCLUDE@ - - - +@CONCLUDE@ \ No newline at end of file diff --git a/src/VISU_I/VISUConfig.cc b/src/VISU_I/VISUConfig.cc new file mode 100644 index 00000000..e23f6210 --- /dev/null +++ b/src/VISU_I/VISUConfig.cc @@ -0,0 +1,299 @@ +// 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< 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="<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 - "<second)(theSObject,thePrefix,aMap); + } + }catch(std::logic_error& exc){ + INFOS("Follow exception was accured :\n"<> there is no value for "<> 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 = "<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 = "< #include -using namespace std; - // IDL headers -#include +#include "SALOMEconfig.h" #include CORBA_SERVER_HEADER(VISU_Gen) #include CORBA_SERVER_HEADER(MED) #include CORBA_SERVER_HEADER(SALOMEDS) @@ -37,6 +53,7 @@ using namespace std; namespace VISU{ //=========================================================================== class VISU_Gen_i; + class Base_i : public virtual POA_VISU::Base, public virtual PortableServer::RefCountServantBase { @@ -57,8 +74,9 @@ namespace VISU{ 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; @@ -68,22 +86,24 @@ namespace VISU{ 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 TRestoringMap; + typedef std::map TRestoringMap; typedef Storable* (*TStorableEngine)(SALOMEDS::SObject_ptr theSObject, - const string& thePrefix, const TRestoringMap& theMap); - typedef map TCallbackMap; + const std::string& thePrefix, const TRestoringMap& theMap); + typedef std::map 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); @@ -91,18 +111,25 @@ namespace VISU{ 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 diff --git a/src/VISU_I/VISU_CorbaMedConvertor.cxx b/src/VISU_I/VISU_CorbaMedConvertor.cxx index 1b879710..09a46503 100644 --- a/src/VISU_I/VISU_CorbaMedConvertor.cxx +++ b/src/VISU_I/VISU_CorbaMedConvertor.cxx @@ -1,20 +1,43 @@ -// 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 #include +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; @@ -58,8 +81,8 @@ static int CELLGEOM[MED_NBR_GEOMETRIE_MAILLE] = { 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 @@ -129,8 +152,8 @@ static SalomeMed2vtk salome_med2vtk[SALOME_MED::MED_ALL_ELEMENTS] = { 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) @@ -153,6 +176,74 @@ string GetName(SALOMEDS::SObject_ptr aSObject){ 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 = "<getNumberOfElements(aMedEntity,aMedType); + if(iNumElemEnd > 0){ + if(MYDEBUG) MESSAGE("GetCellsSize - iNumElemEnd = "<getTypes(); + med_int iGeomElemEnd = aGeom->length(); + theNbCells = theCellsSize = 0; + if(MYDEBUG) MESSAGE("GetCellsSize - iGeomElemEnd = "<getNumber(aGeomType); + int medId = GetIdMEDType(aGeomType); + med_int iNumElemEnd = aCellNumForType->length(); + if(iNumElemEnd > 0){ + if(MYDEBUG) MESSAGE("GetCellsSize - iNumElemEnd = "<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() !!!"); @@ -180,11 +271,9 @@ VISU_Convertor* VISU_MEDFieldConvertor::Build() throw (std::runtime_error&){ 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(); @@ -192,6 +281,8 @@ VISU_Convertor* VISU_MEDFieldConvertor::Build() throw (std::runtime_error&){ 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 = "<> 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()){ @@ -246,50 +337,49 @@ VISU_Convertor* VISU_MEDConvertor::Build() throw (std::runtime_error&){ 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 = '"<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); @@ -377,11 +464,9 @@ VISU_Convertor* VISU_MEDConvertor::Build() throw (std::runtime_error&){ 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; @@ -389,20 +474,23 @@ VISU_Convertor* VISU_MEDConvertor::Build() throw (std::runtime_error&){ 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 = "<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 = '"<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 = "<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 = '"< + +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(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(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 TLineCont; + typedef map TXMap; + typedef map TXYMap; + typedef vector 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 = "<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 = "< 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 = "<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()); + } +} diff --git a/src/VISU_I/VISU_CutLines_i.hh b/src/VISU_I/VISU_CutLines_i.hh new file mode 100644 index 00000000..3ebd8331 --- /dev/null +++ b/src/VISU_I/VISU_CutLines_i.hh @@ -0,0 +1,115 @@ +// 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 diff --git a/src/VISU_I/VISU_CutPlanes_i.cc b/src/VISU_I/VISU_CutPlanes_i.cc new file mode 100644 index 00000000..a4ede3a5 --- /dev/null +++ b/src/VISU_I/VISU_CutPlanes_i.cc @@ -0,0 +1,196 @@ +// 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(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(myPipeLine); + + ScalarMap_i::DoHook(); +} diff --git a/src/VISU_I/VISU_CutPlanes_i.hh b/src/VISU_I/VISU_CutPlanes_i.hh new file mode 100644 index 00000000..a64190bc --- /dev/null +++ b/src/VISU_I/VISU_CutPlanes_i.hh @@ -0,0 +1,101 @@ +// 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 + + diff --git a/src/VISU_I/VISU_DeformedShape_i.cc b/src/VISU_I/VISU_DeformedShape_i.cc new file mode 100644 index 00000000..19baed97 --- /dev/null +++ b/src/VISU_I/VISU_DeformedShape_i.cc @@ -0,0 +1,184 @@ +// 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"<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(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(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(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); + } +} diff --git a/src/VISU_I/VISU_DeformedShape_i.hh b/src/VISU_I/VISU_DeformedShape_i.hh new file mode 100644 index 00000000..1454fcbb --- /dev/null +++ b/src/VISU_I/VISU_DeformedShape_i.hh @@ -0,0 +1,95 @@ +// 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 + + diff --git a/src/VISU_I/VISU_Gen_i.cc b/src/VISU_I/VISU_Gen_i.cc index 3ec2cab5..08ba3fba 100644 --- a/src/VISU_I/VISU_Gen_i.cc +++ b/src/VISU_I/VISU_Gen_i.cc @@ -1,255 +1,97 @@ -// 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 #include #include -#include -#include #include #include CORBA_SERVER_HEADER(SALOME_Session) #include #include + +using namespace std; + static QFileInfo aFileInfo; -#ifdef DEBUG +#ifdef _DEBUG_ static int MYDEBUG = 0; #else static int MYDEBUG = 0; #endif -#include - -//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 : "<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 : "<getId() ; } - //=========================================================================== - static Storable::TCallbackMap VisuStoreMap; - string Storable::ToString(){ - ostringstream strOut; - Storable::DataToStream( strOut, "myComment", GetComment() ); - ToStream(strOut); - strOut< 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="<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 - "<second)(theSObject,thePrefix,aMap); - } - }catch(std::logic_error& exc){ - MESSAGE("Follow exception was accured :\n"<> there is no value for "<> 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"); @@ -267,82 +109,31 @@ namespace 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 - '"<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 = "<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 = "<_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 : "<GetCurrentStudy(); @@ -607,11 +404,12 @@ namespace VISU{ 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); } @@ -688,124 +486,51 @@ namespace VISU{ } 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 : "<GetProperties()->IsLocked()) return ScalarMap::_nil(); - Mutex mt(myMutex,qApp); - Result_i* pResult = dynamic_cast(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(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 : "<GetProperties()->IsLocked()) return DeformedShape::_nil(); - Mutex mt(myMutex,qApp); - Result_i* pResult = dynamic_cast(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(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 : "<GetProperties()->IsLocked()) return Vectors::_nil(); - Mutex mt(myMutex,qApp); - Result_i* pResult = dynamic_cast(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(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 : "<GetProperties()->IsLocked()) return IsoSurfaces::_nil(); - Mutex mt(myMutex,qApp); - Result_i* pResult = dynamic_cast(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(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 : "<GetProperties()->IsLocked()) return StreamLines::_nil(); - Mutex mt(myMutex,qApp); - Result_i* pResult = dynamic_cast(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(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 : "<GetProperties()->IsLocked()) return CutPlanes::_nil(); - Mutex mt(myMutex,qApp); - Result_i* pResult = dynamic_cast(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(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 : "<GetProperties()->IsLocked()) return CutLines::_nil(); - Mutex mt(myMutex,qApp); - Result_i* pResult = dynamic_cast(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(theResult,theMeshName,theEntity,theFieldName,theIteration); return myVisuGen->CutLinesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration); } @@ -944,7 +669,7 @@ namespace VISU{ } } } catch (...) { - MESSAGE("Unknown exception was accured!"); + INFOS("Unknown exception was accured!"); } return false; } @@ -1014,6 +739,9 @@ namespace VISU{ // 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); @@ -1035,7 +763,7 @@ namespace VISU{ 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); @@ -1048,25 +776,31 @@ namespace VISU{ 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); diff --git a/src/VISU_I/VISU_Gen_i.hh b/src/VISU_I/VISU_Gen_i.hh index 9604f498..08c4010c 100644 --- a/src/VISU_I/VISU_Gen_i.hh +++ b/src/VISU_I/VISU_Gen_i.hh @@ -16,6 +16,7 @@ #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 @@ -33,10 +34,13 @@ namespace VISU{ 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); @@ -53,6 +57,23 @@ namespace VISU{ virtual Mesh_ptr GroupMesh(Result_ptr theResult, const char* theMeshName, const char* theGroupName); //Create 3D collored Presentation Of Different Types + template 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(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, diff --git a/src/VISU_I/VISU_IsoSurfaces_i.cc b/src/VISU_I/VISU_IsoSurfaces_i.cc new file mode 100644 index 00000000..d7e6bf15 --- /dev/null +++ b/src/VISU_I/VISU_IsoSurfaces_i.cc @@ -0,0 +1,151 @@ +// 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(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); + + ScalarMap_i::DoHook(); +} + + +void VISU::IsoSurfaces_i::SetMapScale(double theMapScale){ + myIsoSurfacesPL->SetMapScale(theMapScale); +} diff --git a/src/VISU_I/VISU_IsoSurfaces_i.hh b/src/VISU_I/VISU_IsoSurfaces_i.hh new file mode 100644 index 00000000..a5a6d208 --- /dev/null +++ b/src/VISU_I/VISU_IsoSurfaces_i.hh @@ -0,0 +1,85 @@ +// 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 diff --git a/src/VISU_I/VISU_Mesh_i.cc b/src/VISU_I/VISU_Mesh_i.cc new file mode 100644 index 00000000..0a5ad229 --- /dev/null +++ b/src/VISU_I/VISU_Mesh_i.cc @@ -0,0 +1,270 @@ +// 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 = "<GetInput()->GetMeshOnGroupSize(theMeshName,theGroupName); + if(MYDEBUG) MESSAGE("Mesh_i::IsPossible - CheckAvailableMemory = "<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 = "<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"<Delete(); + throw exc; + } + return anActor; +} + +void VISU::Mesh_i::UpdateActor(VISU_Actor* theActor){ + if(VISU_MeshAct* anActor = dynamic_cast(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); + } +} diff --git a/src/VISU_I/VISU_Mesh_i.hh b/src/VISU_I/VISU_Mesh_i.hh new file mode 100644 index 00000000..51668a83 --- /dev/null +++ b/src/VISU_I/VISU_Mesh_i.hh @@ -0,0 +1,104 @@ +// 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 + + diff --git a/src/VISU_I/VISU_Prs3d_i.cc b/src/VISU_I/VISU_Prs3d_i.cc new file mode 100644 index 00000000..350c651d --- /dev/null +++ b/src/VISU_I/VISU_Prs3d_i.cc @@ -0,0 +1,123 @@ +// 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(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::GetServant(aResult.in())); + return NULL; +} diff --git a/src/VISU_I/VISU_Prs3d_i.hh b/src/VISU_I/VISU_Prs3d_i.hh new file mode 100644 index 00000000..3ebbb965 --- /dev/null +++ b/src/VISU_I/VISU_Prs3d_i.hh @@ -0,0 +1,78 @@ +// 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 diff --git a/src/VISU_I/VISU_PrsObject_i.cc b/src/VISU_I/VISU_PrsObject_i.cc index a021b42c..5ba1f599 100644 --- a/src/VISU_I/VISU_PrsObject_i.cc +++ b/src/VISU_I/VISU_PrsObject_i.cc @@ -1,103 +1,41 @@ -// 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 -#include -#include - -#include -#include -#include - -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#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::GetServant(aResult.in())); - return NULL; -} - -//---------------------------------------------------------------- -// PrsObject -//---------------------------------------------------------------- void VISU::PrsObject_i::SetName( const char* theName ) { myName = theName; @@ -115,2111 +53,3 @@ QString VISU::PrsObject_i::GetEntry() { 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(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 : "<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 = "<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"<Delete(); - return NULL; - } -} - -void VISU::Mesh_i::UpdateActor(VISU_Actor* theActor) { - if(VISUMesh_Actor* anActor = dynamic_cast(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 = "<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(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 = "<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 = "<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 = "<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 - "<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 = "<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 = "<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(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"<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(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 = "<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(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 = "<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(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() = "<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 TLineCont; - typedef map TXMap; - typedef map TXYMap; - typedef vector 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 = "<GetInput(iLine); - aDataSet->Update(); - int aNbPoints = aDataSet->GetNumberOfPoints(); - if(MYDEBUG) MESSAGE("CutPlanes_i::BuildTableOfReal iLine = "< 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 = "<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(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 = "<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(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(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 = '"<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(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 = "<GetNumberOfPoints()<<";\t"<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(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 = "<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); -} - -//============================================================================== - diff --git a/src/VISU_I/VISU_PrsObject_i.hh b/src/VISU_I/VISU_PrsObject_i.hh index cd623019..304df61b 100644 --- a/src/VISU_I/VISU_PrsObject_i.hh +++ b/src/VISU_I/VISU_PrsObject_i.hh @@ -1,5 +1,23 @@ -// 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 @@ -9,48 +27,20 @@ #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: @@ -59,589 +49,8 @@ namespace VISU{ 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 diff --git a/src/VISU_I/VISU_Result_i.cc b/src/VISU_I/VISU_Result_i.cc index f0a16be6..f8d2a482 100644 --- a/src/VISU_I/VISU_Result_i.cc +++ b/src/VISU_I/VISU_Result_i.cc @@ -1,18 +1,34 @@ -// 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" @@ -24,9 +40,10 @@ using namespace VISU; #include #include +using namespace VISU; using namespace std; -#ifdef DEBUG +#ifdef _DEBUG_ static int MYDEBUG = 0; static int MYDEBUGWITHFILES = 0; #else @@ -51,23 +68,6 @@ VISU::Result_var VISU::FindResult(SALOMEDS::SObject_ptr theSObject){ 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 TNameMap; static TNameMap aMap; @@ -118,6 +118,71 @@ const char* VISU::Result_i::GetComment() const { return myComment.c_str();} 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 = "<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"<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()); } @@ -250,6 +315,8 @@ VISU::Storable* VISU::Result_i::Build(SALOMEDS::SObject_ptr theSObject) } } } + QString aIsBuild = QAD_CONFIG->getSetting("Visu:BuildResult"); + if(aIsBuild.isEmpty()? 0 : aIsBuild.toInt()) BuildAll(); return this; } @@ -259,13 +326,13 @@ VISU::Storable* VISU::Result_i::Create(const char* theFileName){ 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"<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"<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() { diff --git a/src/VISU_I/VISU_Result_i.hh b/src/VISU_I/VISU_Result_i.hh index d796d86c..163231ec 100644 --- a/src/VISU_I/VISU_Result_i.hh +++ b/src/VISU_I/VISU_Result_i.hh @@ -1,5 +1,23 @@ -// 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 @@ -11,11 +29,7 @@ #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, @@ -27,30 +41,34 @@ namespace VISU{ 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;} @@ -65,11 +83,6 @@ namespace VISU{ 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 diff --git a/src/VISU_I/VISU_ScalarMap_i.cc b/src/VISU_I/VISU_ScalarMap_i.cc new file mode 100644 index 00000000..270e77d4 --- /dev/null +++ b/src/VISU_I/VISU_ScalarMap_i.cc @@ -0,0 +1,429 @@ +// 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 = "<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(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 - "<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"<GetMapper()->SetScalarVisibility(1); + } + myScalarMapPL = dynamic_cast(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(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; +} diff --git a/src/VISU_I/VISU_ScalarMap_i.hh b/src/VISU_I/VISU_ScalarMap_i.hh new file mode 100644 index 00000000..f6dbca2a --- /dev/null +++ b/src/VISU_I/VISU_ScalarMap_i.hh @@ -0,0 +1,141 @@ +// 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 diff --git a/src/VISU_I/VISU_StreamLines_i.cc b/src/VISU_I/VISU_StreamLines_i.cc new file mode 100644 index 00000000..7eb2f338 --- /dev/null +++ b/src/VISU_I/VISU_StreamLines_i.cc @@ -0,0 +1,252 @@ +// 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 + +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 = "<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(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::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 = '"<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(myPipeLine); + + DeformedShape_i::DoHook(); +} diff --git a/src/VISU_I/VISU_StreamLines_i.hh b/src/VISU_I/VISU_StreamLines_i.hh new file mode 100644 index 00000000..5ead8e9b --- /dev/null +++ b/src/VISU_I/VISU_StreamLines_i.hh @@ -0,0 +1,101 @@ +// 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 diff --git a/src/VISU_I/VISU_Table_i.cc b/src/VISU_I/VISU_Table_i.cc index 5d01988c..12d15ee4 100644 --- a/src/VISU_I/VISU_Table_i.cc +++ b/src/VISU_I/VISU_Table_i.cc @@ -1,25 +1,47 @@ -// 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 #include #include + #include -#include -#include -#ifdef DEBUG -static int MYDEBUG = 1; +using namespace std; + +#ifdef _DEBUG_ +static int MYDEBUG = 0; #else static int MYDEBUG = 0; #endif @@ -183,8 +205,9 @@ void VISU::Table_i::ToStream( std::ostringstream& theStr ) /*! 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, "" ); @@ -590,8 +613,9 @@ const char* VISU::Curve_i::GetTableID() { /*! 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 ); @@ -854,8 +878,9 @@ void VISU::Container_i::ToStream( std::ostringstream& theStr ) /*! 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 ); @@ -865,7 +890,8 @@ VISU::Storable* VISU::ContainerRestore(SALOMEDS::SObject_ptr theSObject, //------------------------------------------------------------- // Implementation of reading from file //------------------------------------------------------------- -typedef vector TValues; +typedef double TValue; +typedef vector TValues; struct TRow{ string myTitle; @@ -888,7 +914,8 @@ struct TTable2D{ 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 { @@ -928,12 +955,12 @@ int getLine(ifstream& theStmIn, QString& theString){ if(tmp == '\n') break; } aStrOut< 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; @@ -942,73 +969,75 @@ void ImportTables(const char* theFileName, TTableCont& theTableCont){ 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; - //cout< 0){ QStringList aStrList = QStringList::split("#TITLE:",aTmp); QString aTitle = aStrList[1].stripWhiteSpace(); TRow aRow; - aRow.myTitle = (const char*)aTitle; - //cout<>aVal){ aRow.myValues.push_back(aVal); - //cout<<"\t"< 0) + aTable2D.myRows.push_back(aRow); + if(MYDEBUG) cout<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 = "<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 = "<length(kEnd); - cout<<"kEnd = "<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 = "<SetValue(aTable2D.myTitle.c_str()); else{ @@ -1084,19 +1074,17 @@ SALOMEDS::SObject_var VISU::ImportTables(const char* theFileName, SALOMEDS::Stud int kEnd = aNewTable2D.myRows[0].myValues.size(); aTableOfReal->SetNbColumns(kEnd); for(int j = 0, jEnd = aNewTable2D.myRows.size(); j < jEnd; j++){ - //cout<<"j = "< #include "Plot2d_Curve.h" +#include + namespace VISU{ //============================================================================== class Table_i : public virtual POA_VISU::Table, @@ -47,6 +66,9 @@ namespace VISU{ 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; @@ -55,8 +77,6 @@ namespace VISU{ 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); //============================================================================== @@ -103,6 +123,9 @@ namespace VISU{ 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; @@ -119,8 +142,6 @@ namespace VISU{ 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, @@ -150,6 +171,9 @@ namespace VISU{ 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; @@ -159,9 +183,7 @@ namespace VISU{ 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 diff --git a/src/VISU_I/VISU_TimeAnimation.cxx b/src/VISU_I/VISU_TimeAnimation.cxx index d5f4cc64..49cd78fa 100644 --- a/src/VISU_I/VISU_TimeAnimation.cxx +++ b/src/VISU_I/VISU_TimeAnimation.cxx @@ -7,7 +7,25 @@ // 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; @@ -136,7 +154,7 @@ void VISU_TimeAnimation::generatePresentations(CORBA::Long theFieldNum) { 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 @@ -186,7 +204,7 @@ void VISU_TimeAnimation::generatePresentations(CORBA::Long theFieldNum) { 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(); @@ -210,8 +228,11 @@ void VISU_TimeAnimation::generatePresentations(CORBA::Long theFieldNum) { 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); + } } @@ -230,17 +251,17 @@ CORBA::Boolean VISU_TimeAnimation::generateFrames() { 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; } diff --git a/src/VISU_I/VISU_TimeAnimation.h b/src/VISU_I/VISU_TimeAnimation.h index 34af55dc..0331f2f7 100644 --- a/src/VISU_I/VISU_TimeAnimation.h +++ b/src/VISU_I/VISU_TimeAnimation.h @@ -9,14 +9,19 @@ #ifndef VISU_TIMEANIMATION_H #define VISU_TIMEANIMATION_H +#include "VISUConfig.hh" + +class VTKViewer_ViewFrame; +class VISU_Actor; + #include #include #include -#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 { diff --git a/src/VISU_I/VISU_Vectors_i.cc b/src/VISU_I/VISU_Vectors_i.cc new file mode 100644 index 00000000..81a5664e --- /dev/null +++ b/src/VISU_I/VISU_Vectors_i.cc @@ -0,0 +1,198 @@ +// 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(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(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(theActor)){ + VISU::DeformedShape_i::UpdateActor(anActor); + anActor->GetProperty()->SetLineWidth(GetLineWidth()); + if(VISU_VectorsPL* aVectorsPL = dynamic_cast(anActor->GetPipeLine())){ + aVectorsPL->ShallowCopy(myPipeLine); + aVectorsPL->Update(); + aVectorsPL->SetMapScale(myVectorsPL->GetMapScale()); + } + } +} diff --git a/src/VISU_I/VISU_Vectors_i.hh b/src/VISU_I/VISU_Vectors_i.hh new file mode 100644 index 00000000..1a2322d2 --- /dev/null +++ b/src/VISU_I/VISU_Vectors_i.hh @@ -0,0 +1,92 @@ +// 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 diff --git a/src/VISU_I/VISU_ViewManager_i.cc b/src/VISU_I/VISU_ViewManager_i.cc index f93106df..1035f51f 100644 --- a/src/VISU_I/VISU_ViewManager_i.cc +++ b/src/VISU_I/VISU_ViewManager_i.cc @@ -1,14 +1,44 @@ -// 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" @@ -19,24 +49,25 @@ using namespace std; #include "QAD_Study.h" #include "QAD_RightFrame.h" #include "QAD_StudyFrame.h" -#include -#include +#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 + +#include +#include + #include #include #include #include -#include +using namespace std; -#ifdef DEBUG +#ifdef _DEBUG_ static int MYDEBUG = 0; #else static int MYDEBUG = 0; @@ -72,7 +103,7 @@ namespace VISU{ 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(); @@ -91,11 +122,11 @@ namespace VISU{ 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; } } @@ -289,6 +320,20 @@ namespace VISU{ 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"); @@ -348,7 +393,7 @@ namespace VISU{ 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(){ @@ -767,7 +812,7 @@ namespace VISU{ vtkActor *actor; while(actor = theActors->GetNextActor()){ if(VISU_Actor* anActor = dynamic_cast(actor)){ - VISU::Prs3d_i* aPrs3d = anActor->getPrs3d(); + VISU::Prs3d_i* aPrs3d = anActor->GetPrs3d(); if(anActor->GetVisibility() && aPrs3d){ aPrs3d->Update(); aPrs3d->UpdateActor(anActor); diff --git a/src/VISU_I/VISU_ViewManager_i.hh b/src/VISU_I/VISU_ViewManager_i.hh index 0ba52167..9463e754 100644 --- a/src/VISU_I/VISU_ViewManager_i.hh +++ b/src/VISU_I/VISU_ViewManager_i.hh @@ -1,8 +1,26 @@ -// 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 @@ -10,12 +28,16 @@ #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; @@ -34,6 +56,7 @@ namespace VISU{ 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; diff --git a/src/VISU_SWIG/Makefile.in b/src/VISU_SWIG/Makefile.in index 24f69da1..25d9e713 100644 --- a/src/VISU_SWIG/Makefile.in +++ b/src/VISU_SWIG/Makefile.in @@ -36,18 +36,21 @@ VPATH=.:@srcdir@:@top_srcdir@/idl # 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 diff --git a/src/VISU_SWIG/VISU_Gen_s.cc b/src/VISU_SWIG/VISU_Gen_s.cc new file mode 100644 index 00000000..1a499def --- /dev/null +++ b/src/VISU_SWIG/VISU_Gen_s.cc @@ -0,0 +1,103 @@ +// 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 +#include + +#include +#include +#include +#include +#include + +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(); + } +} diff --git a/src/VISU_SWIG/VISU_Gen_s.hh b/src/VISU_SWIG/VISU_Gen_s.hh new file mode 100644 index 00000000..ecb0c3d0 --- /dev/null +++ b/src/VISU_SWIG/VISU_Gen_s.hh @@ -0,0 +1,67 @@ +// 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 diff --git a/src/VISU_SWIG/batchmode_visu.py b/src/VISU_SWIG/batchmode_visu.py index cc9f9552..868576d8 100644 --- a/src/VISU_SWIG/batchmode_visu.py +++ b/src/VISU_SWIG/batchmode_visu.py @@ -22,3 +22,64 @@ import visu 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 diff --git a/src/VISU_SWIG/batchmode_visu_view3d.py b/src/VISU_SWIG/batchmode_visu_view3d.py index 21468ec0..47396189 100644 --- a/src/VISU_SWIG/batchmode_visu_view3d.py +++ b/src/VISU_SWIG/batchmode_visu_view3d.py @@ -24,7 +24,7 @@ myFieldName = "VITESSE"; #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) diff --git a/src/VISU_SWIG/libVISU_Swig.i b/src/VISU_SWIG/libVISU_Swig.i index ee17ad91..1f9a4de7 100644 --- a/src/VISU_SWIG/libVISU_Swig.i +++ b/src/VISU_SWIG/libVISU_Swig.i @@ -27,5 +27,28 @@ // $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 diff --git a/src/VISU_SWIG/visu.py b/src/VISU_SWIG/visu.py index 73af65e1..f7c75a1c 100644 --- a/src/VISU_SWIG/visu.py +++ b/src/VISU_SWIG/visu.py @@ -270,6 +270,7 @@ def CreatePrsForResult(theVisu, theResult, theView, thePrsTypeList, thePictureDi anAttr = aMeshSObj.FindAttribute("AttributeName")[1] anAttr = anAttr._narrow(SALOMEDS.AttributeName); aMeshName = anAttr.Value() + aMeshNamePic = re.sub(".","_",aMeshName) print " ", aMeshName aFolderIter = myLocalStudy.NewChildIterator(aMeshSObj); @@ -305,13 +306,13 @@ def CreatePrsForResult(theVisu, theResult, theView, thePrsTypeList, thePictureDi 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) @@ -330,7 +331,7 @@ def CreatePrsForResult(theVisu, theResult, theView, thePrsTypeList, thePictureDi 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) @@ -350,7 +351,7 @@ def CreatePrsForResult(theVisu, theResult, theView, thePrsTypeList, thePictureDi 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) @@ -398,7 +399,7 @@ def CreatePrsForResult(theVisu, theResult, theView, thePrsTypeList, thePictureDi 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) @@ -410,7 +411,7 @@ def CreatePrsForResult(theVisu, theResult, theView, thePrsTypeList, thePictureDi 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) @@ -423,7 +424,7 @@ def CreatePrsForResult(theVisu, theResult, theView, thePrsTypeList, thePictureDi 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) @@ -437,7 +438,7 @@ def CreatePrsForResult(theVisu, theResult, theView, thePrsTypeList, thePictureDi 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) @@ -451,19 +452,19 @@ def CreatePrsForResult(theVisu, theResult, theView, thePrsTypeList, thePictureDi 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) @@ -475,7 +476,7 @@ def CreatePrsForResult(theVisu, theResult, theView, thePrsTypeList, thePictureDi 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) @@ -490,3 +491,340 @@ def generateName(prefix = None): 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()) diff --git a/src/VISU_SWIG/visu_med.py b/src/VISU_SWIG/visu_med.py index dbb195b6..edaab1c6 100644 --- a/src/VISU_SWIG/visu_med.py +++ b/src/VISU_SWIG/visu_med.py @@ -42,7 +42,7 @@ def getFieldObjectFromStudy(number,subnumber): 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 diff --git a/src/VISU_SWIG/visu_prs_example.py b/src/VISU_SWIG/visu_prs_example.py index 3ae0c6aa..d8cba431 100644 --- a/src/VISU_SWIG/visu_prs_example.py +++ b/src/VISU_SWIG/visu_prs_example.py @@ -22,7 +22,7 @@ import visu_gui 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 diff --git a/src/VISU_SWIG/visu_swig_test.py b/src/VISU_SWIG/visu_swig_test.py new file mode 100644 index 00000000..45a26744 --- /dev/null +++ b/src/VISU_SWIG/visu_swig_test.py @@ -0,0 +1,6 @@ +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) diff --git a/src/VISU_SWIG/visu_view3d.py b/src/VISU_SWIG/visu_view3d.py index f94f29ee..1248289f 100644 --- a/src/VISU_SWIG/visu_view3d.py +++ b/src/VISU_SWIG/visu_view3d.py @@ -20,7 +20,7 @@ myVisu = visu_gui.myVisu 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"