src/MEDMEM/MEDMEM_VtkMeshDriver.cxx

   1 using namespace std;
   2 #include "MEDMEM_VtkMeshDriver.hxx"
   3
   4 #include "MEDMEM_DriversDef.hxx"
   5
   6 #include "MEDMEM_Family.hxx"
   7 #include "MEDMEM_Group.hxx"
   8 #include "MEDMEM_Coordinate.hxx"
   9 #include "MEDMEM_Connectivity.hxx"
  10 #include "MEDMEM_Mesh.hxx"
  11 #include "MEDMEM_CellModel.hxx"
  12 #include "MEDMEM_Grid.hxx"
  13
  14 #include <sstream>
  15 using namespace MEDMEM;
  16
  17 VTK_MESH_DRIVER::VTK_MESH_DRIVER(): GENDRIVER(),
  18                                     _ptrMesh((MESH * const)MED_NULL)
  19 {
  20   _vtkFile = new ofstream();
  21   // What about _id in Gendriver ?
  22   // _driverType ???
  23 }
  24
  25 VTK_MESH_DRIVER::VTK_MESH_DRIVER(const string & fileName,
  26                                  MESH * ptrMesh) :
  27   GENDRIVER(fileName,MED_WRONLY),
  28   _ptrMesh(ptrMesh)
  29 {
  30   const char * LOC = "VTK_MESH_DRIVER::VTK_MESH_DRIVER(const string & fileName, MESH * ptrMesh) : " ;
  31
  32   // Send an exception because a VTK_MESH_DRIVER object cannot be instantied
  33   // from a file and there is no read for that kind of driver
  34
  35   //  throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << "This driver is only used to write in VTK format So thie object can not be instantied using a file!"));
  36
  37   //  _ptrMesh->addDriver(*this); // OU RECUPERER L'ID.
  38   MESSAGE(LOC << "WARNING this driver is only used to write in VTK format So the object can not be instantied using a file!");
  39
  40   _vtkFile = new ofstream();
  41 }
  42
  43 VTK_MESH_DRIVER::VTK_MESH_DRIVER(const VTK_MESH_DRIVER & driver):
  44   GENDRIVER(driver),
  45   _ptrMesh(driver._ptrMesh),
  46   _meshName(driver._meshName)
  47 {
  48   _ptrMesh->addDriver(*this);
  49   _vtkFile = new ofstream();
  50 }
  51
  52 VTK_MESH_DRIVER::~VTK_MESH_DRIVER()
  53 {
  54   const char * LOC ="VTK_MESH_DRIVER::~VTK_MESH_DRIVER()";
  55   BEGIN_OF(LOC);
  56
  57   close();
  58
  59   SCRUTE(_vtkFile);
  60
  61   delete _vtkFile ;
  62
  63   SCRUTE(_vtkFile);
  64
  65   END_OF(LOC);
  66 }
  67
  68 void VTK_MESH_DRIVER::openConst() const throw (MEDEXCEPTION)
  69 {
  70   const char * LOC = "VTK_MESH_DRIVER::openConst()" ;
  71   BEGIN_OF(LOC);
  72
  73   MESSAGE(LOC<<" : _fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
  74
  75   if ( _fileName == "" )
  76     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
  77                                      << "_fileName is |\"\"|, please set a correct fileName before calling open()"
  78                                      )
  79                           );
  80
  81   if (!(*_vtkFile).is_open())
  82     (*_vtkFile).open(_fileName.c_str()) ;
  83 //    if (*_vtkFile)
  84 //      _status = MED_OPENED ;
  85 //    else
  86
  87
  88   SCRUTE((*_vtkFile).is_open());
  89   SCRUTE(_vtkFile);
  90
  91
  92
  93   if (!(*_vtkFile))
  94     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not open file "
  95                                      << _fileName)
  96                           );
  97   END_OF(LOC);
  98 }
  99
 100 void VTK_MESH_DRIVER::open() {
 101   openConst() ;
 102 }
 103
 104 void VTK_MESH_DRIVER::closeConst() const throw (MEDEXCEPTION)
 105 {
 106   const char * LOC = "VTK_MESH_DRIVER::closeConst() " ;
 107   BEGIN_OF(LOC);
 108
 109   SCRUTE(_vtkFile);
 110   SCRUTE(*_vtkFile);
 111
 112
 113   if ((*_vtkFile).is_open())
 114     (*_vtkFile).close();
 115
 116 //    if (*_vtkFile)
 117 //      _status = MED_CLOSED ;
 118 //    else
 119
 120   SCRUTE(_vtkFile);
 121   SCRUTE(*_vtkFile);
 122
 123   if (!(*_vtkFile))
 124     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not close file "
 125                                      << _fileName)
 126                           );
 127
 128   END_OF(LOC);
 129 }
 130
 131 void VTK_MESH_DRIVER::close() {
 132   closeConst() ;
 133 }
 134
 135 void    VTK_MESH_DRIVER::setMeshName(const string & meshName) { _meshName = meshName; };
 136 string  VTK_MESH_DRIVER::getMeshName() const { return _meshName; };
 137
 138 void VTK_MESH_DRIVER::read(void) throw (MEDEXCEPTION)
 139 {
 140   const char * LOC = "VTK_MESH_DRIVER::read() : " ;
 141   BEGIN_OF(LOC);
 142
 143   // Send an exception
 144
 145   throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << "This driver is only used to write in VTK format !"));
 146
 147   END_OF(LOC);
 148 }
 149
 150
 151 void VTK_MESH_DRIVER::write(void) const
 152   throw (MEDEXCEPTION)
 153 {
 154   const char * LOC = "void VTK_MESH_DRIVER::write(void) const : ";
 155   BEGIN_OF(LOC);
 156
 157   // Well we must open vtk file first, because there are
 158   // no other driver than MED for VTK that do it !
 159
 160   openConst();
 161
 162   (*_vtkFile) << "# vtk DataFile Version 2.0" << endl
 163            << "maillage from MedMemory"  << endl ;
 164   // only ASCII for the moment (binary came later :-)
 165   (*_vtkFile) << "ASCII" << endl ;
 166
 167
 168   (*_vtkFile) << "DATASET UNSTRUCTURED_GRID" << endl ;
 169   // put points (all point are in 3D, so if we are in 1D or 2D, we complete by zero !
 170   int SpaceDimension = _ptrMesh->getSpaceDimension() ;
 171   int NumberOfNodes = _ptrMesh->getNumberOfNodes() ;
 172   (*_vtkFile) << "POINTS " << NumberOfNodes << " float" << endl ;
 173   const double *coordinate = _ptrMesh->getCoordinates(MED_FULL_INTERLACE) ;
 174   for (int i=0;i<NumberOfNodes;i++) {
 175     for (int j=0;j<SpaceDimension;j++)
 176       (*_vtkFile) << coordinate[i*SpaceDimension+j] << " " ;
 177     if (SpaceDimension==1)
 178       (*_vtkFile) << "0 0" ;
 179     if (SpaceDimension==2)
 180       (*_vtkFile) << "0" ;
 181     (*_vtkFile) << endl ;
 182   }
 183
 184   // we put connectivity
 185   // how many cells and how many value in connectivity :
 186   int cells_types_count = _ptrMesh->getNumberOfTypes(MED_CELL) ;
 187   //  int * cells_count = _ptrMesh->get_cells_count() ;
 188   //  int cells_sum = cells_count[cells_types_count] ;
 189   int cells_sum = _ptrMesh->getNumberOfElements(MED_CELL,MED_ALL_ELEMENTS) ;
 190   const CELLMODEL * cells_type = _ptrMesh->getCellsTypes(MED_CELL) ;
 191   //  int connectivity_sum = 0 ;
 192
 193   //const int * connectivity = _ptrMesh->getConnectivity(MED_FULL_INTERLACE,MED_NODAL,MED_CELL,MED_ALL_ELEMENTS) ; !! UNUSED VARIABLE !!
 194   const int * connectivityIndex = _ptrMesh->getConnectivityIndex(MED_NODAL,MED_CELL) ;
 195
 196   int connectivity_sum =  connectivityIndex[cells_sum]-1 ;
 197
 198   (*_vtkFile) << "CELLS " << cells_sum << " " << connectivity_sum+cells_sum << endl ;
 199   // we put connectivity
 200   for (int i=0;i<cells_types_count;i++) {
 201     int *filter = (int*) NULL ; // index in vtk connectivity
 202     switch (cells_type[i].getType())
 203       {
 204       case MED_POINT1  : {
 205         filter = new int[1] ;
 206         filter[0] = 0 ;
 207         break ;
 208       }
 209       case MED_SEG2    : {
 210         filter = new int[2] ;
 211         filter[0] = 0 ;
 212         filter[1] = 1 ;
 213         break ;
 214       }
 215       case MED_SEG3    : {
 216         break ;
 217       }
 218       case MED_TRIA3   : {
 219         filter = new int[3] ;
 220         filter[0] = 0 ;
 221         filter[1] = 1 ;
 222         filter[2] = 2 ;
 223         break ;
 224       }
 225       case MED_QUAD4   : {
 226         filter = new int[4] ;
 227         filter[0] = 0 ;
 228         filter[1] = 1 ;
 229         filter[2] = 2 ;
 230         filter[3] = 3 ;
 231         break ;
 232       }
 233       case MED_TRIA6   : {
 234         break ;
 235       }
 236       case MED_QUAD8   : {
 237         break ;
 238       }
 239       case MED_TETRA4  : {
 240         filter = new int[4] ;
 241         filter[0] = 0 ;
 242         filter[1] = 1 ;
 243         filter[2] = 3 ;  // 3td element in med are 4th in vtk (array begin at 0 !)
 244         filter[3] = 2 ;  // 4th element in med are 3rd in vtk (array begin at 0 !)
 245         break ;
 246       }
 247       case MED_PYRA5   : {
 248         filter = new int[5] ;
 249         filter[0] = 0 ;
 250         filter[1] = 3 ;  // 2nd element in med are 4th in vtk (array begin at 0 !)
 251         filter[2] = 2 ;
 252         filter[3] = 1 ;  // 4th element in med are 2nd in vtk (array begin at 0 !)
 253         filter[4] = 4 ;
 254         break ;
 255       }
 256       case MED_PENTA6  : {
 257         filter = new int[6] ;
 258         filter[0] = 0 ;
 259         filter[1] = 1 ;
 260         filter[2] = 2 ;
 261         filter[3] = 3 ;
 262         filter[4] = 4 ;
 263         filter[5] = 5 ;
 264         break ;
 265       }
 266       case MED_HEXA8   : {
 267         filter = new int[8] ;
 268         filter[0] = 0 ;
 269         filter[1] = 3 ;
 270         filter[2] = 2 ;
 271         filter[3] = 1 ;
 272         filter[4] = 4 ;
 273         filter[5] = 7 ;
 274         filter[6] = 6 ;
 275         filter[7] = 5 ;
 276         break ;
 277       }
 278       case MED_TETRA10 : {
 279         break ;
 280       }
 281       case MED_PYRA13  : {
 282         break ;
 283       }
 284       case MED_PENTA15 : {
 285         break ;
 286       }
 287       case MED_HEXA20  : {
 288         break ;
 289       }
 290       default : {
 291         break ;
 292       }
 293       }
 294     if (filter==NULL)
 295       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": MED element type not supported yet : " << cells_type[i].getName() ) ) ;
 296     int nodes_cell = cells_type[i].getNumberOfNodes();
 297     int numberOfCell = _ptrMesh->getNumberOfElements(MED_CELL,cells_type[i].getType()) ;
 298     const int * connectivityArray = _ptrMesh->getConnectivity(MED_FULL_INTERLACE,MED_NODAL,MED_CELL,cells_type[i].getType());
 299     for (int j=0;j<numberOfCell;j++) {
 300       (*_vtkFile) << nodes_cell << " " ;
 301       for (int k=0;k<nodes_cell;k++)
 302         (*_vtkFile) << connectivityArray[j*nodes_cell+filter[k]] - 1 << " " ;
 303       (*_vtkFile) << endl ;
 304     }
 305     if (filter != NULL)
 306       delete[] filter ;
 307   }
 308   (*_vtkFile) << endl ;
 309   // we put cells type
 310   (*_vtkFile) << "CELL_TYPES " << cells_sum << endl ;
 311   for (int i=0;i<cells_types_count;i++) {
 312     int vtkType = 0 ;
 313     switch (cells_type[i].getType())
 314       {
 315       case MED_POINT1  : {
 316         vtkType = 1 ;
 317         break ;
 318       }
 319       case MED_SEG2    : {
 320         vtkType = 3 ;
 321         break ;
 322       }
 323       case MED_SEG3    : {
 324         vtkType = 0 ;
 325         break ;
 326       }
 327       case MED_TRIA3   : {
 328         vtkType = 5 ;
 329         break ;
 330       }
 331       case MED_QUAD4   : {
 332         vtkType = 9 ;
 333         break ;
 334       }
 335       case MED_TRIA6   : {
 336         vtkType = 0 ;
 337         break ;
 338       }
 339       case MED_QUAD8   : {
 340         vtkType = 0 ;
 341         break ;
 342       }
 343       case MED_TETRA4  : {
 344         vtkType = 10 ;
 345         break ;
 346       }
 347       case MED_PYRA5   : {
 348         vtkType = 14 ;
 349         break ;
 350       }
 351       case MED_PENTA6  : {
 352         vtkType = 13 ;
 353         break ;
 354       }
 355       case MED_HEXA8   : {
 356         vtkType = 12 ;
 357         break ;
 358       }
 359       case MED_TETRA10 : {
 360         vtkType = 0 ;
 361         break ;
 362       }
 363       case MED_PYRA13  : {
 364         vtkType = 0 ;
 365         break ;
 366       }
 367       case MED_PENTA15 : {
 368         vtkType = 0 ;
 369         break ;
 370       }
 371       case MED_HEXA20  : {
 372         vtkType = 0 ;
 373         break ;
 374       }
 375       default : {
 376         vtkType = 0 ;
 377         break ;
 378       }
 379       }
 380     if (vtkType == 0)
 381       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": MED element type not supported yet : " << cells_type[i].getType() ) ) ;
 382     int numberOfCell = _ptrMesh->getNumberOfElements(MED_CELL,cells_type[i].getType()) ;
 383     for (int j=0;j<numberOfCell;j++)
 384       (*_vtkFile) << vtkType << endl ;
 385   }
 386
 387
 388   END_OF(LOC);
 389 }
 390
 391 GENDRIVER * VTK_MESH_DRIVER::copy(void) const
 392 {
 393   return new VTK_MESH_DRIVER(*this);
 394 }