Utilities/Xdmf/vtk/vtkXdmfReader.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkXdmfReader.h,v $
  Language:  C++

  Copyright (c) 1993-2002 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 __vtkXdmfReader_h
#define __vtkXdmfReader_h

#include "vtkDataReader.h"

class vtkDoubleArray;
class vtkDataArray;
class vtkRectilinearGrid;
class vtkDataObject;
class vtkRectilinearGrid;
class vtkDataArraySelection;
class vtkCallbackCommand;
class vtkDataSet;
class vtkMultiProcessController;

//BTX
class XdmfDOM;
class XdmfFormatMulti;
class XdmfTransform;
class XdmfDataDesc;
class XdmfGrid;
class vtkXdmfDataArray;

class vtkXdmfReaderInternal;

//ETX

class VTK_EXPORT vtkXdmfReader : public vtkDataReader
{
public:
  static vtkXdmfReader* New();
  vtkTypeRevisionMacro(vtkXdmfReader, vtkDataReader);
  void PrintSelf(ostream& os, vtkIndent indent);


  vtkDataObject *GetOutput();
  vtkDataObject *GetOutput(int idx);


  vtkGetObjectMacro(PointDataArraySelection, vtkDataArraySelection);
  vtkGetObjectMacro(CellDataArraySelection, vtkDataArraySelection);
  

  int GetNumberOfPointArrays();
  int GetNumberOfCellArrays();
  

  const char* GetPointArrayName(int index);
  const char* GetCellArrayName(int index);
  
  int GetNumberOfParameters();


  int GetParameterType(int index);
  int GetParameterType(const char *Name);
  const char *GetParameterTypeAsString(int index);
  const char *GetParameterTypeAsString(const char *Name);


  int GetParameterRange(int index, int Shape[3]);
  int GetParameterRange(const char *Name, int Shape[3]);
  const char *GetParameterRangeAsString(int index);
  const char *GetParameterRangeAsString(const char *Name);

  const char *GetParameterName(int index);


  int SetParameterIndex(const char *Name, int CurrentIndex); 
  int SetParameterIndex(int ParameterIndex, int CurrentIndex); 
  int GetParameterIndex(const char *Name);
  int GetParameterIndex(int index);


  int GetParameterLength(const char *Name);
  int GetParameterLength(int index);



  const char *GetParameterValue(int index);
  const char *GetParameterValue(const char *Name);


  int GetPointArrayStatus(const char* name);
  int GetCellArrayStatus(const char* name);
  void SetPointArrayStatus(const char* name, int status);  
  void SetCellArrayStatus(const char* name, int status);  


  void EnableAllArrays();
  void DisableAllArrays();

  const char *GetXdmfDOMHandle();

  virtual void SetDomainName(const char*);
  vtkGetStringMacro(DomainName);

  void SetGridName(const char*);


  int GetNumberOfDomains();
  int GetNumberOfGrids();


  const char* GetDomainName(int idx);
  const char* GetGridName(int idx);
  int GetGridIndex(const char* name);


  void SetStride(int x, int y, int z);
  void SetStride(int xyz[3])
    {
    this->SetStride(xyz[0], xyz[1], xyz[2]);
    }
  vtkGetVector3Macro(Stride, int);


  void EnableGrid(const char* name);
  void EnableGrid(int idx);
  void EnableAllGrids();


  void DisableGrid(const char* name);
  void DisableGrid(int idx);
  void DisableAllGrids();


  int GetGridSetting(const char* name);
  int GetGridSetting(int idx);

  virtual int CanReadFile(const char* fname);
  
  void SetController(vtkMultiProcessController* controller);
  
  // Return the controller used to coordinate parallel reading. By default,
  // it is the global controller.
  vtkGetObjectMacro(Controller,vtkMultiProcessController);
  
protected:
  vtkXdmfReader();
  ~vtkXdmfReader();   

  virtual int ProcessRequest(vtkInformation *request,
                             vtkInformationVector **inputVector,
                             vtkInformationVector *outputVector);
  
  virtual int RequestDataObject(vtkInformationVector *outputVector);
  
  virtual int RequestData(vtkInformation *, vtkInformationVector **,
                          vtkInformationVector *);
  virtual int RequestInformation(vtkInformation *, vtkInformationVector **,
                                 vtkInformationVector *);
  virtual int FillOutputPortInformation(int port, vtkInformation *info);

  // Callback registered with the SelectionObserver.
  static void SelectionModifiedCallback(vtkObject* caller, unsigned long eid,
                                        void* clientdata, void* calldata);


  // The array selections.
  vtkDataArraySelection* PointDataArraySelection;
  vtkDataArraySelection* CellDataArraySelection;

  // The observer to modify this object when the array selections are
  // modified.
  vtkCallbackCommand* SelectionObserver;

  XdmfDOM         *DOM;

  char* DomainName;
  char* GridName;

  vtkXdmfReaderInternal* Internals;

  int Stride[3];
  int OutputsInitialized;

  int GridsModified;

  void UpdateGrids();

  int NumberOfEnabledActualGrids;
  
  vtkMultiProcessController *Controller;
  
private:
  vtkXdmfReader(const vtkXdmfReader&); // Not implemented
  void operator=(const vtkXdmfReader&); // Not implemented  
};

#endif //__vtkXdmfReader_h

---