src/CONVERTOR/VISU_Convertor.hxx

Go to the documentation of this file.

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

#ifndef VISU_Convertor_HeaderFile
#define VISU_Convertor_HeaderFile

#include "VISU_IDMapper.hxx"
#include "VISU_ConvertorDef.hxx"

#include "MED_Vector.hxx"

#include <map>
#include <set>
#include <utility>
#include <string>
#include <stdexcept>

namespace VISU
{
  using MED::TVector;

  //---------------------------------------------------------------
  typedef std::string TName;

  typedef TVector<TName> TNames;

  //---------------------------------------------------------------
  struct TIntId: virtual TBaseStructure
  {
    vtkIdType myId;

    TIntId(): myId(0)
    {}
  };


  //---------------------------------------------------------------
  typedef std::map<TEntity,PMeshOnEntity> TMeshOnEntityMap;
  typedef std::map<TName,PGroup> TGroupMap;


  struct TMesh: virtual TBaseStructure
  {
    TMeshOnEntityMap myMeshOnEntityMap; 
    TGroupMap myGroupMap; 
    TName myName; 
    int myDim; 

    std::string myGroupsEntry; 
    std::string myFieldsEntry; 

    TMesh(): myDim(0)
    {}
  };
  typedef std::map<std::string,PMesh> TMeshMap;


  //---------------------------------------------------------------
  struct TSubProfile: virtual TBaseStructure
  {};


  //---------------------------------------------------------------
  struct TProfile: virtual TNamedIDMapper
  {};


  //---------------------------------------------------------------
  bool
  operator<(const PSubProfile& theLeft, const PSubProfile& theRight);

  typedef std::set<PSubProfile> TProfileKey;
  typedef std::map<TProfileKey,PProfile> TProfileMap;


  //---------------------------------------------------------------
  struct TGauss: virtual TBaseStructure
  {};


  //---------------------------------------------------------------
  struct TGaussSubMesh: virtual TBaseStructure
  {
    PSubProfile mySubProfile; 
  };

  
  //---------------------------------------------------------------
  struct TGaussMesh: virtual TGaussPtsIDMapper
  {};


  //---------------------------------------------------------------
  bool
  operator<(const PGaussSubMesh& theLeft, const PGaussSubMesh& theRight);

  typedef std::set<PGaussSubMesh> TGaussKey;
  typedef std::map<TGaussKey,PGaussMesh> TGaussMeshMap;


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

  typedef std::map<TName,PFamily> TFamilyMap;
  typedef std::map<TName,PField> TFieldMap;


  struct TMeshOnEntity: virtual TNamedIDMapper
  {
    TGaussMeshMap myGaussMeshMap; 
    TProfileMap myProfileMap; 

    TFamilyMap myFamilyMap; 
    TFieldMap myFieldMap; 

    TName myMeshName; 
    TEntity myEntity; 
  };


  //---------------------------------------------------------------
  struct TFamily: virtual TIntId,
            virtual TIDMapper
  {
    TEntity myEntity; 
    TName myName; 
  };


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

  class FamilyCmp {
   public:
    bool operator() (const PFamily& theFamily1, const PFamily& theFamily2) const {
       return (theFamily1->myName < theFamily2->myName);
    }
  };

  typedef std::set<PFamily, FamilyCmp> TFamilySet;

  struct TGroup: virtual TIDMapper
  {
    TFamilySet myFamilySet;
  };


  //---------------------------------------------------------------
  typedef std::map<vtkIdType,PValForTime> TValField;
  typedef std::pair<vtkFloatingPointType,vtkFloatingPointType> TMinMax;

  struct TField: virtual TIntId
  {
    TEntity myEntity; 
    TName myName; 
    TName myMeshName; 
    TValField myValField; 
    TNames myCompNames; 
    TNames myUnitNames; 
    vtkIdType myNbComp; 


    virtual
    TMinMax 
    GetMinMax(vtkIdType theCompID) = 0;
    
    bool myIsMinMaxInitilized; 

    TField(): 
      myNbComp(0),
      myIsMinMaxInitilized(false)
    {}
  };
 

  //---------------------------------------------------------------
  typedef std::pair<double,std::string> TTime;

  struct TValForTime: virtual TIntId
  {
    TEntity myEntity; 
    TName myMeshName; 
    TName myFieldName; 
    TTime myTime;

    PProfile myProfile; 
    PGaussMesh myGaussMesh;
  };


  //---------------------------------------------------------------
  void 
  WriteToFile(vtkUnstructuredGrid* theDataSet, 
           const std::string& theFileName);
};


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

class VISU_Convertor
{
protected:
  std::string myName;
  VISU::TMeshMap myMeshMap;
  int myIsDone;

public:
  virtual 
  ~VISU_Convertor()
  {};
  
  virtual
  const std::string& 
  GetName(){ return myName;}

  virtual
  int
  IsDone() const { return myIsDone; }

  typedef VISU::TVTKOutput TOutput;

  virtual
  VISU_Convertor* 
  Build() = 0;

  virtual
  VISU_Convertor* 
  BuildEntities() = 0;

  virtual
  VISU_Convertor* 
  BuildFields() = 0;

  virtual
  VISU_Convertor* 
  BuildMinMax() = 0;

  virtual
  VISU_Convertor* 
  BuildGroups() = 0;

  virtual
  const VISU::TMeshMap& 
  GetMeshMap();

  virtual
  vtkFloatingPointType
  GetSize() = 0;

  virtual
  VISU::PNamedIDMapper 
  GetMeshOnEntity(const std::string& theMeshName, 
            const VISU::TEntity& theEntity) = 0;
  
  virtual
  vtkFloatingPointType
  GetMeshOnEntitySize(const std::string& theMeshName, 
                const VISU::TEntity& theEntity) = 0;
  
  virtual 
  VISU::PIDMapper 
  GetFamilyOnEntity(const std::string& theMeshName, 
              const VISU::TEntity& theEntity,
              const std::string& theFamilyName) = 0;

  virtual 
  vtkFloatingPointType 
  GetFamilyOnEntitySize(const std::string& theMeshName, 
               const VISU::TEntity& theEntity,
               const std::string& theFamilyName) = 0;

  virtual
  VISU::PIDMapper
  GetMeshOnGroup(const std::string& theMeshName, 
           const std::string& theGroupName) = 0;
  
  virtual
  vtkFloatingPointType
  GetMeshOnGroupSize(const std::string& theMeshName, 
               const std::string& theGroupName) = 0;
  
  virtual
  VISU::PIDMapper 
  GetTimeStampOnMesh(const std::string& theMeshName, 
               const VISU::TEntity& theEntity,
               const std::string& theFieldName,
               int theStampsNum) = 0;

  virtual
  VISU::PGaussPtsIDMapper 
  GetTimeStampOnGaussPts(const std::string& theMeshName, 
                const VISU::TEntity& theEntity,
                const std::string& theFieldName,
                int theStampsNum) = 0;
   
  virtual 
  vtkFloatingPointType
  GetTimeStampSize(const std::string& theMeshName, 
             const VISU::TEntity& theEntity,
             const std::string& theFieldName,
             int theStampsNum) = 0;
    
  virtual 
  vtkFloatingPointType
  GetFieldOnMeshSize(const std::string& theMeshName, 
               const VISU::TEntity& theEntity,
               const std::string& theFieldName) = 0;
  
  virtual
  const VISU::PField 
  GetField(const std::string& theMeshName, 
        VISU::TEntity theEntity, 
        const std::string& theFieldName) = 0;
  
  virtual
  const VISU::PValForTime 
  GetTimeStamp(const std::string& theMeshName, 
            const VISU::TEntity& theEntity,
            const std::string& theFieldName,
            int theStampsNum) = 0;
    
  static 
  std::string 
  GenerateName(const VISU::TTime& aTime);

  static 
  std::string 
  GenerateName(const std::string& theName, unsigned int theTimeId);
};

extern "C"
{
  VISU_Convertor* 
  CreateConvertor(const std::string& theFileName);
};


#endif

Generated on Thu Apr 26 18:52:27 2007 for SALOME - VISU - v.3.2.6 by  1.4.6