src/CONVERTOR/VISU_IDMapper.hxx

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

//  VISU CONVERTOR :
//  File   : VISU_Convertor.hxx
//  Author : Alexey PETROV
//  Module : VISU
//
#ifndef VISU_IDMapper_HeaderFile
#define VISU_IDMapper_HeaderFile

#include "VISUConvertor.hxx"

#include "MED_SharedPtr.hxx"
#include "MED_Vector.hxx"
#include "VTKViewer.h"

#include <string>
#include <map>

class vtkUnstructuredGrid;
class vtkPolyData;
class vtkDataSet;
class vtkCell;

namespace VISU
{
  using MED::SharedPtr;
  using MED::TVector;


  //---------------------------------------------------------------
  class VISU_CONVERTOR_EXPORT TStructuredId
  {
    vtkIdType myData[3];

  public:
    TStructuredId();

    vtkIdType&
    operator [] ( size_t theId );

    const vtkIdType&
    operator [] ( size_t theId ) const;

    bool
    operator == ( const TStructuredId& theId ) const;
  };

  typedef std::map<vtkIdType, TStructuredId> TObj2StructuredId;
  typedef MED::SharedPtr<TObj2StructuredId> PObj2StructuredId;
  
  struct TStructured;
  typedef MED::SharedPtr<TStructured> PStructured;
  
  struct VISU_CONVERTOR_EXPORT TStructured
  {
    TStructured():
      myIsStructured(false),
      myIsPolarType(true)
    {}

    virtual
    void
    CopyStructure(PStructured theStructured);

    bool
    IsStructured() const;

    TStructuredId
    GetStructure();
    
    vtkIdType
    GetStructureDim();
    
    TStructuredId
    GetIndexesOfNode(vtkIdType theNodeId);

    vtkIdType
    GetObjectIDByIndexes(TStructuredId theVec);

    bool myIsStructured; 
    bool myIsPolarType; 

    TStructuredId myGrilleStructure;
    
    TObj2StructuredId myObj2StructuredId;
  };
  
  //---------------------------------------------------------------
  struct VISU_CONVERTOR_EXPORT TBaseStructure: virtual TStructured
  {
    virtual ~TBaseStructure()
    {}

    std::string myEntry; 
  };
  typedef MED::SharedPtr<TBaseStructure> PBaseStructure;

  //---------------------------------------------------------------

  struct VISU_CONVERTOR_EXPORT TIDMapper: virtual TBaseStructure
  {
    virtual 
    vtkIdType 
    GetNodeObjID(vtkIdType theID) const;

    virtual 
    vtkIdType 
    GetNodeVTKID(vtkIdType theID) const;

    virtual
    vtkFloatingPointType* 
    GetNodeCoord(vtkIdType theObjID);

    virtual 
    vtkIdType 
    GetElemObjID(vtkIdType theID) const;

    virtual 
    vtkIdType 
    GetElemVTKID(vtkIdType theID) const;

    virtual
    vtkCell* 
    GetElemCell(vtkIdType theObjID);

    virtual
    vtkDataSet*
    GetOutput() = 0;

    virtual
    unsigned long int
    GetMemorySize() = 0;
  };
  typedef MED::SharedPtr<TIDMapper> PIDMapper;
  

  //---------------------------------------------------------------
  struct VISU_CONVERTOR_EXPORT TUnstructuredGridIDMapper: virtual TIDMapper
  {
    virtual
    vtkUnstructuredGrid*
    GetUnstructuredGridOutput() = 0;

    virtual
    vtkDataSet*
    GetOutput();
  };
  typedef MED::SharedPtr<TUnstructuredGridIDMapper> PUnstructuredGridIDMapper;
  

  //---------------------------------------------------------------

  struct TNamedIDMapper: virtual TUnstructuredGridIDMapper
  {
    virtual
    std::string 
    GetNodeName(vtkIdType theObjID) const = 0;

    virtual
    std::string 
    GetElemName(vtkIdType theObjID) const = 0;
  };
  typedef MED::SharedPtr<TNamedIDMapper> PNamedIDMapper;
  

  //---------------------------------------------------------------
  struct TPolyDataIDMapper: virtual TIDMapper
  {
    virtual
    vtkPolyData*
    GetPolyDataOutput() = 0;

    virtual
    vtkDataSet*
    GetOutput();
  };
  typedef MED::SharedPtr<TPolyDataIDMapper> PPolyDataIDMapper;
  

  //---------------------------------------------------------------
  typedef vtkIdType TCellID; 
  typedef vtkIdType TLocalPntID;
  typedef std::pair<TCellID,TLocalPntID> TGaussPointID;

  struct TGaussPtsIDMapper: virtual TPolyDataIDMapper
  {
    virtual 
    TGaussPointID 
    GetObjID(vtkIdType theID) const = 0;

    virtual 
    vtkIdType 
    GetVTKID(const TGaussPointID& theID) const = 0;

    virtual 
    TNamedIDMapper*
    GetParent() const = 0;
  };
  typedef MED::SharedPtr<TGaussPtsIDMapper> PGaussPtsIDMapper;

  //---------------------------------------------------------------
}

#endif