vtkGenericEnSightReader.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkGenericEnSightReader.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkGenericEnSightReader_h
#define vtkGenericEnSightReader_h
 
#include "vtkIOEnSightModule.h" // For export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
 
class vtkCallbackCommand;
class vtkDataArrayCollection;
class vtkDataArraySelection;
class vtkIdListCollection;
 
//BTX
class TranslationTableType;
//ETX
 
//BTX
// Cell/Point Ids store mode:
// Sparse Mode is supposed to be for a large number of distributed processes (Unstructured)
// Non Sparse Mode is supposed to be for a small number of distributed processes (Unstructured)
// Implicit Mode is for Structured Data
enum EnsightReaderCellIdMode
    {
    SINGLE_PROCESS_MODE,
    SPARSE_MODE,
    NON_SPARSE_MODE,
    IMPLICIT_STRUCTURED_MODE
    };
//ETX
 
class VTKIOENSIGHT_EXPORT vtkGenericEnSightReader : public vtkMultiBlockDataSetAlgorithm
{
public:
  static vtkGenericEnSightReader *New();
  vtkTypeMacro(vtkGenericEnSightReader, vtkMultiBlockDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);
 
 
  void SetCaseFileName(const char* fileName);
  vtkGetStringMacro(CaseFileName);
 
 
  vtkSetStringMacro(FilePath);
  vtkGetStringMacro(FilePath);
 
 
  vtkGetMacro(EnSightVersion, int);
 
 
  vtkGetMacro(NumberOfVariables, int);
  vtkGetMacro(NumberOfComplexVariables, int);
 
 
  int GetNumberOfVariables(int type); // returns -1 if unknown type specified
  vtkGetMacro(NumberOfScalarsPerNode, int);
  vtkGetMacro(NumberOfVectorsPerNode, int);
  vtkGetMacro(NumberOfTensorsSymmPerNode, int);
  vtkGetMacro(NumberOfScalarsPerElement, int);
  vtkGetMacro(NumberOfVectorsPerElement, int);
  vtkGetMacro(NumberOfTensorsSymmPerElement, int);
  vtkGetMacro(NumberOfScalarsPerMeasuredNode, int);
  vtkGetMacro(NumberOfVectorsPerMeasuredNode, int);
  vtkGetMacro(NumberOfComplexScalarsPerNode, int);
  vtkGetMacro(NumberOfComplexVectorsPerNode, int);
  vtkGetMacro(NumberOfComplexScalarsPerElement, int);
  vtkGetMacro(NumberOfComplexVectorsPerElement, int);
 
  const char* GetDescription(int n);
 
  const char* GetComplexDescription(int n);
 
  const char* GetDescription(int n, int type);
 
 
  int GetVariableType(int n);
  int GetComplexVariableType(int n);
 
 
  virtual void SetTimeValue(float value);
  vtkGetMacro(TimeValue, float);
 
 
  vtkGetMacro(MinimumTimeValue, float);
  vtkGetMacro(MaximumTimeValue, float);
 
 
  vtkGetObjectMacro(TimeSets, vtkDataArrayCollection);
 
  int DetermineEnSightVersion(int quiet=0);
 
 
  vtkBooleanMacro(ReadAllVariables, int);
  vtkSetMacro(ReadAllVariables, int);
  vtkGetMacro(ReadAllVariables, int);
 
 
  vtkGetObjectMacro(PointDataArraySelection, vtkDataArraySelection);
  vtkGetObjectMacro(CellDataArraySelection, vtkDataArraySelection);
 
 
  int GetNumberOfPointArrays();
  int GetNumberOfCellArrays();
 
 
  const char* GetPointArrayName(int index);
  const char* GetCellArrayName(int index);
 
 
  int GetPointArrayStatus(const char* name);
  int GetCellArrayStatus(const char* name);
  void SetPointArrayStatus(const char* name, int status);
  void SetCellArrayStatus(const char* name, int status);
 
  //BTX
  enum FileTypes
  {
    ENSIGHT_6             = 0,
    ENSIGHT_6_BINARY      = 1,
    ENSIGHT_GOLD          = 2,
    ENSIGHT_GOLD_BINARY   = 3,
    ENSIGHT_MASTER_SERVER = 4
  };
  //ETX
 
 
  void SetByteOrderToBigEndian();
  void SetByteOrderToLittleEndian();
  vtkSetMacro(ByteOrder, int);
  vtkGetMacro(ByteOrder, int);
  const char *GetByteOrderAsString();
 
//BTX
  enum
  {
    FILE_BIG_ENDIAN=0,
    FILE_LITTLE_ENDIAN=1,
    FILE_UNKNOWN_ENDIAN=2
  };
//ETX
 
 
  vtkGetStringMacro(GeometryFileName);
 
 
  vtkSetMacro(ParticleCoordinatesByIndex, int);
  vtkGetMacro(ParticleCoordinatesByIndex, int);
  vtkBooleanMacro(ParticleCoordinatesByIndex, int);
 
  static int CanReadFile(const char *casefilename);
 
//THIB
vtkGenericEnSightReader* GetReader() { return this->Reader; }
 
 
protected:
  vtkGenericEnSightReader();
  ~vtkGenericEnSightReader();
 
  virtual int FillOutputPortInformation(int port, vtkInformation* info);
  virtual int RequestInformation(vtkInformation*,
                                 vtkInformationVector**,
                                 vtkInformationVector*);
  virtual int RequestData(vtkInformation*,
                          vtkInformationVector**,
                          vtkInformationVector*);
 
  virtual void ClearForNewCaseFileName();
 
  int ReadLine(char result[256]);
 
  int ReadBinaryLine(char result[80]);
 
  // Internal function that skips blank lines and reads the 1st
  // non-blank line it finds (up to 256 characters).
  // Returns 0 is there was an error.
  int ReadNextDataLine(char result[256]);
 
 
  vtkSetStringMacro(GeometryFileName);
 
 
  void AddVariableDescription(const char* description);
  void AddComplexVariableDescription(const char* description);
 
 
  void AddVariableType(int variableType);
  void AddComplexVariableType(int variableType);
 
 
  int  ReplaceWildcards(char* fileName, int timeSet, int fileSet);
  void ReplaceWildcardsHelper(char* fileName, int num);
 
  // Callback registered with the SelectionObserver.
  static void SelectionModifiedCallback(vtkObject* caller, unsigned long eid,
                                        void* clientdata, void* calldata);
  void SelectionModified();
 
  // Utility to create argument for vtkDataArraySelection::SetArrays.
  char** CreateStringArray(int numStrings);
  void DestroyStringArray(int numStrings, char** strings);
 
  // Fill the vtkDataArraySelection objects with the current set of
  // EnSight variables.
  void SetDataArraySelectionSetsFromVariables();
 
  // Fill the vtkDataArraySelection objects with the current set of
  // arrays in the internal EnSight reader.
  void SetDataArraySelectionSetsFromReader();
 
  // Fill the internal EnSight reader's vtkDataArraySelection objects
  // from those in this object.
  void SetReaderDataArraySelectionSetsFromSelf();
 
  istream* IS;
  FILE *IFile;
  vtkGenericEnSightReader *Reader;
 
  char* CaseFileName;
  char* GeometryFileName;
  char* FilePath;
 
  // array of types (one entry per instance of variable type in case file)
  int* VariableTypes;
  int* ComplexVariableTypes;
 
  // pointers to lists of descriptions
  char** VariableDescriptions;
  char** ComplexVariableDescriptions;
 
  int NumberOfVariables;
  int NumberOfComplexVariables;
 
  // number of file names / descriptions per type
  int NumberOfScalarsPerNode;
  int NumberOfVectorsPerNode;
  int NumberOfTensorsSymmPerNode;
  int NumberOfScalarsPerElement;
  int NumberOfVectorsPerElement;
  int NumberOfTensorsSymmPerElement;
  int NumberOfScalarsPerMeasuredNode;
  int NumberOfVectorsPerMeasuredNode;
  int NumberOfComplexScalarsPerNode;
  int NumberOfComplexVectorsPerNode;
  int NumberOfComplexScalarsPerElement;
  int NumberOfComplexVectorsPerElement;
 
  float TimeValue;
  float MinimumTimeValue;
  float MaximumTimeValue;
 
  // Flag for whether TimeValue has been set.
  int TimeValueInitialized;
 
  vtkDataArrayCollection *TimeSets;
  virtual void SetTimeSets(vtkDataArrayCollection*);
 
  int ReadAllVariables;
 
  int ByteOrder;
  int ParticleCoordinatesByIndex;
 
  // The EnSight file version being read.  Valid after
  // UpdateInformation.  Value is -1 for unknown version.
  int EnSightVersion;
 
  // The array selections.  These map over the variables and complex
  // variables to hide the details of EnSight behind VTK terminology.
  vtkDataArraySelection* PointDataArraySelection;
  vtkDataArraySelection* CellDataArraySelection;
 
  // The observer to modify this object when the array selections are
  // modified.
  vtkCallbackCommand* SelectionObserver;
 
  // Whether the SelectionModified callback should invoke Modified.
  // This is used when we are copying to/from the internal reader.
  int SelectionModifiedDoNotCallModified;
 
  // Insert a partId and return the 'realId' that should be used.
  int InsertNewPartId(int partId);
 
  // Wrapper around an stl map
  TranslationTableType *TranslationTable;
 
private:
  vtkGenericEnSightReader(const vtkGenericEnSightReader&);  // Not implemented.
  void operator=(const vtkGenericEnSightReader&);  // Not implemented.
};
 
#endif