return aDataSetAttributes->GetArray("VISU_FIELD") != NULL;
}
+ //---------------------------------------------------------------
+ bool
+ IsDataOnElnoCells(vtkDataSet* theDataSet)
+ {
+ theDataSet->Update();
+ vtkDataSetAttributes *aDataSetAttributes = theDataSet->GetCellData();
+ return (aDataSetAttributes->GetArray("ELNO_FIELD") != NULL &&
+ aDataSetAttributes->GetArray("ELNO_COMPONENT_MAPPER") != NULL);
+ }
+
//---------------------------------------------------------------
vtkIdType
bool
IsDataOnCells(vtkDataSet* theDataSet);
+ //---------------------------------------------------------------
+ VISU_CONVERTOR_EXPORT
+ bool
+ IsDataOnElnoCells(vtkDataSet* theDataSet);
+
//---------------------------------------------------------------
VISU_CONVERTOR_EXPORT
if(!isNeedInCells){
vtkUnstructuredGrid* anOutput = theUnstructuredGridIDMapper->GetUnstructuredGridOutput();
const VISU::PUnstructuredGrid& aSource = theUnstructuredGridIDMapper->mySource.GetSource();
- VISU::GetTimeStampOnProfile(aSource, theField, theValForTime, theEntity);
+ //VISU::GetTimeStampOnProfile(aSource, theField, theValForTime, theEntity);
+ VISU::GetElnoTimeStamp(aSource, theField, theValForTime, theEntity);
}
return anOutput;
}
case MED::eNOEUD: return VISU::NODE_ENTITY;
case MED::eARETE: return VISU::EDGE_ENTITY;
case MED::eFACE: return VISU::FACE_ENTITY;
+ case MED::eNOEUD_ELEMENT:
case MED::eMAILLE: return VISU::CELL_ENTITY;
}
return VISU::TEntity(-1);
aFullDataArray->Delete();
}
-
+
//---------------------------------------------------------------
+ template<int EDataType>
+ void
+ InitElnoTimeStamp(const PUnstructuredGrid& theSource,
+ const PFieldImpl& theField,
+ const PValForTimeImpl& theValForTime,
+ const VISU::TEntity& theEntity);
+
+
+ //----------------------------------------------------------------------------
+ void
+ GetElnoTimeStamp(const PUnstructuredGrid& theSource,
+ const PFieldImpl& theField,
+ const PValForTimeImpl& theValForTime,
+ const VISU::TEntity& theEntity)
+ {
+ vtkIdType aDataType = theField->GetDataType();
+ switch(aDataType){
+ case VTK_DOUBLE:
+ InitElnoTimeStamp<VTK_DOUBLE>(theSource, theField, theValForTime, theEntity);
+ break;
+ case VTK_FLOAT:
+ InitElnoTimeStamp<VTK_FLOAT>(theSource, theField, theValForTime, theEntity);
+ break;
+ case VTK_INT:
+ InitElnoTimeStamp<VTK_INT>(theSource, theField, theValForTime, theEntity);
+ break;
+ case VTK_LONG:
+ InitElnoTimeStamp<VTK_LONG>(theSource, theField, theValForTime, theEntity);
+ break;
+ default:
+ EXCEPTION(std::runtime_error,
+ "GetElnoTimeStamp - handling unsupported data type - "<<aDataType);
+ }
+ }
+
+ //----------------------------------------------------------------------------
+ template<int EDataType>
+ struct TTimeStampOnElnoInitArray
+ {
+ typedef typename TL::TEnum2VTKArrayType<EDataType>::TResult TVTKDataArray;
+ typedef typename TL::TEnum2VTKBasicType<EDataType>::TResult TVTKBasicType;
+ typedef TTMeshValue<TVTKBasicType> TMeshValue;
+ typedef MED::SharedPtr<TMeshValue> TMeshValuePtr;
+
+ typedef TDataArrayHolder<EDataType> TTDataArrayHolder;
+ typedef MED::SharedPtr<TTDataArrayHolder> PDataArrayHolder;
+ PDataArrayHolder myDataArrayHolder;
+ vtkIntArray *myComponentMapper;
+ vtkIdType myComponentStep;
+
+ TTimeStampOnElnoInitArray(const PDataArrayHolder& theDataArrayHolder, vtkIntArray * aComponentMapper=0):
+ myDataArrayHolder(theDataArrayHolder),
+ myComponentStep(0),
+ myComponentMapper(aComponentMapper)
+ {}
+
+ void SetComponentStep(vtkIdType& theStep){
+ myComponentStep = theStep;
+ }
+
+ void
+ Execute(const PFieldImpl& theField,
+ const PValForTimeImpl& theValForTime)
+ {
+ vtkIdType aNbComp = theField->myNbComp;
+ TVector<TVTKBasicType> aDataValues(myComponentStep+1);
+
+ vtkIdType componentCount=0,aTupleId=0,aNextStartId=0,aComponentTupleId=0;
+ int theTuple[3] = {aNextStartId,
+ theField->myNbComp,
+ 0};
+
+ const TGeom2MeshValue& aGeom2MeshValue = theValForTime->GetGeom2MeshValue();
+ TGeom2MeshValue::const_iterator anIter = aGeom2MeshValue.begin();
+ for(; anIter != aGeom2MeshValue.end(); anIter++){
+ EGeometry aEGeom = anIter->first;
+ const TMeshValuePtr aMeshValue = anIter->second;
+
+ vtkIdType aNbElem = aMeshValue->GetNbElem();
+ vtkIdType aNbGauss = aMeshValue->GetNbGauss();
+
+ INITMSG(MYDEBUG,
+ "- aEGeom = "<<aEGeom<<
+ "; aNbElem = "<<aNbElem<<
+ "; aNbGauss = "<<aNbGauss<<
+ std::endl);
+ theTuple[2] = aNbGauss;
+ for(vtkIdType iElem = 0; iElem < aNbElem; iElem++) {
+ const typename TMeshValue::TValueSliceArr& aValueSliceArr = aMeshValue->GetGaussValueSliceArr(iElem);
+
+ for( vtkIdType iGauss = 0; iGauss < aNbGauss; iGauss++ ) {
+ const typename TMeshValue::TCValueSlice& aValueSlice = aValueSliceArr[iGauss];
+
+ for( vtkIdType iComp = 0; iComp < aNbComp; iComp++ ) {
+ aDataValues[componentCount] = aValueSlice[iComp];
+ componentCount++;
+
+ if(componentCount == myComponentStep ) {
+ this->myDataArrayHolder->SetTuple(aTupleId, &aDataValues[0]);
+ componentCount=0;
+ aTupleId++;
+ }
+ }
+ }
+ theTuple[0]=aNextStartId;
+ if(this->myComponentMapper) {
+ this->myComponentMapper->InsertTupleValue(aComponentTupleId,theTuple);
+ aComponentTupleId++;
+ }
+ aNextStartId=theTuple[1]*theTuple[2]+theTuple[0];
+ }
+ if(componentCount > 0)
+ this->myDataArrayHolder->SetTuple(aTupleId, &aDataValues[0]);
+ }
+ }
+ };
+
+ //----------------------------------------------------------------------------
+ template<int EDataType>
+ void
+ InitElnoTimeStamp(const PUnstructuredGrid& theSource,
+ const PFieldImpl& theField,
+ const PValForTimeImpl& theValForTime,
+ const VISU::TEntity& theEntity)
+ {
+ vtkIdType aNbTuples = theField->myDataSize / theField->myNbComp;
+ std::string aFieldName = VISU::GenerateFieldName(theField, theValForTime);
+
+ vtkDataSetAttributes* aDataSetAttributes = theSource->GetCellData();
+
+
+ typedef typename TL::TEnum2VTKArrayType<EDataType>::TResult TVTKDataArray;
+ TVTKDataArray *aSelectedDataArray = TVTKDataArray::New();
+ vtkIdType aNbComp = theField->myNbComp;
+
+ //Calculate Effective Nb of Tuples
+ const TGeom2MeshValue& aGeom2MeshValue = theValForTime->GetGeom2MeshValue();
+ TGeom2MeshValue::const_iterator anIter = aGeom2MeshValue.begin();
+ vtkIdType aEffectNbTuples = 0;
+ for(;anIter != aGeom2MeshValue.end(); anIter++){
+ aEffectNbTuples += anIter->second->GetNbElem()*anIter->second->GetNbGauss();
+ }
+
+ //Calculate Effective Nb of Components
+ vtkIdType aEffectNbComp = (aEffectNbTuples*aNbComp)/aNbTuples+1;
+
+ aSelectedDataArray->SetNumberOfComponents(aEffectNbComp);
+ aDataSetAttributes->SetVectors(aSelectedDataArray);
+
+ aSelectedDataArray->SetNumberOfTuples(aNbTuples);
+ aSelectedDataArray->SetName(aFieldName.c_str());
+
+ //Add in the data set attributes array to restore
+ //real Nb of Components
+ vtkIntArray *aComponentMapper = vtkIntArray::New();
+ aComponentMapper->SetNumberOfTuples(aNbTuples);
+ //Set 3 components:
+ //{[startId , realNbComponents, nbData], ..., ... ,[...]}
+ aComponentMapper->SetNumberOfComponents(3);
+ aComponentMapper->SetName("ELNO_COMPONENT_MAPPER");
+ aDataSetAttributes->AddArray(aComponentMapper);
+
+ TVTKDataArray *aFullDataArray = TVTKDataArray::New();
+ aFullDataArray->SetNumberOfComponents(aEffectNbComp);
+ aFullDataArray->SetNumberOfTuples(aNbTuples);
+ aFullDataArray->SetName("ELNO_FIELD");
+
+ aDataSetAttributes->AddArray(aFullDataArray);
+
+ INITMSG(MYDEBUG,"InitElnoTimeStamp "<<
+ "- theEntity = "<<theEntity<<
+ "; aNbTuples = "<<aNbTuples<<
+ "; aNbComp = "<<aNbComp<<
+ std::endl);
+ TTimerLog aTimerLog(MYDEBUG,"InitElnoTimeStamp");
+
+ typedef typename TL::TEnum2VTKBasicType<EDataType>::TResult TVTKBasicType;
+ typedef TTMeshValue<TVTKBasicType> TMeshValue;
+ typedef MED::SharedPtr<TMeshValue> TMeshValuePtr;
+
+ typedef TDataArrayHolder<EDataType> TTDataArrayHolder;
+ typedef MED::SharedPtr<TTDataArrayHolder> PDataArrayHolder;
+
+ TMeshValuePtr aMeshValue = theValForTime->GetFirstMeshValue();
+
+ typedef TDataArrayHolder2<EDataType> TTDataArrayHolder2;
+ PDataArrayHolder aDataArrayHolder(new TTDataArrayHolder2(aSelectedDataArray, aFullDataArray));
+ TTimeStampOnElnoInitArray<EDataType> aArrayInitializer(aDataArrayHolder,aComponentMapper);
+ aArrayInitializer.SetComponentStep(aEffectNbComp);
+ aArrayInitializer.Execute(theField, theValForTime);
+
+
+ aSelectedDataArray->Delete();
+ aFullDataArray->Delete();
+ }
+
}
//---------------------------------------------------------------
+ // Initilize corresponding vtkDataSetAttributes for TValForTime
+ void
+ GetElnoTimeStamp(const PUnstructuredGrid& theSource,
+ const PFieldImpl& theField,
+ const PValForTimeImpl& theValForTime,
+ const VISU::TEntity& theEntity);
+
}
#endif
aFilter->SetVectors(aDataSet);
aFilter->AddField("VISU_FIELD",aDataSet);
aFilter->AddField("VISU_CELLS_MAPPER",aDataSet);
+ aFilter->AddField("ELNO_FIELD",aDataSet);
+ aFilter->AddField("ELNO_COMPONENT_MAPPER",aDataSet);
aFilter->AddField("VISU_POINTS_MAPPER",aDataSet);
-
+
myCommonCellsFilter->SetProfileUG(aFilter->GetUnstructuredGridOutput());
}
return myCommonCellsFilter->GetOutput();
VISU_SphereWidget.hxx \
VISU_WidgetCtrl.hxx \
VISU_ScalarMapOnDeformedShapePL.hxx \
- VISUPipeline.hxx
+ VISU_OpenGLElnoMapper.hxx \
+ VISUPipeline.hxx \
+ VISU_ElnoGeometryFilter.hxx
dist_libVisuPipeLine_la_SOURCES= \
VISU_MapperHolder.cxx \
VISU_SphereWidget.cxx \
VISU_WidgetCtrl.cxx \
VISU_ScalarBarCtrl.cxx \
- VISU_ScalarMapOnDeformedShapePL.cxx
+ VISU_ScalarMapOnDeformedShapePL.cxx \
+ VISU_OpenGLElnoMapper.cxx \
+ VISU_ElnoGeometryFilter.cxx
+
libVisuPipeLine_la_CPPFLAGS= \
$(VTK_INCLUDES) \
// Author: Alexey PETROV
// Module : VISU
+
+// Salome includes
+#include "VISU_Convertor.hxx"
+#include "VISU_ConvertorUtils.hxx"
#include "VISU_MeshPL.hxx"
#include "VISU_ScalarMapPL.hxx"
#include "VISU_IsoSurfacesPL.hxx"
#include "VISU_StreamLinesPL.hxx"
#include "VISU_GaussPointsPL.hxx"
#include "VISU_ScalarMapOnDeformedShapePL.hxx"
+#include "VISU_OpenGLElnoMapper.hxx"
#include "VISU_Plot3DPL.hxx"
#include "VISU_ScalarBarActor.hxx"
-
-#include "VISU_DeformedGridPL.hxx"
-
#include "VISU_OpenGLPointSpriteMapper.hxx"
#include "VTKViewer_GeometryFilter.h"
-#include <vtkMaskPoints.h>
-
-#include "VISU_Convertor.hxx"
-#include "VISU_TableReader.hxx"
-#include "VISU_ConvertorUtils.hxx"
-
-typedef VISU_StreamLinesPL TPresent;
+#include "VISU_ElnoGeometryFilter.hxx"
+// VTK includes
+#include <vtkMaskPoints.h>
+#include <vtkUnstructuredGridReader.h>
#include <vtkUnstructuredGrid.h>
#include <vtkDataSetMapper.h>
-
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderWindow.h>
#include <vtkImageData.h>
+#include <vtkCellData.h>
#include <vtkRenderer.h>
#include <vtkCamera.h>
#include <vtkActor.h>
#include <vtk3DWidget.h>
-
#include <vtkProperty.h>
-#include <qfileinfo.h>
-
-#include <memory>
-
-//#define _DEBUG_ID_MAPPING_
-
-//----------------------------------------------------------------------------
-template<class TPipeLine>
-VISU_ColoredPL*
-CreateColoredPL(VISU_Convertor* theConvertor,
- const std::string& theMeshName,
- const VISU::TEntity& theEntity,
- const std::string& theFieldName,
- int theTimeStampNumber);
-
-
-//----------------------------------------------------------------------------
-template<>
-VISU_ColoredPL*
-CreateColoredPL<VISU_GaussPointsPL>(VISU_Convertor* theConvertor,
- const std::string& theMeshName,
- const VISU::TEntity& theEntity,
- const std::string& theFieldName,
- int theTimeStampNumber)
-{
- VISU_GaussPointsPL* aPresent = VISU_GaussPointsPL::New();
- VISU::PGaussPtsIDMapper aGaussPtsIDMapper =
- theConvertor->GetTimeStampOnGaussPts(theMeshName,
- theEntity,
- theFieldName,
- theTimeStampNumber);
- aPresent->SetGaussPtsIDMapper(aGaussPtsIDMapper);
-
- char aMainTexture[80];
- strcpy( aMainTexture, getenv( "VISU_ROOT_DIR" ) );
- strcat( aMainTexture, "/share/salome/resources/visu/sprite_texture.bmp" );
+void PrintMissing(){
+ cout<<"VISUPipeLine : ";
+ cout<<"missing operand after `VISUPipeLine'"<<endl;
- char anAlphaTexture[80];
- strcpy( anAlphaTexture, getenv( "VISU_ROOT_DIR" ) );
- strcat( anAlphaTexture, "/share/salome/resources/visu/sprite_alpha.bmp" );
-
- vtkSmartPointer<vtkImageData> aTextureValue =
- VISU_GaussPointsPL::MakeTexture( aMainTexture, anAlphaTexture );
- aPresent->SetImageData( aTextureValue.GetPointer() );
-
- aPresent->Update();
-
-#ifdef _DEBUG_ID_MAPPING_
- vtkDataSet* aDataSet = aPresent->GetOutput();
- aDataSet->Update();
- int aNbCells = aDataSet->GetNumberOfCells();
- cout<<"aNbCells = "<<aNbCells<<endl;
- for(int anCellId = 0; anCellId < aNbCells; anCellId++){
- vtkIdType anObjID = aPresent->GetNodeObjID(anCellId);
- vtkIdType aVtkID = aPresent->GetNodeVTKID(anObjID);
- cout<<anObjID<<"; "<<aVtkID<<"; - ";
- vtkFloatingPointType* aCoord = aPresent->GetNodeCoord(anObjID);
- cout<<aCoord[0]<<"; "<<aCoord[1]<<"; "<<aCoord[2]<<endl;
- }
-#endif
-
- return aPresent;
+ cout<<"VISUPipeLine : ";
+ cout<<"Try `VISUPipeLine -h' for more information."<<endl;
}
-
-//----------------------------------------------------------------------------
-template<class TPipeLine>
-VISU_ColoredPL*
-CreateColoredPL(VISU_Convertor* theConvertor,
- const std::string& theMeshName,
- const VISU::TEntity& theEntity,
- const std::string& theFieldName,
- int theTimeStampNumber)
-{
- TPipeLine* aPresent = TPipeLine::New();
- VISU::PUnstructuredGridIDMapper anUnstructuredGridIDMapper =
- theConvertor->GetTimeStampOnMesh(theMeshName,
- theEntity,
- theFieldName,
- theTimeStampNumber);
- aPresent->SetUnstructuredGridIDMapper(anUnstructuredGridIDMapper);
-
- //aPresent->ClearGeometry();
- //{
- // VISU::PUnstructuredGridIDMapper anIDMapper =
- // theConvertor->GetMeshOnGroup(theMeshName,
- // "groupe1");
- // aPresent->AddGeometry(anIDMapper->GetOutput());
- //}
- //{
- // VISU::PUnstructuredGridIDMapper anIDMapper =
- // theConvertor->GetMeshOnGroup(theMeshName,
- // "TUBEH ");
- // aPresent->AddGeometry(anIDMapper->GetOutput());
- //}
- //{
- // VISU::PUnstructuredGridIDMapper anIDMapper =
- // theConvertor->GetMeshOnGroup(theMeshName,
- // "STRI ");
- // aPresent->AddGeometry(anIDMapper->GetOutput());
- //}
- aPresent->Update();
- return aPresent;
+void PrintHelp(){
+
+ cout<<" Usage: VISUPipeLine filename meshname fieldname [timestamp] [component] " <<endl;
+ cout<<"filename - Name of the med file. " <<endl;
+ cout<<"meshname - Name of the mesh in the med file. " <<endl;
+ cout<<"fieldname - Name of the mesh field. " <<endl;
+ cout<<"timestamp - Number of the time stamp in the field 1,2,3 ... (optionally)" <<endl;
+ cout<<" by default used first time stamp. " <<endl;
+ cout<<"component - Number of the component in the field 0,1,2,3 ...(optionally)" <<endl;
+ cout<<" 0 - modulus, 1 - first component, 2 - second component, ... " <<endl;
+ cout<<" by default used modulus. " <<endl;
}
-
-//----------------------------------------------------------------------------
-struct TMEDSource
-{
- std::auto_ptr<VISU_Convertor> myConvertor;
-
- TMEDSource(char** argv): myConvertor(CreateConvertor(argv[1]))
- {
- myConvertor->BuildEntities();
- }
-};
-
-
-//----------------------------------------------------------------------------
-struct TMeshBulder: TMEDSource
-{
- TMeshBulder(char** argv): TMEDSource(argv)
- {}
-
- int Publish(vtkRenderer *theRenderer) const
- {
- const VISU::TMeshMap& aMeshMap = myConvertor->GetMeshMap();
- VISU::TMeshMap::const_iterator aMeshMapIter = aMeshMap.begin();
- if(aMeshMapIter == aMeshMap.end())
- return 0;
-
- const std::string& aMeshName = aMeshMapIter->first;
- const VISU::PMesh aMesh = aMeshMapIter->second;
- const VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh->myMeshOnEntityMap;
- VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter;
-
- VISU::TEntity anEntity = VISU::CELL_ENTITY;
- aMeshOnEntityMapIter = aMeshOnEntityMap.find(anEntity);
-
- VISU::PNamedIDMapper anIDMapper = myConvertor->GetMeshOnEntity(aMeshName, anEntity);
-
- VISU_MeshPL* aPresent = VISU_MeshPL::New();
- aPresent->SetUnstructuredGridIDMapper(anIDMapper);
-
- vtkActor* anActor = vtkActor::New();
- anActor->SetMapper(aPresent->GetMapper());
- anActor->GetProperty()->SetRepresentation(VTK_WIREFRAME);
-
- theRenderer->AddActor(anActor);
- anActor->Delete();
-
- return 0;
- }
-};
+void PrintErr(){
+ cout<<"***************************ERROR*****************************************"<<endl;
+}
//----------------------------------------------------------------------------
-struct TColoredPrsBulder: TMEDSource
+int
+main(int argc, char** argv)
{
- TColoredPrsBulder(char** argv): TMEDSource(argv)
- {}
-
- int Publish(vtkRenderer *theRenderer) const
- {
- myConvertor->BuildGroups();
- myConvertor->BuildFields();
- myConvertor->BuildMinMax();
- const VISU::TMeshMap& aMeshMap = myConvertor->GetMeshMap();
- VISU::TMeshMap::const_iterator aMeshMapIter = aMeshMap.begin();
- if(aMeshMapIter == aMeshMap.end())
- return 0;
-
- const std::string& aMeshName = aMeshMapIter->first;
- const VISU::PMesh 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::PMeshOnEntity aMeshOnEntity = aMeshOnEntityMapIter->second;
- const VISU::TFieldMap& aFieldMap = aMeshOnEntity->myFieldMap;
- VISU::TFieldMap::const_iterator aFieldMapIter = aFieldMap.begin();
- for(; aFieldMapIter != aFieldMap.end(); aFieldMapIter++){
- const VISU::PField aField = aFieldMapIter->second;
- //if(aField->myNbComp == 1)
- // continue;
- const std::string& aFieldName = aFieldMapIter->first;
- const VISU::TValField& aValField = aField->myValField;
- VISU::TValField::const_reverse_iterator aValFieldIter = aValField.rbegin();
- if(aValFieldIter == aValField.rend())
- return 0;
-
- int aTimeStamp = aValFieldIter->first;
-
- VISU_ColoredPL* aPresent = NULL;
- if(anEntity != VISU::NODE_ENTITY){
- aPresent = CreateColoredPL<TPresent>(myConvertor.get(),
- aMeshName,
- anEntity,
- aFieldName,
- aTimeStamp);
-
- }else{
- continue;
- aPresent = CreateColoredPL<TPresent>(myConvertor.get(),
- aMeshName,
- anEntity,
- aFieldName,
- aTimeStamp);
- }
-
- vtkActor* anActor = vtkActor::New();
- anActor->SetMapper(aPresent->GetMapper());
-
- VISU_ScalarBarActor * aScalarBar = VISU_ScalarBarActor::New();
- aScalarBar->SetLookupTable(aPresent->GetBarTable());
-
- theRenderer->AddActor(anActor);
- anActor->Delete();
-
- theRenderer->AddActor2D(aScalarBar);
- aScalarBar->Delete();
- }
+ try{
+ if(argc == 1){
+ PrintMissing();
+ return 1;
+ }
+ if(argc == 2 && !strcmp(argv[1],"-h")) {
+ PrintHelp();
+ return 1;
}
- return 0;
- }
-};
-
-
-//----------------------------------------------------------------------------
-struct TXLSSource
-{
- VISU::TTableContainer myContainer;
-
- TXLSSource(char** argv)
- {
- VISU::ImportTables( argv[1], myContainer );
- }
-
- int Publish(vtkRenderer *theRenderer) const
- {
- if ( myContainer.empty() )
- return 0;
-
- VISU::PPolyDataIDMapper anIDMapper = myContainer[0];
-
- VISU_DeformedGridPL* aPresent = VISU_DeformedGridPL::New();
- aPresent->SetPolyDataIDMapper(anIDMapper);
- //aPresent->SetContourPrs( true );
- aPresent->Update();
-
- vtkActor* anActor = vtkActor::New();
- anActor->SetMapper(aPresent->GetMapper());
-
- theRenderer->AddActor(anActor);
- anActor->Delete();
- VISU_ScalarBarActor * aScalarBar = VISU_ScalarBarActor::New();
- aScalarBar->SetLookupTable(aPresent->GetBarTable());
+ char* aFileName =0;
+ char* aMeshName =0;
+ char* aFieldName =0;
+ int aTimeStampNumber = 1;
+ int aComponentNumber = 0;
+ bool allInit = false;
+ bool isMeshOk = false;
+ bool isFieldOk = false;
+ bool isTimeStampOk = false;
+ bool isComponentOk = false;
+
+ if(argc == 4 ){
+ aFileName = new char[static_cast<int>(strlen(argv[1])) + 1];
+ aMeshName = new char[static_cast<int>(strlen(argv[2])) + 1];
+ aFieldName = new char[static_cast<int>(strlen(argv[3])) + 1];
+
+ strcpy(aFileName,argv[1]);
+ strcpy(aMeshName,argv[2]);
+ strcpy(aFieldName,argv[3]);
+
+ allInit = true;
+ }
+
+ if(argc == 5) {
+ aFileName = new char[static_cast<int>(strlen(argv[1])) + 1];
+ aMeshName = new char[static_cast<int>(strlen(argv[2])) + 1];
+ aFieldName = new char[static_cast<int>(strlen(argv[3])) + 1];
+
+ strcpy(aFileName,argv[1]);
+ strcpy(aMeshName,argv[2]);
+ strcpy(aFieldName,argv[3]);
+
+ aTimeStampNumber = atoi(argv[4]);
+ allInit = true;
+ }
- theRenderer->AddActor2D(aScalarBar);
- aScalarBar->Delete();
+ if(argc == 6) {
+ aFileName = new char[static_cast<int>(strlen(argv[1])) + 1];
+ aMeshName = new char[static_cast<int>(strlen(argv[2])) + 1];
+ aFieldName = new char[static_cast<int>(strlen(argv[3])) + 1];
+
+ strcpy(aFileName,argv[1]);
+ strcpy(aMeshName,argv[2]);
+ strcpy(aFieldName,argv[3]);
+
+ aTimeStampNumber = atoi(argv[4]);
+ aComponentNumber = atoi(argv[5]);
+ allInit = true;
+ }
- return 0;
- }
-};
-
-//----------------------------------------------------------------------------
-template<class TPrsBuilder>
-int RenderPresentation(const TPrsBuilder& thePrsBuilder)
-{
- vtkRenderWindow *aWindow = vtkRenderWindow::New();
- vtkRenderer *aRenderer = vtkRenderer::New();
-
- aWindow->AddRenderer(aRenderer);
- aRenderer->GetActiveCamera()->ParallelProjectionOn();
-
- vtkRenderWindowInteractor *anInteractor = vtkRenderWindowInteractor::New();
- anInteractor->SetRenderWindow(aWindow);
- aWindow->Delete();
-
- vtkInteractorStyle* aStyle = vtkInteractorStyleTrackballCamera::New();
- anInteractor->SetInteractorStyle(aStyle);
- aStyle->Delete();
-
- int aRet = thePrsBuilder.Publish(aRenderer);
-
- aWindow->Render();
- anInteractor->Start();
-
- return aRet;
-}
-
-
-//----------------------------------------------------------------------------
-int
-main(int argc, char** argv)
-{
- try{
- if (argc > 1) {
- QFileInfo aFileInfo( argv[1] );
- if ( aFileInfo.isFile() ) {
- QString anExtension = aFileInfo.extension();
- if ( anExtension == "med" ) {
- //TMeshBulder aBuilder( argv );
- TColoredPrsBulder aBuilder( argv );
- return RenderPresentation( aBuilder );
- } else if ( anExtension == "xls" || anExtension == "txt" )
- return RenderPresentation( TXLSSource( argv ) );
+ if(allInit){
+
+ vtkRenderWindow *aWindow = vtkRenderWindow::New();
+ vtkRenderer *aRenderer = vtkRenderer::New();
+
+ aWindow->AddRenderer(aRenderer);
+ aRenderer->GetActiveCamera()->ParallelProjectionOn();
+
+ vtkRenderWindowInteractor *anInteractor = vtkRenderWindowInteractor::New();
+ anInteractor->SetRenderWindow(aWindow);
+ aWindow->Delete();
+
+ vtkInteractorStyle* aStyle = vtkInteractorStyleTrackballCamera::New();
+ anInteractor->SetInteractorStyle(aStyle);
+ aStyle->Delete();
+
+ VISU_Convertor* aConvertor = CreateConvertor(aFileName);
+ aConvertor->BuildEntities();
+ aConvertor->BuildGroups();
+ aConvertor->BuildFields();
+ aConvertor->BuildMinMax();
+ const VISU::TMeshMap& aMeshMap = aConvertor->GetMeshMap();
+ VISU::TMeshMap::const_iterator aMeshMapIter = aMeshMap.begin();
+ if(aMeshMapIter == aMeshMap.end()) return 0;
+ //Iterate by meshes
+ for (;aMeshMapIter != aMeshMap.end();aMeshMapIter++) {
+
+ const std::string& theMeshName = aMeshMapIter->first;
+ if( strcmp(aMeshName, theMeshName.c_str()) )
+ continue;
+ else
+ isMeshOk = true;
+
+ const VISU::PMesh aMesh = aMeshMapIter->second;
+ const VISU::TMeshOnEntityMap& aMeshOnEntityMap = aMesh->myMeshOnEntityMap;
+ VISU::TMeshOnEntityMap::const_iterator aMeshOnEntityMapIter;
+
+ aMeshOnEntityMapIter = aMeshOnEntityMap.begin();
+ //Iterate by meshes on entity
+ for(; aMeshOnEntityMapIter != aMeshOnEntityMap.end(); aMeshOnEntityMapIter++) {
+ const VISU::TEntity& anEntity = aMeshOnEntityMapIter->first;
+ const VISU::PMeshOnEntity aMeshOnEntity = aMeshOnEntityMapIter->second;
+
+ const VISU::TFieldMap& aFieldMap = aMeshOnEntity->myFieldMap;
+ VISU::TFieldMap::const_iterator aFieldMapIter = aFieldMap.begin();
+
+ //Iterate by field
+ for(; aFieldMapIter != aFieldMap.end(); aFieldMapIter++){
+ const VISU::PField aField = aFieldMapIter->second;
+ const std::string& theFieldName = aFieldMapIter->first;
+
+ if( strcmp(aFieldName, theFieldName.c_str()) )
+ continue;
+ else
+ isFieldOk = true;
+
+ if(aComponentNumber > aField->myNbComp)
+ continue;
+ else
+ isComponentOk = true;
+
+ const VISU::TValField& aValField = aField->myValField;
+ VISU::TValField::const_iterator aValFieldIter = 0;
+ aValFieldIter = aValField.find(aTimeStampNumber);
+ if(aValFieldIter == aValField.end())
+ continue;
+ else
+ isTimeStampOk = true;
+
+ int aTimeStamp = aValFieldIter->first;
+
+ vtkActor* anActor = vtkActor::New();
+
+ if(anEntity != VISU::NODE_ENTITY){
+ VISU::PUnstructuredGridIDMapper anUnstructuredGridIDMapper =
+ aConvertor->GetTimeStampOnMesh(theMeshName,
+ anEntity,
+ theFieldName,
+ aTimeStamp);
+
+ VISU_ElnoGeometryFilter *aGeometryFilter = VISU_ElnoGeometryFilter::New();
+ aGeometryFilter->SetScalarMode(aComponentNumber);
+ aGeometryFilter->SetInput( anUnstructuredGridIDMapper->GetUnstructuredGridOutput() );
+ aGeometryFilter->Update();
+
+ VISU_OpenGLElnoMapper* aMapper = VISU_OpenGLElnoMapper::New();
+ aMapper->SetInput( aGeometryFilter->GetOutput() );
+
+
+ double* range = aGeometryFilter->GetRange();
+
+ VISU_LookupTable* aMapperTable( VISU_LookupTable::New() );
+ aMapperTable->SetHueRange(0.667, 0.0);
+ aMapperTable->SetRange( aGeometryFilter->GetRange() );
+ aMapperTable->Build();
+
+
+ aMapper->SetLookupTable( aMapperTable );
+ aMapper->SetUseLookupTableScalarRange( true );
+ aMapper->SetColorModeToMapScalars();
+ aMapper->ScalarVisibilityOn();
+
+
+ anActor->SetMapper( aMapper );
+
+ VISU_ScalarBarActor * aScalarBar = VISU_ScalarBarActor::New();
+ aScalarBar->SetLookupTable( aMapperTable );
+
+ aRenderer->AddActor(anActor);
+ aRenderer->AddActor2D(aScalarBar);
+ }else{
+ continue;
+ }
+
+ aWindow->Render();
+ aRenderer->ResetCamera();
+
+ anInteractor->Start();
+ return 0;
+ }
+ }
}
}
+ else{
+ PrintMissing();
+ return 1;
+ }
+
+ if(!isMeshOk) {
+ PrintErr();
+ cout<<"Can not find mesh with name `"<<aMeshName<<"' in the file `"<<aFileName<<"'"<<endl;
+ PrintErr();
+ return 1;
+ }
+ if(!isFieldOk) {
+ PrintErr();
+ cout<<"Can not find field with name `"<<aFieldName<<"' on the mesh `"<<aMeshName<<"'"<<endl;
+ PrintErr();
+ return 1;
+ }
+ if(!isComponentOk) {
+ PrintErr();
+ cout<<"Field field with name `"<<aFieldName<<"' containt less then `"<<aComponentNumber<<"' component(s)."<<endl;
+ PrintErr();
+ return 1;
+ }
+ if(!isTimeStampOk) {
+ PrintErr();
+ cout<<"Can not find time stamp with number `"<<aTimeStampNumber<<"' on the field `"<<aFieldName<<"'"<<endl;
+ PrintErr();
+ }
}catch(std::exception& exc){
MSG(true, "Follow exception was occured :\n"<<exc.what());
}catch(...){
- MSG(true, "Unknown exception was occured!");
+ MSG(true, "Unknown exception was occured in VISU_Convertor_impl");
}
return 1;
}
--- /dev/null
+#include "VISU_ElnoGeometryFilter.hxx"
+#include "VISU_ConvertorUtils.hxx"
+
+#include <vtkCellArray.h>
+#include <vtkCellData.h>
+#include <vtkGenericCell.h>
+#include <vtkHexagonalPrism.h>
+#include <vtkHexahedron.h>
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
+#include <vtkMergePoints.h>
+#include <vtkObjectFactory.h>
+#include <vtkPointData.h>
+#include <vtkPolyData.h>
+#include <vtkPyramid.h>
+#include <vtkPentagonalPrism.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkStructuredGrid.h>
+#include <vtkTetra.h>
+#include <vtkUnsignedCharArray.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkVoxel.h>
+#include <vtkWedge.h>
+#include <vtkObjectFactory.h>
+
+vtkCxxRevisionMacro(VISU_ElnoGeometryFilter, "$Revision$");
+vtkStandardNewMacro(VISU_ElnoGeometryFilter);
+
+
+//----------------------------------------------------------------------------------------------
+// Construct with all types of clipping turned off.
+VISU_ElnoGeometryFilter::VISU_ElnoGeometryFilter()
+{
+ this->PointMinimum = 0;
+ this->PointMaximum = VTK_LARGE_ID;
+
+ this->CellMinimum = 0;
+ this->CellMaximum = VTK_LARGE_ID;
+
+ this->Extent[0] = -VTK_DOUBLE_MAX;
+ this->Extent[1] = VTK_DOUBLE_MAX;
+ this->Extent[2] = -VTK_DOUBLE_MAX;
+ this->Extent[3] = VTK_DOUBLE_MAX;
+ this->Extent[4] = -VTK_DOUBLE_MAX;
+ this->Extent[5] = VTK_DOUBLE_MAX;
+
+ this->PointClipping = 0;
+ this->CellClipping = 0;
+ this->ExtentClipping = 0;
+
+ this->Merging = 0;
+ this->Locator = NULL;
+
+ myElnoData = NULL;
+ myElnoMapper = NULL;
+ myScalarMode = 0;
+ myMinMax[0] = 0.;
+ myMinMax[1] = 1.;
+}
+//----------------------------------------------------------------------------------------------
+VISU_ElnoGeometryFilter::~VISU_ElnoGeometryFilter()
+{
+ if ( this->Locator )
+ {
+ this->Locator->UnRegister(this);
+ this->Locator = NULL;
+ }
+}
+
+//----------------------------------------------------------------------------------------------
+int VISU_ElnoGeometryFilter::RequestData(vtkInformation *request,
+ vtkInformationVector **inputVector,
+ vtkInformationVector *outputVector)
+{
+ // get the info objects
+ vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
+ vtkInformation *outInfo = outputVector->GetInformationObject(0);
+
+ // get the input and ouptut
+ vtkDataSet *input = vtkDataSet::SafeDownCast(
+ inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ vtkPolyData *output = vtkPolyData::SafeDownCast(
+ outInfo->Get(vtkDataObject::DATA_OBJECT()));
+
+ vtkIdType numCells=input->GetNumberOfCells();
+
+ if(!InitInternalArray(input))
+ return 1;
+
+ if (numCells == 0)
+ {
+ return 1;
+ }
+
+ if (input->GetDataObjectType() == VTK_UNSTRUCTURED_GRID){
+ this->UnstructuredGridExecute(input, output, outInfo);
+ return 1;
+ }else
+ return Superclass::RequestData(request,inputVector,outputVector);
+
+ return 1;
+}
+//----------------------------------------------------------------------------------------------
+template<typename TValueType>
+void CopyArray(TValueType *outputPtr, TValueType* inputPtr,const vtkIdType& theDataSize){
+ for(vtkIdType iData =0;iData < theDataSize;iData++){
+ *outputPtr = *inputPtr;
+ outputPtr++;inputPtr++;
+ }
+}
+//----------------------------------------------------------------------------------------------
+void VISU_ElnoGeometryFilter::UnstructuredGridExecute(vtkDataSet *dataSetInput,
+ vtkPolyData *output,
+ vtkInformation *outInfo)
+{
+ vtkUnstructuredGrid *input= (vtkUnstructuredGrid *)dataSetInput;
+ vtkCellArray *Connectivity = input->GetCells();
+ if (Connectivity == NULL)
+ {
+ return;
+ }
+
+ //Create data array
+ vtkDataArray * aElnoScalars = vtkDataArray::CreateDataArray(myElnoData->GetDataType());
+
+ vtkIdType cellId;
+ int i;
+ int allVisible;
+ vtkIdType npts = 0;
+ vtkIdType *pts = 0;
+ vtkPoints *p = input->GetPoints();
+ vtkIdType numCells=input->GetNumberOfCells();
+ vtkPointData *pd = input->GetPointData();
+ vtkCellData *cd = input->GetCellData();
+ vtkPointData *outputPD = output->GetPointData();
+ vtkCellData *outputCD = output->GetCellData();
+ vtkCellArray *Verts, *Lines, *Polys, *Strips;
+ vtkIdList *cellIds, *faceIds;
+ char *cellVis;
+ vtkIdType newCellId;
+ int faceId, *faceVerts, numFacePts;
+ double x[3];
+ int PixelConvert[4];
+ // ghost cell stuff
+ unsigned char updateLevel = (unsigned char)
+ (outInfo->Get(
+ vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS()));
+ unsigned char *cellGhostLevels = 0;
+
+ PixelConvert[0] = 0;
+ PixelConvert[1] = 1;
+ PixelConvert[2] = 3;
+ PixelConvert[3] = 2;
+
+ vtkDebugMacro(<<"Executing geometry filter for unstructured grid input");
+
+ vtkDataArray* temp = 0;
+ if (cd)
+ {
+ temp = cd->GetArray("vtkGhostLevels");
+ }
+ if ( (!temp) || (temp->GetDataType() != VTK_UNSIGNED_CHAR)
+ || (temp->GetNumberOfComponents() != 1))
+ {
+ vtkDebugMacro("No appropriate ghost levels field available.");
+ }
+ else
+ {
+ cellGhostLevels = ((vtkUnsignedCharArray*)temp)->GetPointer(0);
+ }
+
+ // Check input
+ if ( Connectivity == NULL )
+ {
+ vtkDebugMacro(<<"Nothing to extract");
+ return;
+ }
+
+ // Determine nature of what we have to do
+ cellIds = vtkIdList::New();
+ faceIds = vtkIdList::New();
+ if ( (!this->CellClipping) && (!this->PointClipping) &&
+ (!this->ExtentClipping) )
+ {
+ allVisible = 1;
+ cellVis = NULL;
+ }
+ else
+ {
+ allVisible = 0;
+ cellVis = new char[numCells];
+ }
+
+ // Just pass points through, never merge
+ output->SetPoints(input->GetPoints());
+ outputPD->PassData(pd);
+
+ outputCD->CopyAllocate(cd,numCells,numCells/2);
+
+ Verts = vtkCellArray::New();
+ Verts->Allocate(numCells/4+1,numCells);
+ Lines = vtkCellArray::New();
+ Lines->Allocate(numCells/4+1,numCells);
+ Polys = vtkCellArray::New();
+ Polys->Allocate(numCells/4+1,numCells);
+ Strips = vtkCellArray::New();
+ Strips->Allocate(numCells/4+1,numCells);
+
+ // Loop over the cells determining what's visible
+ if (!allVisible)
+ {
+ for (cellId=0, Connectivity->InitTraversal();
+ Connectivity->GetNextCell(npts,pts);
+ cellId++)
+ {
+ cellVis[cellId] = 1;
+ if ( this->CellClipping && cellId < this->CellMinimum ||
+ cellId > this->CellMaximum )
+ {
+ cellVis[cellId] = 0;
+ }
+ else
+ {
+ for (i=0; i < npts; i++)
+ {
+ p->GetPoint(pts[i], x);
+ if ( (this->PointClipping && (pts[i] < this->PointMinimum ||
+ pts[i] > this->PointMaximum) ) ||
+ (this->ExtentClipping &&
+ (x[0] < this->Extent[0] || x[0] > this->Extent[1] ||
+ x[1] < this->Extent[2] || x[1] > this->Extent[3] ||
+ x[2] < this->Extent[4] || x[2] > this->Extent[5] )) )
+ {
+ cellVis[cellId] = 0;
+ break;
+ }//point/extent clipping
+ }//for each point
+ }//if point clipping needs checking
+ }//for all cells
+ }//if not all visible
+
+ // Loop over all cells now that visibility is known
+ // (Have to compute visibility first for 3D cell boundarys)
+ int progressInterval = numCells/20 + 1;
+
+ vtkDataArray *aTmpElnoComponents = vtkDataArray::CreateDataArray(myElnoData->GetDataType());
+ aTmpElnoComponents->SetNumberOfComponents(1);
+
+
+ vtkDataArray *aTmpElnoScalars = vtkDataArray::CreateDataArray(myElnoData->GetDataType());
+ aTmpElnoScalars->SetNumberOfComponents(1);
+ vtkIdType aPosition = 0;
+
+ for (cellId=0, Connectivity->InitTraversal();
+ Connectivity->GetNextCell(npts,pts);
+ cellId++)
+ {
+ //Progress and abort method support
+ if ( !(cellId % progressInterval) )
+ {
+ vtkDebugMacro(<<"Process cell #" << cellId);
+ this->UpdateProgress ((double)cellId/numCells);
+ }
+
+ // Handle ghost cells here. Another option was used cellVis array.
+ if (cellGhostLevels && cellGhostLevels[cellId] > updateLevel)
+ { // Do not create surfaces in outer ghost cells.
+ continue;
+ }
+
+ if (allVisible || cellVis[cellId]) //now if visible extract geometry
+ {
+ //special code for nonlinear cells - rarely occurs, so right now it
+ //is slow.
+ //Create temporary data array
+ vtkDataArray *aComponents = vtkDataArray::CreateDataArray(myElnoData->GetDataType());
+ aComponents->SetNumberOfComponents(2);
+ switch (input->GetCellType(cellId))
+ {
+ case VTK_EMPTY_CELL:
+ break;
+
+ case VTK_VERTEX:
+ case VTK_POLY_VERTEX:
+ newCellId = Verts->InsertNextCell(npts,pts);
+ outputCD->CopyData(cd,cellId,newCellId);
+ break;
+
+ case VTK_LINE:
+ case VTK_POLY_LINE:
+ newCellId = Lines->InsertNextCell(npts,pts);
+ outputCD->CopyData(cd,cellId,newCellId);
+ break;
+
+ //--
+ case VTK_TRIANGLE:
+ case VTK_QUAD:
+ case VTK_POLYGON:
+ newCellId = Polys->InsertNextCell(npts,pts);
+ outputCD->CopyData(cd,cellId,newCellId);
+
+ //Copy Elno Data
+ this->GetElementData(cellId, aComponents);
+ this->CopyElementData(aTmpElnoComponents,aTmpElnoScalars,aComponents,aPosition);
+ break;
+
+ case VTK_TRIANGLE_STRIP:
+ newCellId = Strips->InsertNextCell(npts,pts);
+ outputCD->CopyData(cd,cellId,newCellId);
+ break;
+
+ case VTK_PIXEL:
+ //Get Elno Data
+ GetElementData(cellId, aComponents);
+
+ newCellId = Polys->InsertNextCell(npts);
+ for ( i=0; i < npts; i++)
+ {
+ Polys->InsertCellPoint(pts[PixelConvert[i]]);
+ //Copy Elno Data
+ this->CopyElementData(aTmpElnoComponents,aTmpElnoScalars,aComponents,aPosition,PixelConvert[i]);
+ }
+ outputCD->CopyData(cd,cellId,newCellId);
+ break;
+
+ case VTK_TETRA:
+ //Get Elno Data
+ GetElementData(cellId, aComponents);
+ for (faceId = 0; faceId < 4; faceId++)
+ {
+ faceIds->Reset();
+ faceVerts = vtkTetra::GetFaceArray(faceId);
+ faceIds->InsertNextId(pts[faceVerts[0]]);
+ faceIds->InsertNextId(pts[faceVerts[1]]);
+ faceIds->InsertNextId(pts[faceVerts[2]]);
+ numFacePts = 3;
+ input->GetCellNeighbors(cellId, faceIds, cellIds);
+ if ( cellIds->GetNumberOfIds() <= 0 ||
+ (!allVisible && !cellVis[cellIds->GetId(0)]) )
+ {
+ newCellId = Polys->InsertNextCell(numFacePts);
+ for ( i=0; i < numFacePts; i++)
+ {
+ Polys->InsertCellPoint(pts[faceVerts[i]]);
+ //Copy Elno Data
+ this->CopyElementData(aTmpElnoComponents,aTmpElnoScalars,aComponents,aPosition,faceVerts[i]);
+ }
+ outputCD->CopyData(cd,cellId,newCellId);
+ }
+ }
+ break;
+
+ case VTK_VOXEL:
+ GetElementData(cellId, aComponents);
+ for (faceId = 0; faceId < 6; faceId++)
+ {
+ faceIds->Reset();
+ faceVerts = vtkVoxel::GetFaceArray(faceId);
+ faceIds->InsertNextId(pts[faceVerts[0]]);
+ faceIds->InsertNextId(pts[faceVerts[1]]);
+ faceIds->InsertNextId(pts[faceVerts[2]]);
+ faceIds->InsertNextId(pts[faceVerts[3]]);
+ numFacePts = 4;
+ input->GetCellNeighbors(cellId, faceIds, cellIds);
+ if ( cellIds->GetNumberOfIds() <= 0 ||
+ (!allVisible && !cellVis[cellIds->GetId(0)]) )
+ {
+ newCellId = Polys->InsertNextCell(numFacePts);
+ for ( i=0; i < numFacePts; i++)
+ {
+ Polys->InsertCellPoint(pts[faceVerts[PixelConvert[i]]]);
+ //Copy Elno Data
+ this->CopyElementData(aTmpElnoComponents,aTmpElnoScalars,aComponents,aPosition,faceVerts[PixelConvert[i]]);
+ }
+ outputCD->CopyData(cd,cellId,newCellId);
+ }
+ }
+ break;
+
+ case VTK_HEXAHEDRON:
+ //Get Elno Data
+ GetElementData(cellId, aComponents);
+ for (faceId = 0; faceId < 6; faceId++)
+ {
+ faceIds->Reset();
+ faceVerts = vtkHexahedron::GetFaceArray(faceId);
+ faceIds->InsertNextId(pts[faceVerts[0]]);
+ faceIds->InsertNextId(pts[faceVerts[1]]);
+ faceIds->InsertNextId(pts[faceVerts[2]]);
+ faceIds->InsertNextId(pts[faceVerts[3]]);
+ numFacePts = 4;
+ input->GetCellNeighbors(cellId, faceIds, cellIds);
+ if ( cellIds->GetNumberOfIds() <= 0 ||
+ (!allVisible && !cellVis[cellIds->GetId(0)]) )
+ {
+ newCellId = Polys->InsertNextCell(numFacePts);
+ for ( i=0; i < numFacePts; i++)
+ {
+ Polys->InsertCellPoint(pts[faceVerts[i]]);
+ //Copy Elno Data
+ this->CopyElementData(aTmpElnoComponents,aTmpElnoScalars,aComponents,aPosition,faceVerts[i]);
+ }
+ outputCD->CopyData(cd,cellId,newCellId);
+ }
+ }
+ break;
+
+ case VTK_WEDGE:
+ //Get Elno Data
+ GetElementData(cellId, aComponents);
+ for (faceId = 0; faceId < 5; faceId++)
+ {
+ faceIds->Reset();
+ faceVerts = vtkWedge::GetFaceArray(faceId);
+ faceIds->InsertNextId(pts[faceVerts[0]]);
+ faceIds->InsertNextId(pts[faceVerts[1]]);
+ faceIds->InsertNextId(pts[faceVerts[2]]);
+ numFacePts = 3;
+ if (faceVerts[3] >= 0)
+ {
+ faceIds->InsertNextId(pts[faceVerts[3]]);
+ numFacePts = 4;
+ }
+ input->GetCellNeighbors(cellId, faceIds, cellIds);
+ if ( cellIds->GetNumberOfIds() <= 0 ||
+ (!allVisible && !cellVis[cellIds->GetId(0)]) )
+ {
+ newCellId = Polys->InsertNextCell(numFacePts);
+ for ( i=0; i < numFacePts; i++)
+ {
+ Polys->InsertCellPoint(pts[faceVerts[i]]);
+ //Copy Elno Data
+ this->CopyElementData(aTmpElnoComponents,aTmpElnoScalars,aComponents,aPosition,faceVerts[i]);
+ }
+ outputCD->CopyData(cd,cellId,newCellId);
+ }
+ }
+ break;
+
+ case VTK_PYRAMID:
+ //Get Elno Data
+ GetElementData(cellId, aComponents);
+ for (faceId = 0; faceId < 5; faceId++)
+ {
+ faceIds->Reset();
+ faceVerts = vtkPyramid::GetFaceArray(faceId);
+ faceIds->InsertNextId(pts[faceVerts[0]]);
+ faceIds->InsertNextId(pts[faceVerts[1]]);
+ faceIds->InsertNextId(pts[faceVerts[2]]);
+ numFacePts = 3;
+ if (faceVerts[3] >= 0)
+ {
+ faceIds->InsertNextId(pts[faceVerts[3]]);
+ numFacePts = 4;
+ }
+ input->GetCellNeighbors(cellId, faceIds, cellIds);
+ if ( cellIds->GetNumberOfIds() <= 0 ||
+ (!allVisible && !cellVis[cellIds->GetId(0)]) )
+ {
+ newCellId = Polys->InsertNextCell(numFacePts);
+ for ( i=0; i < numFacePts; i++)
+ {
+ Polys->InsertCellPoint(pts[faceVerts[i]]);
+ //Copy Elno Data
+ this->CopyElementData(aTmpElnoComponents,aTmpElnoScalars,aComponents,aPosition,faceVerts[i]);
+ }
+ outputCD->CopyData(cd,cellId,newCellId);
+ }
+ }
+ break;
+
+ case VTK_PENTAGONAL_PRISM:
+ //Get Elno Data
+ GetElementData(cellId, aComponents);
+ for (faceId = 0; faceId < 7; faceId++)
+ {
+ faceIds->Reset();
+ faceVerts = vtkPentagonalPrism::GetFaceArray(faceId);
+ faceIds->InsertNextId(pts[faceVerts[0]]);
+ faceIds->InsertNextId(pts[faceVerts[1]]);
+ faceIds->InsertNextId(pts[faceVerts[2]]);
+ faceIds->InsertNextId(pts[faceVerts[3]]);
+ numFacePts = 4;
+ if (faceVerts[4] >= 0)
+ {
+ faceIds->InsertNextId(pts[faceVerts[4]]);
+ numFacePts = 5;
+ }
+ input->GetCellNeighbors(cellId, faceIds, cellIds);
+ if ( cellIds->GetNumberOfIds() <= 0 ||
+ (!allVisible && !cellVis[cellIds->GetId(0)]) )
+ {
+ newCellId = Polys->InsertNextCell(numFacePts);
+ for ( i=0; i < numFacePts; i++)
+ {
+ Polys->InsertCellPoint(pts[faceVerts[i]]);
+ //Copy Elno Data
+ this->CopyElementData(aTmpElnoComponents,aTmpElnoScalars,aComponents,aPosition,faceVerts[i]);
+ }
+ outputCD->CopyData(cd,cellId,newCellId);
+ }
+ }
+ break;
+
+ case VTK_HEXAGONAL_PRISM:
+ //Get Elno Data
+ GetElementData(cellId, aComponents);
+ for (faceId = 0; faceId < 8; faceId++)
+ {
+ faceIds->Reset();
+ faceVerts = vtkHexagonalPrism::GetFaceArray(faceId);
+ faceIds->InsertNextId(pts[faceVerts[0]]);
+ faceIds->InsertNextId(pts[faceVerts[1]]);
+ faceIds->InsertNextId(pts[faceVerts[2]]);
+ faceIds->InsertNextId(pts[faceVerts[3]]);
+ numFacePts = 4;
+ if (faceVerts[4] >= 0)
+ {
+ faceIds->InsertNextId(pts[faceVerts[4]]);
+ faceIds->InsertNextId(pts[faceVerts[5]]);
+ numFacePts = 6;
+ }
+ input->GetCellNeighbors(cellId, faceIds, cellIds);
+ if ( cellIds->GetNumberOfIds() <= 0 ||
+ (!allVisible && !cellVis[cellIds->GetId(0)]) )
+ {
+ newCellId = Polys->InsertNextCell(numFacePts);
+ for ( i=0; i < numFacePts; i++)
+ {
+ Polys->InsertCellPoint(pts[faceVerts[i]]);
+ //Copy Elno Data
+ this->CopyElementData(aTmpElnoComponents,aTmpElnoScalars,aComponents,aPosition,faceVerts[i]);
+ }
+ outputCD->CopyData(cd,cellId,newCellId);
+ }
+ }
+ break;
+
+ //Quadratic cells
+ case VTK_QUADRATIC_EDGE:
+ case VTK_QUADRATIC_TRIANGLE:
+ case VTK_QUADRATIC_QUAD:
+ case VTK_QUADRATIC_TETRA:
+ case VTK_QUADRATIC_HEXAHEDRON:
+ case VTK_QUADRATIC_WEDGE:
+ case VTK_QUADRATIC_PYRAMID:
+ {
+ vtkGenericCell *cell = vtkGenericCell::New();
+ input->GetCell(cellId,cell);
+ vtkIdList *ipts = vtkIdList::New();
+ vtkPoints *coords = vtkPoints::New();
+ vtkIdList *icellIds = vtkIdList::New();
+ vtkIdType inewCellId;
+
+ if ( cell->GetCellDimension() == 1 )
+ {
+ cell->Triangulate(0,ipts,coords);
+ for (i=0; i < ipts->GetNumberOfIds(); i+=2)
+ {
+ inewCellId = Lines->InsertNextCell(2);
+ Lines->InsertCellPoint(ipts->GetId(i));
+ Lines->InsertCellPoint(ipts->GetId(i+1));
+ outputCD->CopyData(cd,cellId,inewCellId);
+ }
+ }
+ else if ( cell->GetCellDimension() == 2 )
+ {
+ cell->Triangulate(0,ipts,coords);
+ for (i=0; i < ipts->GetNumberOfIds(); i+=3)
+ {
+ inewCellId = Polys->InsertNextCell(3);
+ Polys->InsertCellPoint(ipts->GetId(i));
+ Polys->InsertCellPoint(ipts->GetId(i+1));
+ Polys->InsertCellPoint(ipts->GetId(i+2));
+ outputCD->CopyData(cd,cellId,inewCellId);
+ }
+ }
+ else //3D nonlinear cell
+ {
+ vtkCell *face;
+ for (int j=0; j < cell->GetNumberOfFaces(); j++)
+ {
+ face = cell->GetFace(j);
+ input->GetCellNeighbors(cellId, face->PointIds, icellIds);
+ if ( icellIds->GetNumberOfIds() <= 0)
+ {
+ face->Triangulate(0,ipts,coords);
+ for (i=0; i < ipts->GetNumberOfIds(); i+=3)
+ {
+ inewCellId = Polys->InsertNextCell(3);
+ Polys->InsertCellPoint(ipts->GetId(i));
+ Polys->InsertCellPoint(ipts->GetId(i+1));
+ Polys->InsertCellPoint(ipts->GetId(i+2));
+ outputCD->CopyData(cd,cellId,inewCellId);
+ }
+ }
+ }
+ } //3d cell
+ icellIds->Delete();
+ coords->Delete();
+ ipts->Delete();
+ cell->Delete();
+ }
+ break; //done with quadratic cells
+
+ } //switch
+ aComponents->Delete();
+ } //if visible
+ } //for all cells
+
+ // Update ourselves and release memory
+ //
+ output->SetVerts(Verts);
+ Verts->Delete();
+ output->SetLines(Lines);
+ Lines->Delete();
+ output->SetPolys(Polys);
+ Polys->Delete();
+ output->SetStrips(Strips);
+ Strips->Delete();
+
+
+ myMinMax[0] = *(aTmpElnoScalars->GetTuple(0));
+ myMinMax[1] = *(aTmpElnoScalars->GetTuple(0));
+
+ //Build Min and Max
+ for(vtkIdType count = 0;count < aTmpElnoScalars->GetSize();count++){
+ double s = *(aTmpElnoScalars->GetTuple(count));
+ if(s < myMinMax[0]){
+ myMinMax[0] = s;
+ }
+ else if(s > myMinMax[1])
+ {
+ myMinMax[1] = s;
+ }
+ }
+
+ vtkIdType aNbEffectiveComponents = (aTmpElnoScalars->GetSize()/output->GetNumberOfCells())+1;
+
+ vtkDataArray *aElnoPseudoScalars = vtkDataArray::CreateDataArray(this->myElnoData->GetDataType());
+ aElnoPseudoScalars->SetName("ELNO_PSEUDO_SCALARS");
+ aElnoPseudoScalars->SetNumberOfTuples(aTmpElnoComponents->GetSize());
+ aElnoPseudoScalars->SetNumberOfComponents(1);
+
+
+ switch(this->myElnoData->GetDataType()){
+
+ vtkTemplateMacro3(CopyArray,
+ static_cast<VTK_TT*>(aElnoPseudoScalars->GetVoidPointer(0)),
+ static_cast<VTK_TT*>(aTmpElnoScalars->GetVoidPointer(0)),
+ aTmpElnoScalars->GetSize());
+ default:
+ break;
+ }
+
+ output->GetCellData()->AddArray(aElnoPseudoScalars);
+ output->Squeeze();
+
+ aElnoPseudoScalars->Delete();
+
+ aTmpElnoComponents->Delete();
+
+ vtkDebugMacro(<<"Extracted " << input->GetNumberOfPoints() << " points,"
+ << output->GetNumberOfCells() << " cells.");
+ cellIds->Delete();
+ faceIds->Delete();
+ if ( cellVis )
+ {
+ delete [] cellVis;
+ }
+}
+
+//----------------------------------------------------------------------------------------------
+void VISU_ElnoGeometryFilter::SetScalarMode(vtkIdType theScalarMode){
+ if(myScalarMode == theScalarMode)
+ return;
+ myScalarMode = theScalarMode;
+}
+
+//----------------------------------------------------------------------------------------------
+vtkIdType VISU_ElnoGeometryFilter::GetScalarMode() const{
+ return myScalarMode;
+}
+
+//----------------------------------------------------------------------------------------------
+double* VISU_ElnoGeometryFilter::GetRange(){
+ return myMinMax;
+}
+
+//----------------------------------------------------------------------------------------------
+bool VISU_ElnoGeometryFilter::InitInternalArray(vtkDataSet *input){
+
+ if (!VISU::IsDataOnElnoCells(input))
+ return false;
+ myElnoData = input->GetCellData()->GetArray("ELNO_FIELD");
+ myElnoMapper = input->GetCellData()->GetArray("ELNO_COMPONENT_MAPPER");
+ return true;
+}
+
+
+//----------------------------------------------------------------------------------------------
+template<typename TValueType>
+void
+GetElementDataByModulus(TValueType* theInputPtr,
+ TValueType* theOutputPtr,
+ const vtkIdType& theDataSize,
+ const vtkIdType& theNbComponent )
+{
+ vtkFloatingPointType aScalar;
+ for(vtkIdType iData = 0; iData < theDataSize; iData++){
+ aScalar = 0;
+ for(vtkIdType iComponent=0; iComponent < theNbComponent; iComponent++){
+ aScalar += (*(theInputPtr+iComponent))*(*(theInputPtr+iComponent));
+ }
+ *theOutputPtr = TValueType(sqrt(aScalar));
+ theOutputPtr++;
+ theInputPtr += theNbComponent;
+ }
+}
+
+//----------------------------------------------------------------------------------------------
+template<typename TValueType>
+void GetElementDataByComponent(TValueType* theInputPtr,
+ TValueType* theOutputPtr,
+ const vtkIdType& theComponentId,
+ const vtkIdType& theDataSize,
+ const vtkIdType& theNbComponent){
+ for(vtkIdType iValue = 0; iValue < theDataSize; iValue++){
+ *theOutputPtr = *(theInputPtr + theComponentId);
+ theInputPtr+=theNbComponent;
+ theOutputPtr++;
+ }
+}
+
+//----------------------------------------------------------------------------------------------
+
+template <typename TValueType>
+void CopyArray1(TValueType *theInputPtr,
+ TValueType *theOutPtr,
+ const vtkIdType& theDataSize,
+ const vtkIdType& theNbComponent)
+{
+ for(vtkIdType iData = 0; iData < theDataSize; iData++){
+ for(vtkIdType iComponent=0; iComponent < theNbComponent;iComponent++){
+ *theOutPtr++ = *theInputPtr++;
+ }
+ }
+}
+
+//----------------------------------------------------------------------------------------------
+void VISU_ElnoGeometryFilter::GetElementData(const vtkIdType& theElemId,
+ vtkDataArray* theOutArray){
+ if(myElnoMapper){
+ int aElemInfo[3];
+ vtkIntArray *anArray = vtkIntArray::SafeDownCast(myElnoMapper);
+ anArray->GetTupleValue(theElemId,aElemInfo);
+ vtkIdType aDataSize = aElemInfo[2];
+ vtkIdType aNbComponent = aElemInfo[1];
+ vtkIdType aStartId = aElemInfo[0];
+ theOutArray->SetNumberOfComponents(aNbComponent);
+ theOutArray->SetNumberOfTuples(aDataSize);
+ void *aInputPtr = myElnoData->GetVoidPointer(aStartId);
+ void *aOutputPtr = theOutArray->GetVoidPointer(0);
+
+ switch(myElnoData->GetDataType()){
+ vtkTemplateMacro4(CopyArray1,
+ static_cast<VTK_TT*>(aInputPtr),
+ static_cast<VTK_TT*>(aOutputPtr),
+ aDataSize,
+ aNbComponent);
+ default:
+ break;
+ }
+ }
+ else {
+ theOutArray->SetNumberOfTuples(0);
+ theOutArray->SetNumberOfComponents(0);
+ }
+}
+
+//----------------------------------------------------------------------------------------------
+/*!
+ Copy Elno Element (or) point data
+*/
+
+void
+VISU_ElnoGeometryFilter::CopyElementData(vtkDataArray *toComponents,
+ vtkDataArray *toScalars,
+ vtkDataArray *from,
+ vtkIdType& position,
+ const vtkIdType& PntId) const
+{
+ //Optimize needed
+ vtkIdType aNbComponents = from->GetNumberOfComponents();
+
+ vtkDataArray *tmpComponents = vtkDataArray::CreateDataArray(this->myElnoData->GetDataType());
+ tmpComponents->SetNumberOfTuples(toComponents->GetNumberOfTuples());
+ tmpComponents->DeepCopy(toComponents);
+
+ vtkDataArray *tmpScalars = vtkDataArray::CreateDataArray(this->myElnoData->GetDataType());
+ tmpScalars->SetNumberOfTuples(toScalars->GetNumberOfTuples());
+ tmpScalars->DeepCopy(toScalars);
+
+ vtkIdType aDataSize = 0;
+ void *inputPtr = NULL;
+
+
+ if(PntId == -2){
+ aDataSize = from->GetNumberOfTuples();
+ inputPtr = from->GetVoidPointer(0);
+ }
+ else{
+ aDataSize = 1;
+ inputPtr = from->GetVoidPointer(PntId*aNbComponents);
+ }
+
+ toComponents->Allocate(position*aNbComponents + aDataSize*aNbComponents);
+ toScalars->Allocate(position+aDataSize);
+
+ switch(this->myElnoData->GetDataType()){
+ vtkTemplateMacro4(CopyArray1,
+ static_cast<VTK_TT*>(tmpComponents->GetVoidPointer(0)),
+ static_cast<VTK_TT*>(toComponents->GetVoidPointer(0)),
+ position*aNbComponents,
+ 1);
+ default:
+ break;
+ }
+
+ switch(this->myElnoData->GetDataType()){
+ vtkTemplateMacro4(CopyArray1,
+ static_cast<VTK_TT*>(tmpScalars->GetVoidPointer(0)),
+ static_cast<VTK_TT*>(toScalars->GetVoidPointer(0)),
+ position,
+ 1);
+ default:
+ break;
+ }
+
+ //Optimize needed
+
+ //Fill Elno Field
+ void *outputComponentsPtr = toComponents->GetVoidPointer(position*aNbComponents);
+ switch(this->myElnoData->GetDataType()){
+ vtkTemplateMacro4(CopyArray1,
+ static_cast<VTK_TT*>(inputPtr),
+ static_cast<VTK_TT*>(outputComponentsPtr),
+ aDataSize,
+ aNbComponents);
+ default:
+ break;
+ }
+
+
+
+ //Fill Scalars array
+ void *outputScalarasPtr = toScalars->GetVoidPointer(position);
+ if( !myScalarMode ) {
+ switch(this->myElnoData->GetDataType()){
+ vtkTemplateMacro4(GetElementDataByModulus,
+ static_cast<VTK_TT*>(inputPtr),
+ static_cast<VTK_TT*>(outputScalarasPtr),
+ aDataSize,
+ aNbComponents);
+ default:
+ break;
+ }
+ }
+ else{
+ switch(this->myElnoData->GetDataType()){
+ vtkTemplateMacro5(GetElementDataByComponent,
+ static_cast<VTK_TT*>(inputPtr),
+ static_cast<VTK_TT*>(outputScalarasPtr),
+ myScalarMode - 1,
+ aDataSize,
+ aNbComponents);
+ default:
+ break;
+ }
+ }
+ position+=aDataSize;
+ tmpComponents->Delete();
+ tmpScalars->Delete();
+}
+
+//----------------------------------------------------------------------------------------------
+vtkIdType VISU_ElnoGeometryFilter::GetNbOfEffectiveElnoComponents(vtkCellData *theInputData){
+ vtkIdType nbEffectiveComponents = -1;
+ vtkDataArray* aFieldArray = theInputData->GetArray("ELNO_FIELD");
+ if(aFieldArray){
+ nbEffectiveComponents = aFieldArray->GetNumberOfComponents();
+ }
+ return nbEffectiveComponents;
+}
+//----------------------------------------------------------------------------------------------
+int VISU_ElnoGeometryFilter::GetNbOfElnoComponents(vtkCellData *theInputData) {
+ vtkIdType nbComponents = -1;
+ vtkDataArray* aFieldArray = theInputData->GetArray("ELNO_COMPONENT_MAPPER");
+ if(aFieldArray){
+ vtkIntArray *aInfoArray = vtkIntArray::SafeDownCast(aFieldArray);
+ int aInfo[3];
+ aInfoArray->GetTupleValue(0,aInfo);
+ nbComponents = aInfo[1];
+ }
+ return nbComponents;
+}
+//----------------------------------------------------------------------------------------------
+vtkIdType VISU_ElnoGeometryFilter::GetNbOfElnoTuples(vtkCellData *theInputData) {
+ int nbTuples = 0;
+ vtkDataArray* aFieldArray = theInputData->GetArray("ELNO_COMPONENT_MAPPER");
+ if(aFieldArray){
+ vtkIntArray *aInfoArray = vtkIntArray::SafeDownCast(aFieldArray);
+ vtkIdType nbInfoTyples = aInfoArray->GetNumberOfTuples();
+ int aInfo[3];
+ for( vtkIdType iTuple = 0;iTuple < nbInfoTyples; iTuple++ ){
+ aInfoArray->GetTupleValue(iTuple,aInfo);
+ nbTuples+=aInfo[2];
+ }
+ return nbTuples;
+ }
+ else
+ return -1;
+}
+//----------------------------------------------------------------------------------------------
--- /dev/null
+
+#ifndef VISU_ElnoGeometryFilter_HeaderFile
+#define VISU_ElnoGeometryFilter_HeaderFile
+
+#include <vtkGeometryFilter.h>
+
+class VISU_ElnoGeometryFilter : public vtkGeometryFilter {
+public:
+
+ static VISU_ElnoGeometryFilter *New();
+
+ static vtkIdType GetNbOfElnoComponents(vtkCellData *);
+
+ static vtkIdType GetNbOfEffectiveElnoComponents(vtkCellData *);
+
+ static vtkIdType GetNbOfElnoTuples(vtkCellData *);
+
+ static void PrintElemData(vtkDataArray *arr);
+
+ vtkTypeRevisionMacro(vtkGeometryFilter,vtkPolyDataAlgorithm);
+
+ void SetScalarMode(vtkIdType theScalarMode = 0);
+ vtkIdType GetScalarMode() const;
+ double* GetRange();
+
+protected:
+
+ VISU_ElnoGeometryFilter();
+
+ ~VISU_ElnoGeometryFilter();
+
+ virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
+
+
+ void UnstructuredGridExecute (vtkDataSet *, vtkPolyData *, vtkInformation *);
+ void GetElementData(const vtkIdType& theElemId, vtkDataArray *theOutArray);
+
+
+private:
+ bool InitInternalArray(vtkDataSet *input);
+ void CopyElementData(vtkDataArray *toComponents, //Components
+ vtkDataArray *toScalars, //Scalars
+ vtkDataArray *from,
+ vtkIdType& position,
+ const vtkIdType& PntId = -2 ) const;
+
+private:
+ double myMinMax[2]; // myMinMax[0] - Min
+ // myMinMax[1] - Max
+ vtkDataArray *myElnoData;
+ vtkDataArray *myElnoMapper;
+ vtkIdType myScalarMode;
+};
+
+#endif
--- /dev/null
+#include "VISU_OpenGLElnoMapper.hxx"
+
+#include "vtkCellArray.h"
+#include "vtkCellData.h"
+#include "vtkCommand.h"
+#include "vtkDataArray.h"
+#include "vtkFloatArray.h"
+#include "vtkMatrix4x4.h"
+#include "vtkObjectFactory.h"
+#include "vtkOpenGLRenderer.h"
+#include "vtkPlane.h"
+#include "vtkPlaneCollection.h"
+#include "vtkPointData.h"
+#include "vtkPolyData.h"
+#include "vtkPolygon.h"
+#include "vtkProperty.h"
+#include "vtkTimerLog.h"
+#include "vtkTriangle.h"
+#include "vtkOpenGLRenderWindow.h"
+#include "vtkOpenGLTexture.h"
+#include "vtkImageData.h"
+#include "vtkCellData.h"
+#include "vtkLookupTable.h"
+#include "vtkObjectFactory.h"
+
+#ifndef VTK_IMPLEMENT_MESA_CXX
+# include "vtkOpenGL.h"
+#endif
+
+#include <math.h>
+
+
+#ifndef VTK_IMPLEMENT_MESA_CXX
+vtkCxxRevisionMacro(VISU_OpenGLElnoMapper, "$Revision$");
+vtkStandardNewMacro(VISU_OpenGLElnoMapper);
+#endif
+
+// some definitions for what the polydata has in it
+#define VTK_PDM_NORMALS 0x01
+#define VTK_PDM_COLORS 0x02
+#define VTK_PDM_TCOORDS 0x04
+#define VTK_PDM_CELL_COLORS 0x08
+#define VTK_PDM_CELL_NORMALS 0x10
+#define VTK_PDM_POINT_TYPE_FLOAT 0x20
+#define VTK_PDM_POINT_TYPE_DOUBLE 0x40
+#define VTK_PDM_NORMAL_TYPE_FLOAT 0x80
+#define VTK_PDM_NORMAL_TYPE_DOUBLE 0x100
+#define VTK_PDM_TCOORD_TYPE_FLOAT 0x200
+#define VTK_PDM_TCOORD_TYPE_DOUBLE 0x400
+#define VTK_PDM_TCOORD_1D 0x800
+#define VTK_PDM_OPAQUE_COLORS 0x1000
+#define VTK_PDM_USE_FIELD_DATA 0x2000
+
+
+
+// Construct empty object.
+VISU_OpenGLElnoMapper::VISU_OpenGLElnoMapper()
+{
+ this->ListId = 0;
+ this->TotalCells = 0;
+ this->InternalColorTexture = 0;
+}
+
+// Destructor (don't call ReleaseGraphicsResources() since it is virtual
+VISU_OpenGLElnoMapper::~VISU_OpenGLElnoMapper()
+{
+ if (this->LastWindow)
+ {
+ this->ReleaseGraphicsResources(this->LastWindow);
+ }
+ if (this->InternalColorTexture)
+ { // Resources released previously.
+ this->InternalColorTexture->Delete();
+ this->InternalColorTexture = 0;
+ }
+}
+
+// Release the graphics resources used by this mapper. In this case, release
+// the display list if any.
+void VISU_OpenGLElnoMapper::ReleaseGraphicsResources(vtkWindow *win)
+{
+ if (this->ListId && win)
+ {
+ win->MakeCurrent();
+ glDeleteLists(this->ListId,1);
+ this->ListId = 0;
+ }
+ this->LastWindow = NULL;
+ // We may not want to do this here.
+ if (this->InternalColorTexture)
+ {
+ this->InternalColorTexture->ReleaseGraphicsResources(win);
+ }
+}
+
+//
+// Receives from Actor -> maps data to primitives
+//
+void VISU_OpenGLElnoMapper::RenderPiece(vtkRenderer *ren, vtkActor *act)
+{
+ vtkPolyData *input= this->GetInput();
+ vtkPlaneCollection *clipPlanes;
+ vtkPlane *plane;
+ int i, numClipPlanes;
+ double planeEquation[4];
+
+ //
+ // make sure that we've been properly initialized
+ //
+ if (ren->GetRenderWindow()->CheckAbortStatus())
+ {
+ return;
+ }
+
+ if ( input == NULL )
+ {
+ vtkErrorMacro(<< "No input!");
+ return;
+ }
+ else
+ {
+ this->InvokeEvent(vtkCommand::StartEvent,NULL);
+ if (!this->Static)
+ {
+ input->Update();
+ }
+ this->InvokeEvent(vtkCommand::EndEvent,NULL);
+
+ vtkIdType numPts = input->GetNumberOfPoints();
+ if (numPts == 0)
+ {
+ vtkDebugMacro(<< "No points!");
+ return;
+ }
+ }
+
+ if ( this->LookupTable == NULL )
+ {
+ this->CreateDefaultLookupTable();
+ }
+
+ // make sure our window is current
+ ren->GetRenderWindow()->MakeCurrent();
+
+ clipPlanes = this->ClippingPlanes;
+
+ if (clipPlanes == NULL)
+ {
+ numClipPlanes = 0;
+ }
+ else
+ {
+ numClipPlanes = clipPlanes->GetNumberOfItems();
+ if (numClipPlanes > 6)
+ {
+ vtkErrorMacro(<< "OpenGL guarantees at most 6 additional clipping planes");
+ }
+ }
+
+ for (i = 0; i < numClipPlanes; i++)
+ {
+ glEnable((GLenum)(GL_CLIP_PLANE0+i));
+ }
+
+ if ( clipPlanes )
+ {
+ vtkMatrix4x4 *actorMatrix = vtkMatrix4x4::New();
+ act->GetMatrix( actorMatrix );
+ actorMatrix->Invert();
+
+ double origin[4], normal[3], point[4];
+
+ for (i = 0; i < numClipPlanes; i++)
+ {
+ plane = (vtkPlane *)clipPlanes->GetItemAsObject(i);
+
+ plane->GetOrigin(origin);
+ plane->GetNormal(normal);
+
+ point[0] = origin[0] + normal[0];
+ point[1] = origin[1] + normal[1];
+ point[2] = origin[2] + normal[2];
+
+ origin[3] = point[3] = 1.0;
+
+ actorMatrix->MultiplyPoint( origin, origin );
+ actorMatrix->MultiplyPoint( point, point );
+
+ if ( origin[3] != 1.0 )
+ {
+ origin[0] /= origin[3];
+ origin[1] /= origin[3];
+ origin[2] /= origin[3];
+ }
+
+ if ( point[3] != 1.0 )
+ {
+ point[0] /= point[3];
+ point[1] /= point[3];
+ point[2] /= point[3];
+ }
+
+ normal[0] = point[0] - origin[0];
+ normal[1] = point[1] - origin[1];
+ normal[2] = point[2] - origin[2];
+
+ planeEquation[0] = normal[0];
+ planeEquation[1] = normal[1];
+ planeEquation[2] = normal[2];
+ planeEquation[3] = -(planeEquation[0]*origin[0]+
+ planeEquation[1]*origin[1]+
+ planeEquation[2]*origin[2]);
+ glClipPlane((GLenum)(GL_CLIP_PLANE0+i),planeEquation);
+ }
+
+ actorMatrix->Delete();
+ }
+
+ // For vertex coloring, this sets this->Colors as side effect.
+ // For texture map coloring, this sets ColorCoordinates
+ // and ColorTextureMap as a side effect.
+ // I moved this out of the conditional because it is fast.
+ // Color arrays are cached. If nothing has changed,
+ // then the scalars do not have to be regenerted.
+ this->MapScalars(act->GetProperty()->GetOpacity());
+ // If we are coloring by texture, then load the texture map.
+ if (this->ColorTextureMap)
+ {
+ if (this->InternalColorTexture == 0)
+ {
+ this->InternalColorTexture = vtkOpenGLTexture::New();
+ this->InternalColorTexture->RepeatOff();
+ }
+ this->InternalColorTexture->SetInput(this->ColorTextureMap);
+ // Keep color from interacting with texture.
+ float info[4];
+ info[0] = info[1] = info[2] = info[3] = 1.0;
+ glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, info );
+ }
+
+ //
+ // if something has changed regenerate colors and display lists
+ // if required
+ //
+ int noAbort=1;
+ if ( this->GetMTime() > this->BuildTime ||
+ input->GetMTime() > this->BuildTime ||
+ act->GetProperty()->GetMTime() > this->BuildTime ||
+ ren->GetRenderWindow() != this->LastWindow)
+ {
+ if (!this->ImmediateModeRendering &&
+ !this->GetGlobalImmediateModeRendering())
+ {
+ this->ReleaseGraphicsResources(ren->GetRenderWindow());
+ this->LastWindow = ren->GetRenderWindow();
+
+ // If we are coloring by texture, then load the texture map.
+ // Use Map as indicator, because texture hangs around.
+ if (this->ColorTextureMap)
+ {
+ this->InternalColorTexture->Load(ren);
+ }
+
+ // get a unique display list id
+ this->ListId = glGenLists(1);
+ glNewList(this->ListId,GL_COMPILE);
+
+ noAbort = this->Draw(ren,act);
+ glEndList();
+
+ // Time the actual drawing
+ this->Timer->StartTimer();
+ glCallList(this->ListId);
+ this->Timer->StopTimer();
+ }
+ else
+ {
+ this->ReleaseGraphicsResources(ren->GetRenderWindow());
+ this->LastWindow = ren->GetRenderWindow();
+ }
+ if (noAbort)
+ {
+ this->BuildTime.Modified();
+ }
+ }
+ // if nothing changed but we are using display lists, draw it
+ else
+ {
+ if (!this->ImmediateModeRendering &&
+ !this->GetGlobalImmediateModeRendering())
+ {
+ // If we are coloring by texture, then load the texture map.
+ // Use Map as indicator, because texture hangs around.
+ if (this->ColorTextureMap)
+ {
+ this->InternalColorTexture->Load(ren);
+ }
+
+ // Time the actual drawing
+ this->Timer->StartTimer();
+ glCallList(this->ListId);
+ this->Timer->StopTimer();
+ }
+ }
+
+ // if we are in immediate mode rendering we always
+ // want to draw the primitives here
+ if (this->ImmediateModeRendering ||
+ this->GetGlobalImmediateModeRendering())
+ {
+ // If we are coloring by texture, then load the texture map.
+ // Use Map as indicator, because texture hangs around.
+ if (this->ColorTextureMap)
+ {
+ this->InternalColorTexture->Load(ren);
+ }
+ // Time the actual drawing
+ this->Timer->StartTimer();
+ this->Draw(ren,act);
+ this->Timer->StopTimer();
+ }
+
+ this->TimeToDraw = (float)this->Timer->GetElapsedTime();
+
+ // If the timer is not accurate enough, set it to a small
+ // time so that it is not zero
+ if ( this->TimeToDraw == 0.0 )
+ {
+ this->TimeToDraw = 0.0001;
+ }
+
+ for (i = 0; i < numClipPlanes; i++)
+ {
+ glDisable((GLenum)(GL_CLIP_PLANE0+i));
+ }
+}
+
+
+//
+// Helper routine which starts a poly, triangle or quad based upon
+// the number of points in the polygon and whether triangles or quads
+// were the last thing being drawn (we can get better performance if we
+// can draw several triangles within a single glBegin(GL_TRIANGLES) or
+// several quads within a single glBegin(GL_QUADS).
+//
+static void vtkOpenGLBeginPolyTriangleOrQuad(GLenum aGlFunction,
+ GLenum &previousGlFunction,
+ int npts)
+{
+ if (aGlFunction == GL_POLYGON)
+ {
+ switch (npts)
+ {
+ case 3: // Need to draw a triangle.
+ if (previousGlFunction != GL_TRIANGLES)
+ {
+ // we were not already drawing triangles, were we drawing quads?
+ if (previousGlFunction == GL_QUADS)
+ {
+ // we were previously drawing quads, close down the quads.
+ glEnd();
+ }
+ // start drawing triangles
+ previousGlFunction = GL_TRIANGLES;
+ glBegin(GL_TRIANGLES);
+ }
+ break;
+ case 4: // Need to draw a quad
+ if (previousGlFunction != GL_QUADS)
+ {
+ // we were not already drawing quads, were we drawing triangles?
+ if (previousGlFunction == GL_TRIANGLES)
+ {
+ // we were previously drawing triangles, close down the triangles.
+ glEnd();
+ }
+ // start drawing quads
+ previousGlFunction = GL_QUADS;
+ glBegin(GL_QUADS);
+ }
+ break;
+ default:
+ // if we were supposed to be drawing polygons but were really
+ // drawing triangles or quads, then we need to close down the
+ // triangles or quads and begin a polygon
+ if (previousGlFunction != GL_INVALID_VALUE
+ && previousGlFunction != GL_POLYGON)
+ {
+ glEnd();
+ }
+ previousGlFunction = GL_POLYGON;
+ glBegin(aGlFunction);
+ break;
+ }
+ }
+ else if (aGlFunction == GL_POINTS)
+ {
+ // we are supposed to be drawing points
+ if (previousGlFunction != GL_POINTS)
+ {
+ // We were not drawing points before this, switch to points.
+ // We don't need to worry about switching from triangles or quads
+ // since draw all points before drawing any polygons (i.e. in the polys
+ // case we switch to triangles and quads as an optimization, there is
+ // nothing to switch to that is below points).
+ previousGlFunction = GL_POINTS;
+ glBegin(GL_POINTS);
+ }
+ }
+ else
+ {
+ previousGlFunction = aGlFunction;
+ glBegin(aGlFunction);
+ }
+}
+
+
+#define vtkDrawPointsMacro(ptype,ntype,glVertFuncs,glInitFuncs) \
+{ \
+ vtkIdType nPts; unsigned short count = 0; \
+ ptype *points = (ptype *)voidPoints; \
+ glInitFuncs \
+ glBegin(GL_POINTS); \
+ while (ptIds < endPtIds) \
+ { \
+ nPts = *ptIds; \
+ ++ptIds; \
+ while (nPts > 0) \
+ { \
+ glVertFuncs \
+ ++ptIds; \
+ --nPts; \
+ } \
+ if (++count == 10000) \
+ { \
+ cellNum += 10000; \
+ count = 0; \
+ this->UpdateProgress((double)cellNum/this->TotalCells); \
+ if (ren->GetRenderWindow()->CheckAbortStatus()) \
+ { \
+ noAbort = 0; \
+ break; \
+ } \
+ } \
+ } \
+ cellNum += count; \
+ glEnd(); \
+}
+
+#define vtkDrawPrimsMacro(ptype,ntype,prim,glVertFuncs,glInitFuncs) \
+{ \
+ vtkIdType nPts; unsigned short count = 0; \
+ ptype *points = (ptype *)voidPoints; \
+ glInitFuncs \
+ while (ptIds < endPtIds) \
+ { \
+ nPts = *ptIds; \
+ ++ptIds; \
+ glBegin(prim); \
+ while (nPts > 0) \
+ { \
+ glVertFuncs \
+ ++ptIds; \
+ --nPts; \
+ } \
+ glEnd(); \
+ if (++count == 10000) \
+ { \
+ cellNum += 10000; \
+ count = 0; \
+ this->UpdateProgress((double)cellNum/this->TotalCells); \
+ if (ren->GetRenderWindow()->CheckAbortStatus()) \
+ { \
+ noAbort = 0; \
+ break; \
+ } \
+ } \
+ } \
+ cellNum += count; \
+}
+
+#define vtkDrawPolysMacro(ptype,ntype,ttype,prim,glVertFuncs,glCellFuncs,glInitFuncs) \
+{ \
+ vtkIdType nPts; unsigned short count = 0; \
+ ptype *points = (ptype *)voidPoints; \
+ GLenum previousGlFunction=GL_INVALID_VALUE; \
+ glInitFuncs \
+ while (ptIds < endPtIds) \
+ { \
+ nPts = *ptIds; \
+ ++ptIds; \
+ vtkOpenGLBeginPolyTriangleOrQuad( prim, previousGlFunction, nPts ); \
+ glCellFuncs \
+ while (nPts > 0) \
+ { \
+ glVertFuncs \
+ ++ptIds; \
+ --nPts; \
+ } \
+ if (++count == 10000) \
+ { \
+ cellNum += 10000; \
+ count = 0; \
+ this->UpdateProgress((double)cellNum/this->TotalCells); \
+ if (ren->GetRenderWindow()->CheckAbortStatus()) \
+ { \
+ noAbort = 0; \
+ break; \
+ } \
+ } \
+ if ((previousGlFunction != GL_TRIANGLES) \
+ && (previousGlFunction != GL_QUADS) \
+ && (previousGlFunction != GL_POINTS)) \
+ { \
+ glEnd(); \
+ } \
+ } \
+ cellNum += count; \
+ if ((previousGlFunction == GL_TRIANGLES) \
+ || (previousGlFunction == GL_QUADS) \
+ || (previousGlFunction == GL_POINTS)) \
+ { \
+ glEnd(); \
+ } \
+}
+
+#define vtkDrawStripLinesMacro(ptype,ntype,ttype,prim,glVertFuncs,glCellFuncs,glInitFuncs) \
+{ \
+ vtkIdType nPts; \
+ ptype *points = (ptype *)voidPoints; \
+ vtkIdType *savedPtIds = ptIds; \
+ glInitFuncs \
+ while (ptIds < endPtIds) \
+ { \
+ glBegin(prim); \
+ nPts = *ptIds; \
+ ++ptIds; \
+ glCellFuncs \
+ while (nPts > 0) \
+ { \
+ glVertFuncs \
+ ptIds += 2; \
+ nPts -= 2; \
+ } \
+ glEnd(); \
+ ptIds += nPts; /* nPts could be 0 or -1 here */ \
+ } \
+ ptIds = savedPtIds; \
+ while (ptIds < endPtIds) \
+ { \
+ glBegin(prim); \
+ nPts = *ptIds; \
+ ++ptIds; \
+ glCellFuncs \
+ ++ptIds; \
+ --nPts; \
+ while (nPts > 0) \
+ { \
+ glVertFuncs \
+ ptIds += 2; \
+ nPts -= 2; \
+ } \
+ glEnd(); \
+ ptIds += nPts; /* nPts could be 0 or -1 here */ \
+ } \
+}
+
+void VISU_OpenGLElnoMapper::DrawPoints(int idx,
+ vtkPoints *p,
+ vtkDataArray *n,
+ vtkUnsignedCharArray *c,
+ vtkDataArray *t,
+ vtkIdType &cellNum,
+ int &noAbort,
+ vtkCellArray *ca,
+ vtkRenderer *ren)
+{
+ void *voidPoints = p->GetVoidPointer(0);
+ void *voidNormals = 0;
+ unsigned char *colors = 0;
+ if (ca->GetNumberOfCells() == 0)
+ {
+ return;
+ }
+ if (n)
+ {
+ voidNormals = n->GetVoidPointer(0);
+ }
+ if (c)
+ {
+ colors = c->GetPointer(0);
+ }
+
+ vtkIdType *ptIds = ca->GetPointer();
+ vtkIdType *endPtIds = ptIds + ca->GetNumberOfConnectivityEntries();
+
+
+ // draw all the elements, use fast path if available
+ switch (idx)
+ {
+ case VTK_PDM_POINT_TYPE_FLOAT:
+ vtkDrawPointsMacro(float, float, glVertex3fv(points + 3**ptIds);,;);
+ break;
+ case VTK_PDM_POINT_TYPE_DOUBLE:
+ vtkDrawPointsMacro(double, float, glVertex3dv(points + 3**ptIds);,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT|VTK_PDM_NORMAL_TYPE_FLOAT|VTK_PDM_NORMALS:
+ vtkDrawPointsMacro(float, float,
+ glNormal3fv(normals + 3**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ float *normals = (float *)voidNormals;);
+
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_COLORS:
+ vtkDrawPointsMacro(float, float,
+ glColor4ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,;);
+
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawPointsMacro(float, float,
+ glColor3ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS:
+ vtkDrawPointsMacro(float, float,
+ glNormal3fv(normals + 3**ptIds);
+ glColor4ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawPointsMacro(float, float,
+ glNormal3fv(normals + 3**ptIds);
+ glColor3ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ float *normals = (float *)voidNormals;);
+ break;
+ default:
+ {
+ int j;
+ vtkIdType *pts = 0;
+ vtkIdType npts = 0;
+ unsigned short count = 0;
+ glBegin(GL_POINTS);
+ for (ca->InitTraversal(); noAbort && ca->GetNextCell(npts,pts);
+ count++)
+ {
+ for (j = 0; j < npts; j++)
+ {
+ if (c)
+ {
+ if (idx & 0x08)
+ {
+ glColor4ubv(c->GetPointer(cellNum << 2));
+ }
+ else
+ {
+ glColor4ubv(c->GetPointer(pts[j]<< 2));
+ }
+ }
+ if (t)
+ {
+ if (idx & VTK_PDM_TCOORD_1D)
+ {
+ glTexCoord1dv(t->GetTuple(pts[j]));
+ }
+ else
+ {
+ glTexCoord2dv(t->GetTuple(pts[j]));
+ }
+ }
+ if (n)
+ {
+ if (idx & 0x10)
+ {
+ glNormal3dv(n->GetTuple(cellNum));
+ }
+ else
+ {
+ glNormal3dv(n->GetTuple(pts[j]));
+ }
+ }
+ glVertex3dv(p->GetPoint(pts[j]));
+ }
+
+ // check for abort condition
+ if (count == 10000)
+ {
+ count = 0;
+ // report progress
+ this->UpdateProgress((double)cellNum/this->TotalCells);
+ if (ren->GetRenderWindow()->CheckAbortStatus())
+ {
+ noAbort = 0;
+ }
+ }
+ ++cellNum;
+ }
+ glEnd();
+ }
+ }
+}
+
+
+void VISU_OpenGLElnoMapper::DrawLines(int idx,
+ vtkPoints *p,
+ vtkDataArray *n,
+ vtkUnsignedCharArray *c,
+ vtkDataArray *t,
+ vtkIdType &cellNum,
+ int &noAbort,
+ vtkCellArray *ca,
+ vtkRenderer *ren)
+{
+ void *voidPoints = p->GetVoidPointer(0);
+ void *voidNormals = 0;
+ void *voidTCoords = 0;
+ unsigned char *colors = 0;
+ if (ca->GetNumberOfCells() == 0)
+ {
+ return;
+ }
+ if (n)
+ {
+ voidNormals = n->GetVoidPointer(0);
+ }
+ if (t)
+ {
+ voidTCoords = t->GetVoidPointer(0);
+ }
+ if (c)
+ {
+ colors = c->GetPointer(0);
+ }
+ vtkIdType *ptIds = ca->GetPointer();
+ vtkIdType *endPtIds = ptIds + ca->GetNumberOfConnectivityEntries();
+
+ // draw all the elements, use fast path if available
+ switch (idx)
+ {
+ case VTK_PDM_POINT_TYPE_FLOAT:
+ vtkDrawPrimsMacro(float, float, GL_LINE_STRIP,
+ glVertex3fv(points + 3**ptIds);,;);
+ break;
+ case VTK_PDM_POINT_TYPE_DOUBLE:
+ vtkDrawPrimsMacro(double, float, GL_LINE_STRIP,
+ glVertex3dv(points + 3**ptIds);,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT|VTK_PDM_NORMAL_TYPE_FLOAT|VTK_PDM_NORMALS:
+ vtkDrawPrimsMacro(float, float, GL_LINE_STRIP,
+ glNormal3fv(normals + 3**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ float *normals = (float *)voidNormals;);
+
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_COLORS:
+ vtkDrawPrimsMacro(float, float, GL_LINE_STRIP,
+ glColor4ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawPrimsMacro(float, float, GL_LINE_STRIP,
+ glColor3ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS:
+ vtkDrawPrimsMacro(float, float, GL_LINE_STRIP,
+ glNormal3fv(normals + 3**ptIds);
+ glColor4ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ float *normals = (float *)voidNormals;
+ );
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawPrimsMacro(float, float, GL_LINE_STRIP,
+ glNormal3fv(normals + 3**ptIds);
+ glColor3ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ float *normals = (float *)voidNormals;
+ );
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT |
+ VTK_PDM_TCOORD_TYPE_FLOAT | VTK_PDM_TCOORD_1D | VTK_PDM_TCOORDS:
+ vtkDrawPrimsMacro(float, float, GL_LINE_STRIP,
+ glTexCoord1fv(tcoords + *ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ float *tcoords = (float *)voidTCoords;
+ );
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT |
+ VTK_PDM_NORMAL_TYPE_FLOAT | VTK_PDM_NORMALS |
+ VTK_PDM_TCOORD_TYPE_FLOAT | VTK_PDM_TCOORD_1D | VTK_PDM_TCOORDS:
+ vtkDrawPrimsMacro(float, float, GL_LINE_STRIP,
+ glNormal3fv(normals + 3**ptIds);
+ glTexCoord1fv(tcoords + *ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ float *tcoords = (float *)voidTCoords;
+ float *normals = (float *)voidNormals;
+ );
+ break;
+ default:
+ {
+ int j;
+ vtkIdType *pts = 0;
+ vtkIdType npts = 0;
+ unsigned short count = 0;
+ for (ca->InitTraversal(); noAbort && ca->GetNextCell(npts,pts);
+ count++)
+ {
+ glBegin(GL_LINE_STRIP);
+ for (j = 0; j < npts; j++)
+ {
+ if (c)
+ {
+ if (idx & 0x08)
+ {
+ glColor4ubv(c->GetPointer(cellNum << 2));
+ }
+ else
+ {
+ glColor4ubv(c->GetPointer(pts[j] << 2));
+ }
+ }
+ if (t)
+ {
+ if (idx & VTK_PDM_TCOORD_1D)
+ {
+ glTexCoord1dv(t->GetTuple(pts[j]));
+ }
+ else
+ {
+ glTexCoord2dv(t->GetTuple(pts[j]));
+ }
+ }
+ if (n)
+ {
+ if (idx & 0x10)
+ {
+ glNormal3dv(n->GetTuple(cellNum));
+ }
+ else
+ {
+ glNormal3dv(n->GetTuple(pts[j]));
+ }
+ }
+ glVertex3dv(p->GetPoint(pts[j]));
+ }
+ glEnd();
+
+ // check for abort condition
+ if (count == 10000)
+ {
+ count = 0;
+ // report progress
+ this->UpdateProgress((double)cellNum/this->TotalCells);
+ if (ren->GetRenderWindow()->CheckAbortStatus())
+ {
+ noAbort = 0;
+ }
+ }
+ ++cellNum;
+ }
+ }
+ }
+}
+
+
+
+
+
+
+
+
+
+#define PolyNormal \
+{ double polyNorm[3]; vtkPolygon::ComputeNormal(p,nPts,ptIds,polyNorm); glNormal3dv(polyNorm); }
+
+void VISU_OpenGLElnoMapper::DrawPolygons(int idx,
+ vtkPoints *p,
+ vtkDataArray *n,
+ vtkUnsignedCharArray *c,
+ vtkDataArray *t,
+ vtkIdType &cellNum,
+ int &noAbort,
+ GLenum rep,
+ vtkCellArray *ca,
+ vtkRenderer *ren)
+{
+ void *voidPoints = p->GetVoidPointer(0);
+ void *voidNormals = 0;
+ void *voidTCoords = 0;
+ unsigned char *colors = 0;
+ if (ca->GetNumberOfCells() == 0)
+ {
+ return;
+ }
+ if (n)
+ {
+ voidNormals = n->GetVoidPointer(0);
+ }
+ if (c)
+ {
+ colors = c->GetPointer(0);
+ // if these are cell colors then advance to the first cell
+ if (idx & VTK_PDM_CELL_COLORS)
+ {
+ colors = colors + cellNum*4;
+ }
+ }
+ if (t)
+ {
+ voidTCoords = t->GetVoidPointer(0);
+ } vtkIdType *ptIds = ca->GetPointer();
+ vtkIdType *endPtIds = ptIds + ca->GetNumberOfConnectivityEntries();
+
+ // draw all the elements, use fast path if available
+ switch (idx)
+ {
+ case VTK_PDM_POINT_TYPE_FLOAT:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glVertex3fv(points + 3**ptIds);,
+ PolyNormal,;);
+ break;
+ case VTK_PDM_POINT_TYPE_DOUBLE:
+ vtkDrawPolysMacro(double, float, float, rep,
+ glVertex3dv(points + 3**ptIds);,
+ PolyNormal,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT|VTK_PDM_NORMAL_TYPE_FLOAT|VTK_PDM_NORMALS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glColor4ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ PolyNormal,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glColor3ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ PolyNormal,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glColor4ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glColor3ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT | VTK_PDM_NORMALS |
+ VTK_PDM_TCOORD_TYPE_FLOAT | VTK_PDM_TCOORD_1D | VTK_PDM_TCOORDS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glTexCoord1fv(tcoords + *ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;
+ float *tcoords = (float *)voidTCoords;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT | VTK_PDM_CELL_NORMALS |
+ VTK_PDM_TCOORD_TYPE_FLOAT | VTK_PDM_TCOORD_1D | VTK_PDM_TCOORDS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glTexCoord1fv(tcoords + *ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ glNormal3fv(normals); normals += 3;,
+ float *tcoords = (float *)voidTCoords;
+ float *normals = (float *)voidNormals;
+ normals += cellNum*3;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT |
+ VTK_PDM_TCOORD_TYPE_FLOAT | VTK_PDM_TCOORD_1D | VTK_PDM_TCOORDS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glTexCoord1fv(tcoords + *ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ PolyNormal;,
+ float *tcoords = (float *)voidTCoords;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_TCOORD_TYPE_FLOAT | VTK_PDM_TCOORDS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glTexCoord2fv(tcoords + 2**ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;
+ float *tcoords = (float *)voidTCoords;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT|VTK_PDM_NORMAL_TYPE_FLOAT|
+ VTK_PDM_CELL_NORMALS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glVertex3fv(points + 3**ptIds);,
+ glNormal3fv(normals); normals += 3;,
+ float *normals = (float *)voidNormals;
+ normals += cellNum*3;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_CELL_NORMALS | VTK_PDM_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glColor4ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ glNormal3fv(normals); normals += 3;,
+ float *normals = (float *)voidNormals;
+ normals += cellNum*3;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_CELL_NORMALS | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glColor3ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ glNormal3fv(normals); normals += 3;,
+ float *normals = (float *)voidNormals;
+ normals += cellNum*3;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS | VTK_PDM_CELL_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ glColor4ubv(colors); colors += 4;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS |
+ VTK_PDM_CELL_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ glColor3ubv(colors); colors += 4;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_CELL_NORMALS | VTK_PDM_COLORS | VTK_PDM_CELL_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glVertex3fv(points + 3**ptIds);,
+ glNormal3fv(normals); normals += 3;
+ glColor4ubv(colors); colors += 4;,
+ float *normals = (float *)voidNormals;
+ normals += cellNum*3;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_CELL_NORMALS | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS |
+ VTK_PDM_CELL_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glVertex3fv(points + 3**ptIds);,
+ glNormal3fv(normals); normals += 3;
+ glColor3ubv(colors); colors += 4;,
+ float *normals = (float *)voidNormals;
+ normals += cellNum*3;);
+ break;
+ default:
+ {
+ int j;
+ vtkIdType *pts = 0;
+ vtkIdType npts = 0;
+ vtkIdType np = 0;
+ unsigned short count = 0;
+ for (ca->InitTraversal(); noAbort && ca->GetNextCell(npts,pts);
+ count++)
+ {
+ glBegin(rep);
+ if (!n)
+ {
+ double polyNorm[3];
+ vtkPolygon::ComputeNormal(p,npts,pts,polyNorm);
+ glNormal3dv(polyNorm);
+ }
+ for (j = 0; j < npts; j++)
+ {
+ if (c)
+ {
+ if (idx & VTK_PDM_CELL_COLORS)
+ {
+ glColor4ubv(c->GetPointer(np << 2));
+ np++;
+ }
+ else
+ {
+ glColor4ubv(c->GetPointer(pts[j] << 2));
+ }
+ }
+ if (t)
+ {
+ if (idx & VTK_PDM_TCOORD_1D)
+ {
+ glTexCoord1dv(t->GetTuple(pts[j]));
+ }
+ else
+ {
+ glTexCoord2dv(t->GetTuple(pts[j]));
+ }
+ }
+ if (n)
+ {
+ if (idx & VTK_PDM_CELL_NORMALS)
+ {
+ glNormal3dv(n->GetTuple(cellNum));
+ }
+ else
+ {
+ glNormal3dv(n->GetTuple(pts[j]));
+ }
+ }
+ glVertex3dv(p->GetPoint(pts[j]));
+ }
+ glEnd();
+
+ // check for abort condition
+ if (count == 10000)
+ {
+ count = 0;
+ // report progress
+ this->UpdateProgress((double)cellNum/this->TotalCells);
+ if (ren->GetRenderWindow()->CheckAbortStatus())
+ {
+ noAbort = 0;
+ }
+ }
+ ++cellNum;
+ }
+ }
+ }
+}
+
+// fix refs here
+#define TStripNormal \
+if ( vcount > 2) \
+{ \
+ if (vcount % 2) \
+ { \
+ normIdx[0] = ptIds[-2]; normIdx[1] = ptIds[0]; normIdx[2] = ptIds[-1]; \
+ vtkTriangle::ComputeNormal(p, 3, normIdx, polyNorm); \
+ } \
+ else \
+ { \
+ normIdx[0] = ptIds[-2]; normIdx[1] = ptIds[-1]; normIdx[2] = ptIds[0]; \
+ vtkTriangle::ComputeNormal(p, 3, normIdx, polyNorm); \
+ } \
+ glNormal3dv(polyNorm); \
+} \
+vcount++;
+
+#define TStripNormalStart \
+ vtkTriangle::ComputeNormal(p, 3, ptIds, polyNorm); \
+ glNormal3dv(polyNorm); int vcount = 0;
+
+void VISU_OpenGLElnoMapper::DrawTStrips(int idx,
+ vtkPoints *p,
+ vtkDataArray *n,
+ vtkUnsignedCharArray *c,
+ vtkDataArray *t,
+ vtkIdType &cellNum,
+ int &noAbort,
+ GLenum rep,
+ vtkCellArray *ca,
+ vtkRenderer *ren)
+{
+ void *voidPoints = p->GetVoidPointer(0);
+ void *voidNormals = 0;
+ void *voidTCoords = 0;
+ unsigned char *colors = 0;
+ double polyNorm[3];
+ vtkIdType normIdx[3];
+
+ if (ca->GetNumberOfCells() == 0)
+ {
+ return;
+ }
+ if (n)
+ {
+ voidNormals = n->GetVoidPointer(0);
+ }
+ if (c)
+ {
+ colors = c->GetPointer(0);
+ }
+ if (t)
+ {
+ voidTCoords = t->GetVoidPointer(0);
+ }
+ vtkIdType *ptIds = ca->GetPointer();
+ vtkIdType *endPtIds = ptIds + ca->GetNumberOfConnectivityEntries();
+
+ // draw all the elements, use fast path if available
+ switch (idx)
+ {
+ case VTK_PDM_POINT_TYPE_FLOAT:
+ vtkDrawPolysMacro(float, float, float, rep,
+ TStripNormal glVertex3fv(points + 3**ptIds);,
+ TStripNormalStart,;);
+ break;
+ case VTK_PDM_POINT_TYPE_DOUBLE:
+ vtkDrawPolysMacro(double, float, float, rep,
+ TStripNormal glVertex3dv(points + 3**ptIds);,
+ TStripNormalStart,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT|VTK_PDM_NORMAL_TYPE_FLOAT|VTK_PDM_NORMALS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ TStripNormal
+ glColor4ubv(colors + (*ptIds << 2));
+ glVertex3fv(points + 3**ptIds);,
+ TStripNormalStart,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ TStripNormal
+ glColor3ubv(colors + (*ptIds << 2));
+ glVertex3fv(points + 3**ptIds);,
+ TStripNormalStart,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glColor4ubv(colors + (*ptIds << 2));
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glColor3ubv(colors + (*ptIds << 2));
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT | VTK_PDM_NORMALS |
+ VTK_PDM_TCOORD_1D | VTK_PDM_TCOORD_TYPE_FLOAT | VTK_PDM_TCOORDS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glTexCoord1fv(tcoords + *ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;
+ float *tcoords = (float *)voidTCoords;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_TCOORD_TYPE_FLOAT | VTK_PDM_TCOORDS:
+ vtkDrawPolysMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glTexCoord2fv(tcoords + 2**ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;
+ float *tcoords = (float *)voidTCoords;);
+ break;
+ default:
+ {
+ int j;
+ vtkIdType nPts = 0;
+ unsigned short count = 0;
+ unsigned long coloroffset = cellNum;
+ for (ca->InitTraversal(); noAbort && ca->GetNextCell(nPts,ptIds);
+ count++)
+ {
+ glBegin(rep);
+ vtkTriangle::ComputeNormal(p, 3, ptIds, polyNorm);
+ glNormal3dv(polyNorm);
+ for (j = 0; j < nPts; j++)
+ {
+ if (c)
+ {
+ if ( (idx & VTK_PDM_USE_FIELD_DATA) && j>=2 )
+ {
+ glColor4ubv(c->GetPointer(coloroffset << 2));
+ coloroffset++;
+ }
+ else if (idx & VTK_PDM_CELL_COLORS)
+ {
+ glColor4ubv(c->GetPointer(cellNum << 2));
+ }
+ else
+ {
+ glColor4ubv(c->GetPointer(ptIds[j] << 2));
+ }
+ }
+ if (t)
+ {
+ if (idx & VTK_PDM_TCOORD_1D)
+ {
+ glTexCoord1dv(t->GetTuple(ptIds[j]));
+ }
+ else
+ {
+ glTexCoord2dv(t->GetTuple(ptIds[j]));
+ }
+ }
+ if (n)
+ {
+ if (idx & VTK_PDM_CELL_NORMALS)
+ {
+ glNormal3dv(n->GetTuple(cellNum));
+ }
+ else
+ {
+ glNormal3dv(n->GetTuple(ptIds[j]));
+ }
+ }
+ else
+ {
+ if (j >= 2)
+ {
+ if (j % 2)
+ {
+ normIdx[0] = ptIds[j-2]; normIdx[1] = ptIds[j];
+ normIdx[2] = ptIds[j-1];
+ vtkTriangle::ComputeNormal(p, 3, normIdx, polyNorm);
+ }
+ else
+ {
+ normIdx[0] = ptIds[j-2]; normIdx[1] = ptIds[j-1];
+ normIdx[2] = ptIds[j];
+ vtkTriangle::ComputeNormal(p, 3, normIdx, polyNorm);
+ }
+ }
+ glNormal3dv(polyNorm);
+ }
+ glVertex3dv(p->GetPoint(ptIds[j]));
+ }
+ glEnd();
+
+ // check for abort condition
+ if (count == 10000)
+ {
+ count = 0;
+ // report progress
+ this->UpdateProgress((double)cellNum/this->TotalCells);
+ if (ren->GetRenderWindow()->CheckAbortStatus())
+ {
+ noAbort = 0;
+ }
+ }
+ ++cellNum;
+ }
+ }
+ }
+}
+
+void vtkOpenGLPolyDataMapperDrawTStripLines(int idx,
+ vtkPoints *p,
+ vtkDataArray *n,
+ vtkUnsignedCharArray *c,
+ vtkDataArray *t,
+ vtkIdType &cellNum,
+ int &noAbort,
+ GLenum rep,
+ vtkCellArray *ca,
+ vtkRenderer *ren)
+{
+ void *voidPoints = p->GetVoidPointer(0);
+ void *voidNormals = 0;
+ void *voidTCoords = 0;
+ unsigned char *colors = 0;
+ double polyNorm[3];
+ vtkIdType normIdx[3];
+
+ if (n)
+ {
+ voidNormals = n->GetVoidPointer(0);
+ }
+ if (c)
+ {
+ colors = c->GetPointer(0);
+ }
+ if (t)
+ {
+ voidTCoords = t->GetVoidPointer(0);
+ }
+ vtkIdType *ptIds = ca->GetPointer();
+ vtkIdType *endPtIds = ptIds + ca->GetNumberOfConnectivityEntries();
+
+ // draw all the elements, use fast path if available
+ switch (idx)
+ {
+ case VTK_PDM_POINT_TYPE_FLOAT:
+ vtkDrawStripLinesMacro(float, float, float, rep,
+ TStripNormal; glVertex3fv(points + 3**ptIds);,
+ TStripNormalStart,;);
+ break;
+ case VTK_PDM_POINT_TYPE_DOUBLE:
+ vtkDrawStripLinesMacro(double, float, float, rep,
+ TStripNormal glVertex3dv(points + 3**ptIds);,
+ TStripNormalStart,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT|VTK_PDM_NORMAL_TYPE_FLOAT|VTK_PDM_NORMALS:
+ vtkDrawStripLinesMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_COLORS:
+ vtkDrawStripLinesMacro(float, float, float, rep,
+ TStripNormal;
+ glColor4ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ TStripNormalStart,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawStripLinesMacro(float, float, float, rep,
+ TStripNormal;
+ glColor3ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,
+ TStripNormalStart,;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS:
+ vtkDrawStripLinesMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glColor4ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_COLORS | VTK_PDM_OPAQUE_COLORS:
+ vtkDrawStripLinesMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glColor3ubv(colors + 4**ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT | VTK_PDM_NORMALS |
+ VTK_PDM_TCOORD_TYPE_FLOAT | VTK_PDM_TCOORD_1D | VTK_PDM_TCOORDS:
+ vtkDrawStripLinesMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glTexCoord1fv(tcoords + *ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;
+ float *tcoords = (float *)voidTCoords;);
+ break;
+ case VTK_PDM_POINT_TYPE_FLOAT | VTK_PDM_NORMAL_TYPE_FLOAT |
+ VTK_PDM_NORMALS | VTK_PDM_TCOORD_TYPE_FLOAT | VTK_PDM_TCOORDS:
+ vtkDrawStripLinesMacro(float, float, float, rep,
+ glNormal3fv(normals + 3**ptIds);
+ glTexCoord2fv(tcoords + 2**ptIds);
+ glVertex3fv(points + 3**ptIds);,;,
+ float *normals = (float *)voidNormals;
+ float *tcoords = (float *)voidTCoords;);
+ break;
+ default:
+ {
+ int j;
+ vtkIdType nPts = 0;
+ int count = 0;
+ unsigned long coloroffset = cellNum;
+ for (ca->InitTraversal(); noAbort && ca->GetNextCell(nPts,ptIds);
+ count++)
+ {
+ glBegin(rep);
+ for (j = 0; j < nPts; j += 2)
+ {
+ if (c)
+ {
+ if ( (idx & VTK_PDM_USE_FIELD_DATA) && j >= 2)
+ {
+ glColor4ubv(c->GetPointer((coloroffset+j) << 2));
+ }
+ else if (idx & VTK_PDM_CELL_COLORS)
+ {
+ glColor4ubv(c->GetPointer(cellNum << 2));
+ }
+ else
+ {
+ glColor4ubv(c->GetPointer(ptIds[j] << 2));
+ }
+ }
+ if (t)
+ {
+ if (idx & VTK_PDM_TCOORD_1D)
+ {
+ glTexCoord1dv(t->GetTuple(ptIds[j]));
+ }
+ else
+ {
+ glTexCoord2dv(t->GetTuple(ptIds[j]));
+ }
+ }
+ if (n)
+ {
+ if (idx & VTK_PDM_CELL_NORMALS)
+ {
+ glNormal3dv(n->GetTuple(cellNum));
+ }
+ else
+ {
+ glNormal3dv(n->GetTuple(ptIds[j]));
+ }
+ }
+ else
+ {
+ if ( j == 0 )
+ {
+ vtkTriangle::ComputeNormal(p, 3, ptIds, polyNorm);
+ }
+ else
+ {
+ normIdx[0] = ptIds[j-2]; normIdx[1] = ptIds[j-1];
+ normIdx[2] = ptIds[j];
+ vtkTriangle::ComputeNormal(p, 3, normIdx, polyNorm);
+ }
+ glNormal3dv(polyNorm);
+ }
+ glVertex3dv(p->GetPoint(ptIds[j]));
+ }
+ glEnd();
+
+ glBegin(rep);
+ for (j = 1; j < nPts; j += 2)
+ {
+ if (c)
+ {
+ if ( (idx & VTK_PDM_USE_FIELD_DATA) && j >= 2)
+ {
+ glColor4ubv(c->GetPointer((coloroffset+j) << 2));
+ }
+ else if (idx & VTK_PDM_CELL_COLORS)
+ {
+ glColor4ubv(c->GetPointer(cellNum << 2));
+ }
+ else
+ {
+ glColor4ubv(c->GetPointer(ptIds[j] << 2));
+ }
+ }
+ if (t)
+ {
+ if (idx & VTK_PDM_TCOORD_1D)
+ {
+ glTexCoord1dv(t->GetTuple(ptIds[j]));
+ }
+ else
+ {
+ glTexCoord2dv(t->GetTuple(ptIds[j]));
+ }
+ }
+ if (n)
+ {
+ if (idx & VTK_PDM_CELL_NORMALS)
+ {
+ glNormal3dv(n->GetTuple(cellNum));
+ }
+ else
+ {
+ glNormal3dv(n->GetTuple(ptIds[j]));
+ }
+ }
+ else
+ {
+ if (j == 1)
+ {
+ vtkTriangle::ComputeNormal(p, 3, ptIds, polyNorm);
+ }
+ else
+ {
+ normIdx[0] = ptIds[j-2]; normIdx[1] = ptIds[j];
+ normIdx[2] = ptIds[j-1];
+ vtkTriangle::ComputeNormal(p, 3, normIdx, polyNorm);
+ }
+ glNormal3dv(polyNorm);
+ }
+ glVertex3dv(p->GetPoint(ptIds[j]));
+ }
+ glEnd();
+
+ // check for abort condition
+ if (count == 100)
+ {
+ count = 0;
+ if (ren->GetRenderWindow()->CheckAbortStatus())
+ {
+ noAbort = 0;
+ }
+ }
+ ++cellNum;
+ coloroffset += (nPts >= 2)? (nPts - 2) : 0;
+ }
+ }
+ }
+}
+
+// Draw method for OpenGL.
+int VISU_OpenGLElnoMapper::Draw(vtkRenderer *aren, vtkActor *act)
+{
+ vtkOpenGLRenderer *ren = (vtkOpenGLRenderer *)aren;
+ int rep, interpolation;
+ float tran;
+ vtkProperty *prop;
+ vtkPoints *p;
+ vtkUnsignedCharArray *c=NULL;
+ vtkDataArray *n;
+ vtkDataArray *t;
+ int tDim;
+ int noAbort = 1;
+ vtkPolyData *input = this->GetInput();
+ int cellScalars = 0;
+ vtkIdType cellNum = 0;
+ int cellNormals;
+ int resolve=0, zResolve=0;
+ double zRes = 0.0;
+
+ // get the property
+ prop = act->GetProperty();
+
+ // get the transparency
+ tran = prop->GetOpacity();
+
+ // if the primitives are invisable then get out of here
+ if (tran <= 0.0)
+ {
+ return noAbort;
+ }
+
+ // get the representation (e.g., surface / wireframe / points)
+ rep = prop->GetRepresentation();
+
+ // get the shading interpolation
+ interpolation = prop->GetInterpolation();
+
+ // and draw the display list
+ p = input->GetPoints();
+
+ // are they cell or point scalars
+ if ( this->Colors )
+ {
+ c = this->Colors;
+ if ( (this->ScalarMode == VTK_SCALAR_MODE_USE_CELL_DATA ||
+ this->ScalarMode == VTK_SCALAR_MODE_USE_CELL_FIELD_DATA ||
+ this->ScalarMode == VTK_SCALAR_MODE_USE_FIELD_DATA ||
+ !input->GetPointData()->GetScalars() )
+ && this->ScalarMode != VTK_SCALAR_MODE_USE_POINT_FIELD_DATA)
+ {
+ cellScalars = 1;
+ }
+ }
+
+ n = input->GetPointData()->GetNormals();
+ if (interpolation == VTK_FLAT)
+ {
+ n = 0;
+ }
+
+ cellNormals = 0;
+ if (n == 0 && input->GetCellData()->GetNormals())
+ {
+ cellNormals = 1;
+ n = input->GetCellData()->GetNormals();
+ }
+
+ // if we are doing vertex colors then set lmcolor to adjust
+ // the current materials ambient and diffuse values using
+ // vertex color commands otherwise tell it not to.
+ glDisable( GL_COLOR_MATERIAL );
+ if (c)
+ {
+ GLenum lmcolorMode;
+ if (this->ScalarMaterialMode == VTK_MATERIALMODE_DEFAULT)
+ {
+ if (prop->GetAmbient() > prop->GetDiffuse())
+ {
+ lmcolorMode = GL_AMBIENT;
+ }
+ else
+ {
+ lmcolorMode = GL_DIFFUSE;
+ }
+ }
+ else if (this->ScalarMaterialMode == VTK_MATERIALMODE_AMBIENT_AND_DIFFUSE)
+ {
+ lmcolorMode = GL_AMBIENT_AND_DIFFUSE;
+ }
+ else if (this->ScalarMaterialMode == VTK_MATERIALMODE_AMBIENT)
+ {
+ lmcolorMode = GL_AMBIENT;
+ }
+ else // if (this->ScalarMaterialMode == VTK_MATERIALMODE_DIFFUSE)
+ {
+ lmcolorMode = GL_DIFFUSE;
+ }
+ glColorMaterial( GL_FRONT_AND_BACK, lmcolorMode);
+ glEnable( GL_COLOR_MATERIAL );
+ }
+
+ unsigned long idx = 0;
+ if (n && !cellNormals)
+ {
+ idx |= VTK_PDM_NORMALS;
+ }
+ if (c)
+ {
+ idx |= VTK_PDM_COLORS;
+ if (c->GetName())
+ { // In the future, I will look at the number of components.
+ // All paths will have to handle 3 componet colors.
+ idx |= VTK_PDM_OPAQUE_COLORS;
+ }
+ }
+ if (cellScalars)
+ {
+ idx |= VTK_PDM_CELL_COLORS;
+ }
+ if (cellNormals)
+ {
+ idx |= VTK_PDM_CELL_NORMALS;
+ }
+ if (this->ScalarMode == VTK_SCALAR_MODE_USE_FIELD_DATA)
+ {
+ idx |= VTK_PDM_USE_FIELD_DATA;
+ }
+
+ // store the types in the index
+ if (p->GetDataType() == VTK_FLOAT)
+ {
+ idx |= VTK_PDM_POINT_TYPE_FLOAT;
+ }
+ else if (p->GetDataType() == VTK_DOUBLE)
+ {
+ idx |= VTK_PDM_POINT_TYPE_DOUBLE;
+ }
+ if (n)
+ {
+ if (n->GetDataType() == VTK_FLOAT)
+ {
+ idx |= VTK_PDM_NORMAL_TYPE_FLOAT;
+ }
+ else if (n->GetDataType() == VTK_DOUBLE)
+ {
+ idx |= VTK_PDM_NORMAL_TYPE_DOUBLE;
+ }
+ }
+
+ // Texture and color by texture
+ t = input->GetPointData()->GetTCoords();
+ if ( t )
+ {
+ tDim = t->GetNumberOfComponents();
+ if (tDim > 2)
+ {
+ vtkDebugMacro(<< "Currently only 1d and 2d textures are supported.\n");
+ t = NULL;
+ }
+ }
+ // Set the texture if we are going to use texture
+ // for coloring with a point attribute.
+ // fixme ... make the existance of the coordinate array the signal.
+ if (this->InterpolateScalarsBeforeMapping && this->ColorCoordinates &&
+ ! (idx & VTK_PDM_CELL_COLORS))
+ {
+ t = this->ColorCoordinates;
+ }
+ // Set the flags
+ if (t)
+ {
+ idx |= VTK_PDM_TCOORDS;
+ if (t->GetDataType() == VTK_FLOAT)
+ {
+ idx |= VTK_PDM_TCOORD_TYPE_FLOAT;
+ }
+ else if (t->GetDataType() == VTK_DOUBLE)
+ {
+ idx |= VTK_PDM_TCOORD_TYPE_DOUBLE;
+ }
+ if (t->GetNumberOfComponents() == 1)
+ {
+ idx |= VTK_PDM_TCOORD_1D;
+ }
+ // Not 1D assumes 2D texture coordinates.
+ }
+
+ if ( this->GetResolveCoincidentTopology() )
+ {
+ resolve = 1;
+ if ( this->GetResolveCoincidentTopology() == VTK_RESOLVE_SHIFT_ZBUFFER )
+ {
+ zResolve = 1;
+ zRes = this->GetResolveCoincidentTopologyZShift();
+ }
+ else
+ {
+#ifdef GL_VERSION_1_1
+ double f, u;
+ glEnable(GL_POLYGON_OFFSET_FILL);
+ this->GetResolveCoincidentTopologyPolygonOffsetParameters(f,u);
+ glPolygonOffset(f,u);
+#endif
+ }
+ }
+
+ // we need to know the total number of cells so that we can report progress
+ this->TotalCells =
+ input->GetVerts()->GetNumberOfCells() +
+ input->GetLines()->GetNumberOfCells() +
+ input->GetPolys()->GetNumberOfCells() +
+ input->GetStrips()->GetNumberOfCells();
+
+ // For verts or lines that have no normals, disable shading.
+ // This will fall back on the color set in the glColor4fv()
+ // call in vtkOpenGLProperty::Render() - the color returned
+ // by vtkProperty::GetColor() with alpha set to 1.0.
+ if (!n)
+ {
+ glDisable( GL_LIGHTING);
+ }
+
+ this->DrawPoints(idx,p,n,c,t,cellNum,noAbort,input->GetVerts(), ren);
+
+ // do lines
+ if ( zResolve )
+ {
+ glDepthRange(zRes, 1.);
+ }
+ if (rep == VTK_POINTS)
+ {
+ this->DrawPoints(idx,p,n,c,t,cellNum, noAbort,input->GetLines(), ren);
+ }
+ else
+ {
+ this->DrawLines(idx,p,n,c,t,cellNum, noAbort, input->GetLines(), ren);
+ }
+
+ // reset the lighting if we turned it off
+ if (!n)
+ {
+ glEnable( GL_LIGHTING);
+ }
+
+ // disable shading if we are rendering points, but have no normals
+ if (!n && rep == VTK_POINTS)
+ {
+ glDisable( GL_LIGHTING);
+ }
+
+ // do polys
+ if (rep == VTK_POINTS && !prop->GetBackfaceCulling() && !prop->GetFrontfaceCulling() )
+ {
+ this->DrawPoints(idx,p,n,c,t,cellNum, noAbort, input->GetPolys(), ren);
+ }
+ else if (rep == VTK_WIREFRAME && !prop->GetBackfaceCulling() && !prop->GetFrontfaceCulling())
+ {
+ this->DrawPolygons(idx,p,n,c,t,cellNum, noAbort,
+ GL_LINE_LOOP, input->GetPolys(), ren);
+ }
+ else
+ {
+ this->DrawPolygons(idx,p,n,c,t,cellNum, noAbort,
+ GL_POLYGON, input->GetPolys(), ren);
+ }
+
+
+ // do tstrips
+ if ( zResolve )
+ {
+ glDepthRange(2*zRes, 1.);
+ }
+ if (rep == VTK_POINTS && !prop->GetBackfaceCulling() && !prop->GetFrontfaceCulling() )
+ {
+ this->DrawPoints(idx,p,n,c,t,cellNum, noAbort, input->GetStrips(), ren);
+ }
+ else if (rep == VTK_WIREFRAME && !prop->GetBackfaceCulling() && !prop->GetFrontfaceCulling())
+ {
+ vtkIdType oldCellNum = cellNum;
+ this->DrawTStrips(idx,p,n,c,t,cellNum, noAbort,
+ GL_LINE_STRIP, input->GetStrips(), ren);
+ vtkOpenGLPolyDataMapperDrawTStripLines(idx,p,n,c,t,oldCellNum, noAbort,
+ GL_LINE_STRIP, input->GetStrips(),
+ ren);
+ }
+ else
+ {
+ this->DrawTStrips(idx,p,n,c,t,cellNum, noAbort,
+ GL_TRIANGLE_STRIP, input->GetStrips(), ren);
+ }
+
+ // enable lighting again if necessary
+ if (!n && rep == VTK_POINTS)
+ {
+ glEnable( GL_LIGHTING);
+ }
+
+ if (resolve)
+ {
+ if ( zResolve )
+ {
+ glDepthRange(0., 1.);
+ }
+ else
+ {
+#ifdef GL_VERSION_1_1
+ glDisable(GL_POLYGON_OFFSET_FILL);
+#endif
+ }
+ }
+
+ this->UpdateProgress(1.0);
+ return noAbort;
+}
+
+void VISU_OpenGLElnoMapper::PrintSelf(ostream& os, vtkIndent indent)
+{
+ this->Superclass::PrintSelf(os,indent);
+}
+
+
+
+//-----------------------------------------------------------------------------
+/*template<typename TValueType>
+void CopyArray(TValueType* input,TValueType* output,vtkIdType theNbElem){
+
+ for(vtkIdType iTuple = 0; iTuple < theNbElem ; iTuple++){
+ *output = *input;
+ input++;
+ output++;
+ }
+}
+
+vtkDataArray* VISU_OpenGLElnoMapper::GetElnoScalars(int cellFlag){
+
+ vtkDataArray *scalars = vtkAbstractMapper::
+ GetScalars(this->GetInput(), this->ScalarMode, this->ArrayAccessMode,
+ this->ArrayId, this->ArrayName, cellFlag);
+
+ vtkIdType anInputDataType = scalars->GetDataType();
+
+ vtkDataArray *elnoScalars = vtkDataArray::CreateDataArray(anInputDataType);
+ vtkIdType aNbElnoTuples = VISU_ElnoExtractor::GetNbOfElnoTuples(this->GetInput()->GetCellData());
+ elnoScalars->SetNumberOfComponents(1);
+ elnoScalars->SetNumberOfTuples(aNbElnoTuples);
+
+ void *scalarsPtr = scalars->GetVoidPointer(0);
+ void *elnoScalarsPtr = elnoScalars->GetVoidPointer(0);
+
+ switch(anInputDataType){
+ vtkTemplateMacro3(CopyArray,
+ (VTK_TT *)(scalarsPtr),
+ (VTK_TT *)(elnoScalarsPtr),
+ aNbElnoTuples);
+ default:
+ break;
+ }
+
+ return elnoScalars;
+ }*/
+
+
+vtkUnsignedCharArray *VISU_OpenGLElnoMapper::MapScalars(double alpha)
+{
+ int cellFlag = 0;
+ vtkDataArray *scalars = this->GetInput()->GetCellData()->GetArray("ELNO_PSEUDO_SCALARS");
+ if(!scalars)
+ return NULL;
+ // This is for a legacy feature: selection of the array component to color by
+ // from the mapper. It is now in the lookuptable. When this feature
+ // is removed, we can remove this condition.
+ if (scalars == 0 || scalars->GetNumberOfComponents() <= this->ArrayComponent)
+ {
+ this->ArrayComponent = 0;
+ }
+
+ if ( !this->ScalarVisibility || scalars==0 || this->GetInput()==0)
+ { // No scalar colors.
+ if ( this->ColorCoordinates )
+ {
+ this->ColorCoordinates->UnRegister(this);
+ this->ColorCoordinates = 0;
+ }
+ if ( this->ColorTextureMap )
+ {
+ this->ColorTextureMap->UnRegister(this);
+ this->ColorTextureMap = 0;
+ }
+ if ( this->Colors )
+ {
+ this->Colors->UnRegister(this);
+ this->Colors = 0;
+ }
+ return 0;
+ }
+
+ // Get the lookup table.
+ if ( scalars->GetLookupTable() )
+ {
+ this->SetLookupTable(scalars->GetLookupTable());
+ }
+ else
+ {
+ // make sure we have a lookup table
+ if ( this->LookupTable == 0 )
+ {
+ this->CreateDefaultLookupTable();
+ }
+ this->LookupTable->Build();
+ }
+ if ( !this->UseLookupTableScalarRange )
+ {
+ this->LookupTable->SetRange(this->ScalarRange);
+ }
+
+ // Decide betweeen texture color or vertex color.
+ // Cell data always uses vertext color.
+ // Only point data can use both texture and vertext coloring.
+ if (this->InterpolateScalarsBeforeMapping && ! cellFlag)
+ {
+ // Only use texture color if we are mapping scalars.
+ // Directly coloring with RGB unsigned chars should not use texture.
+ if ( this->ColorMode != VTK_COLOR_MODE_DEFAULT ||
+ (vtkUnsignedCharArray::SafeDownCast(scalars)) == 0 )
+ { // Texture color option.
+ this->MapScalarsToTexture(scalars, alpha);
+ return 0;
+ }
+ }
+
+ // Vertex colors are being used.
+ // Get rid of texure Color arrays. Only texture or vertex coloring
+ // can be active at one time. The existence of the array is the
+ // signal to use that technique.
+ if ( this->ColorCoordinates )
+ {
+ this->ColorCoordinates->UnRegister(this);
+ this->ColorCoordinates = 0;
+ }
+ if ( this->ColorTextureMap )
+ {
+ this->ColorTextureMap->UnRegister(this);
+ this->ColorTextureMap = 0;
+ }
+
+ // Lets try to resuse the old colors.
+ if (this->Colors)
+ {
+ if (this->LookupTable && this->LookupTable->GetAlpha() == alpha)
+ {
+ if (this->GetMTime() < this->Colors->GetMTime() &&
+ this->GetInput()->GetMTime() < this->Colors->GetMTime() &&
+ this->LookupTable->GetMTime() < this->Colors->GetMTime())
+ {
+ return this->Colors;
+ }
+ }
+ }
+
+ // Get rid of old colors
+ if ( this->Colors )
+ {
+ this->Colors->UnRegister(this);
+ this->Colors = 0;
+ }
+
+ // map scalars
+ this->LookupTable->SetAlpha(alpha);
+ this->Colors = this->LookupTable->
+ MapScalars(scalars, this->ColorMode, this->ArrayComponent);
+ // Consistent register and unregisters
+ this->Colors->Register(this);
+ this->Colors->Delete();
+
+ return this->Colors;
+}
--- /dev/null
+
+#ifndef VISU_OpenGLElnoMapper_HeaderFile
+#define VISU_OpenGLElnoMapper_HeaderFile
+
+#include "vtkPolyDataMapper.h"
+
+#include "vtkOpenGL.h" // Needed for GLenum
+
+class vtkCellArray;
+class vtkPoints;
+class vtkProperty;
+class vtkRenderWindow;
+class vtkOpenGLRenderer;
+class vtkOpenGLTexture;
+
+class VTK_RENDERING_EXPORT VISU_OpenGLElnoMapper : public vtkPolyDataMapper
+{
+public:
+ static VISU_OpenGLElnoMapper *New();
+ vtkTypeRevisionMacro(VISU_OpenGLElnoMapper, vtkPolyDataMapper);
+ virtual void PrintSelf(ostream& os, vtkIndent indent);
+
+ // Description:
+ // Implement superclass render method.
+ virtual void RenderPiece(vtkRenderer *ren, vtkActor *a);
+
+ // Description:
+ // Release any graphics resources that are being consumed by this mapper.
+ // The parameter window could be used to determine which graphic
+ // resources to release.
+ void ReleaseGraphicsResources(vtkWindow *);
+
+ // Description:
+ // Draw method for OpenGL.
+ virtual int Draw(vtkRenderer *ren, vtkActor *a);
+
+ // Description:
+ // Map the scalars (if there are any scalars and ScalarVisibility is on)
+ // through the lookup table, returning an unsigned char RGBA array. This is
+ // typically done as part of the rendering process. The alpha parameter
+ // allows the blending of the scalars with an additional alpha (typically
+ // which comes from a vtkActor, etc.)
+
+protected:
+ VISU_OpenGLElnoMapper();
+ ~VISU_OpenGLElnoMapper();
+
+
+ void DrawPoints(int idx,
+ vtkPoints *p,
+ vtkDataArray *n,
+ vtkUnsignedCharArray *c,
+ vtkDataArray *t,
+ vtkIdType &cellNum,
+ int &noAbort,
+ vtkCellArray *ca,
+ vtkRenderer *ren);
+
+ void DrawLines(int idx,
+ vtkPoints *p,
+ vtkDataArray *n,
+ vtkUnsignedCharArray *c,
+ vtkDataArray *t,
+ vtkIdType &cellNum,
+ int &noAbort,
+ vtkCellArray *ca,
+ vtkRenderer *ren);
+
+ void DrawPolygons(int idx,
+ vtkPoints *p,
+ vtkDataArray *n,
+ vtkUnsignedCharArray *c,
+ vtkDataArray *t,
+ vtkIdType &cellNum,
+ int &noAbort,
+ GLenum rep,
+ vtkCellArray *ca,
+ vtkRenderer *ren);
+
+ void DrawTStrips(int idx,
+ vtkPoints *p,
+ vtkDataArray *n,
+ vtkUnsignedCharArray *c,
+ vtkDataArray *t,
+ vtkIdType &cellNum,
+ int &noAbort,
+ GLenum rep,
+ vtkCellArray *ca,
+ vtkRenderer *ren);
+
+ vtkIdType TotalCells;
+ int ListId;
+ vtkOpenGLTexture* InternalColorTexture;
+
+ // vtkDataArray* GetElnoScalars(int cellFlag);
+ vtkUnsignedCharArray* MapScalars(double alpha);
+
+
+ /*private:
+
+ vtkOpenGLPolyDataMapper(const vtkOpenGLPolyDataMapper&); // Not implemented.
+ void operator=(const vtkOpenGLPolyDataMapper&); // Not implemented.
+ */
+};
+
+#endif
