vtkAMRResampleFilter.h

Go to the documentation of this file.

/*=========================================================================
 
 Program:   Visualization Toolkit
 Module:    vtkAMRResampleFilter.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 vtkAMRResampleFilter_h
#define vtkAMRResampleFilter_h
 
#include "vtkFiltersAMRModule.h" // For export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
#include <vector> // For STL vector
 
class vtkInformation;
class vtkInformationVector;
class vtkUniformGrid;
class vtkOverlappingAMR;
class vtkMultiBlockDataSet;
class vtkMultiProcessController;
class vtkFieldData;
class vtkCellData;
class vtkPointData;
class vtkIndent;
 
class vtkAMRBox;
class VTKFILTERSAMR_EXPORT vtkAMRResampleFilter : public vtkMultiBlockDataSetAlgorithm
{
public:
  static vtkAMRResampleFilter *New();
  vtkTypeMacro(vtkAMRResampleFilter,vtkMultiBlockDataSetAlgorithm);
  void PrintSelf(ostream &oss, vtkIndent indent);
 
 
  vtkSetVector3Macro(NumberOfSamples,int);
  vtkGetVector3Macro(NumberOfSamples,int);
 
 
  vtkSetMacro(TransferToNodes,int);
  vtkGetMacro(TransferToNodes,int);
 
 
  vtkSetMacro(DemandDrivenMode,int);
  vtkGetMacro(DemandDrivenMode,int);
 
 
  vtkSetMacro(NumberOfPartitions,int);
  vtkGetMacro(NumberOfPartitions,int);
 
 
  vtkSetVector3Macro(Min,double);
  vtkGetVector3Macro(Min,double);
 
 
  vtkSetVector3Macro(Max,double);
  vtkGetVector3Macro(Max,double);
 
 
  vtkSetMacro(UseBiasVector,bool);
  vtkGetMacro(UseBiasVector,bool);
 
 
  vtkSetVector3Macro(BiasVector,double);
  vtkGetVector3Macro(BiasVector,double);
 
 
  vtkSetMacro(Controller, vtkMultiProcessController*);
  vtkGetMacro(Controller, vtkMultiProcessController*);
 
  // Standard pipeline routines
 
 
  virtual int RequestInformation(
      vtkInformation *rqst,
      vtkInformationVector **inputVector,
      vtkInformationVector *outputVector );
 
  virtual int RequestData(
       vtkInformation*,vtkInformationVector**,vtkInformationVector*);
  virtual int FillInputPortInformation(int port, vtkInformation *info);
  virtual int FillOutputPortInformation(int port, vtkInformation *info);
 
 
  virtual int RequestUpdateExtent(
      vtkInformation*, vtkInformationVector**, vtkInformationVector* );
 
 
protected:
  vtkAMRResampleFilter();
  virtual ~vtkAMRResampleFilter();
 
  vtkOverlappingAMR *AMRMetaData;
  vtkMultiBlockDataSet *ROI; // Pointer to the region of interest.
  int NumberOfSamples[3];
  int GridNumberOfSamples[3];
  double Min[3];
  double Max[3];
  double GridMin[3];
  double GridMax[3];
  int LevelOfResolution;
  int NumberOfPartitions;
  int TransferToNodes;
  int DemandDrivenMode;
  vtkMultiProcessController *Controller;
  bool UseBiasVector;
  double BiasVector[3];
 
  // Debugging Stuff
  int NumberOfBlocksTestedForLevel;
  int NumberOfBlocksTested;
  int NumberOfBlocksVisSkipped;
  int NumberOfTimesFoundOnDonorLevel;
  int NumberOfTimesLevelUp;
  int NumberOfTimesLevelDown;
  int NumberOfFailedPoints;
  double AverageLevel;
// BTX
  std::vector< int > BlocksToLoad; // Holds the ids of the blocks to load.
// ETX
 
  bool IsParallel();
 
  bool IsRegionMine( const int regionIdx );
 
  int GetRegionProcessId( const int regionIdx );
 
 
  void ComputeCellCentroid(
      vtkUniformGrid *g, const vtkIdType cellIdx, double c[3] );
 
  void InitializeFields( vtkFieldData *f, vtkIdType size, vtkCellData *src );
 
 
  void CopyData( vtkFieldData *target, vtkIdType targetIdx,
                 vtkCellData *src, vtkIdType srcIdx );
 
  bool FoundDonor(double q[3],vtkUniformGrid *&donorGrid,int &cellIdx);
 
 
 
  bool SearchForDonorGridAtLevel(
      double q[3], vtkOverlappingAMR *amrds,
      unsigned int level, unsigned int& gridId,
      int &donorCellIdx);
 
 
  int ProbeGridPointInAMR(
    double q[3], unsigned int &donorLevel, unsigned int& donorGridId,
      vtkOverlappingAMR *amrds, unsigned int maxLevel, bool useCached);
 
 
  int ProbeGridPointInAMRGraph(double q[3],
                               unsigned int &donorLevel,  unsigned int &donorGridId,
                               vtkOverlappingAMR *amrds, unsigned int maxLevel, bool useCached);
 
 
  void TransferToCellCenters(
      vtkUniformGrid *g, vtkOverlappingAMR *amrds );
 
 
  void TransferToGridNodes(
      vtkUniformGrid *g, vtkOverlappingAMR *amrds );
 
 
  void TransferSolution(
      vtkUniformGrid *g, vtkOverlappingAMR *amrds);
 
 
  void ExtractRegion(
      vtkOverlappingAMR *amrds, vtkMultiBlockDataSet *mbds,
      vtkOverlappingAMR *metadata );
 
  bool IsBlockWithinBounds( double *grd );
 
  void ComputeAMRBlocksToLoad( vtkOverlappingAMR *metadata );
 
 
  void ComputeRegionParameters(
      vtkOverlappingAMR *amrds,
      int N[3], double min[3], double max[3], double h[3] );
 
 
  void GetDomainParameters(
      vtkOverlappingAMR *amr,
      double domainMin[3], double domainMax[3], double h[3],
      int dims[3], double &rf );
 
 
  bool RegionIntersectsWithAMR(
      double domainMin[3], double domainMax[3],
      double regionMin[3], double regionMax[3] );
 
 
  void AdjustNumberOfSamplesInRegion(const double Rh[3],
      const bool outside[6], int N[3] );
 
 
  void ComputeLevelOfResolution(
      const int N[3], const double h0[3], const double L[3], const double rf);
 
 
  void SnapBounds(
    const double h0[3], const double domainMin[3], const double domainMax[3],
    const int dims[3], bool outside[6] );
 
 
  void ComputeAndAdjustRegionParameters(
      vtkOverlappingAMR *amrds, double h[3] );
 
  void GetRegion( double h[3] );
 
  bool GridsIntersect( double *g1, double *g2 );
 
  vtkUniformGrid* GetReferenceGrid( vtkOverlappingAMR *amrds );
 
  void SearchGridDecendants(double q[3],
                            vtkOverlappingAMR *amrds,
                            unsigned int maxLevel,
                            unsigned int &level,
                            unsigned int &gridId,
                            int &id);
 
 
  bool SearchGridAncestors(double q[3],
                           vtkOverlappingAMR *amrds,
                           unsigned int &level,
                           unsigned int &gridId,
                           int &id);
 
 
private:
  vtkAMRResampleFilter(const vtkAMRResampleFilter&); // Not implemented
  void operator=(const vtkAMRResampleFilter&); // Not implemented
 
};
 
#endif /* vtkAMRResampleFilter_h */