src/MEDMEM/MEDMEM_VtkMeshDriver.cxx

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