dox/Filtering/vtkAMRBox.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkAMRBox.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 __vtkAMRBox_h
#define __vtkAMRBox_h

#include "vtkObject.h"
#include "vtkType.h" //For utility functions.
#include <vtkstd/vector> // STL Header

class VTK_FILTERING_EXPORT vtkAMRBox
{
public:
  vtkAMRBox(int dim=3);


  vtkAMRBox(
      int ilo,int jlo,int klo,
      int ihi,int jhi,int khi);


  vtkAMRBox(
      int ilo,int jlo,
      int ihi,int jhi);


  vtkAMRBox(int dim, const int lo[3], const int hi[3]);
  vtkAMRBox(const int lo[3], const int hi[3]);


  vtkAMRBox(int dim, const int dims[6]);
  vtkAMRBox(const int dims[6]);

  vtkAMRBox(const vtkAMRBox &other);

  vtkAMRBox &operator=(const vtkAMRBox &other);

  void Invalidate();


  int GetDimensionality() const { return this->Dimension; }
  void SetDimensionality(int dim);


  void SetDimensions(
      int ilo, int jlo, int klo,
      int ihi, int jhi, int khi);

  void SetDimensions(const int lo[3], const int hi[3]);

  void SetDimensions(const int dims[6]);

  void GetDimensions(int lo[3], int hi[3]) const;

  void GetDimensions(int dims[6]) const;


  void GetLoCorner(int lo[3]) const;
  const int *GetLoCorner() const { return this->LoCorner; }


  void GetHiCorner(int hi[3]) const;
  const int *GetHiCorner() const { return this->HiCorner; }


  void GetNumberOfCells(int ext[3]) const;
  vtkIdType GetNumberOfCells() const;


  void GetNumberOfNodes(int ext[3]) const;
  vtkIdType GetNumberOfNodes() const;


  const double *GetGridSpacing() const { return this->DX; }
  void GetGridSpacing(double dX[3]) const;
  void SetGridSpacing(double dx);
  void SetGridSpacing(const double dX[3]);
  void SetGridSpacing(double dx, double dy, double dz);


  const double *GetDataSetOrigin() const { return this->X0; }
  void GetDataSetOrigin(double X0[3]) const;
  void SetDataSetOrigin(const double X0[3]);
  void SetDataSetOrigin(double x0, double y0, double z0);

  void GetBoxOrigin(double x0[3]) const;

  void Grow(int byN);

  void Shrink(int byN);


  void Shift(int i, int j);
  void Shift(int i, int j, int k);
  void Shift(const int I[3]);

  bool Empty() const;

  bool operator==(const vtkAMRBox &other);

  void operator&=(const vtkAMRBox &rhs);


  bool Contains(int i,int j,int k) const;
  bool Contains(const int I[3]) const;

  bool Contains(const vtkAMRBox &other) const;

  void Refine(int r);

  void Coarsen(int r);

  ostream &Print(ostream &os) const;

  //BTX
  // @deprecated Replaced by Contains() as of VTK 5.4.
  // Do not use! See Contains().
  VTK_LEGACY(int DoesContainCell(int i, int j, int k));
  // @deprecated Replaced by Contains() as of VTK 5.4.
  // Do not use! See Contains().
  VTK_LEGACY(int DoesContainBox(vtkAMRBox const & box) const);
  //ETX

public:

  int LoCorner[3]; // lo corner cell id.
  int HiCorner[3]; // hi corner cell id.

private:
  int Dimension;         // 2 or 3.
  double X0[3];          // Dataset origin (not box origin). low corner cell's, low corner node.
  double DX[3];          // grid spacing.
};

// NOTE 2008-11-10
// Favor the set'ers above to this helper, where ever possible.
// Helper to unroll the loop
template<int dimension>
struct vtkAMRBoxInitializeHelp;
template<int dimension>
void vtkAMRBoxInitialize(
        int *LoCorner,
        int *HiCorner, // member
        const int *loCorner,
        const int *hiCorner, // local
        vtkAMRBoxInitializeHelp<dimension>* = 0) // dummy parameter for vs6
  {
  for(int i=0; i<dimension; ++i)
    {
    LoCorner[i] = loCorner[i];
    HiCorner[i] = hiCorner[i];
    }
  for(int i=dimension; i<(3-dimension); ++i)
    {
    LoCorner[i] = 0;
    HiCorner[i] = 0;
    }
  }

//*****************************************************************************

template <typename T>
void FillRegion(
        T *pArray,
        const vtkAMRBox &arrayRegion,
        const vtkAMRBox &destRegion,
        T fillValue)
{
  // Convert regions to array index space. VTK arrays
  // always start with 0,0,0.
  int ofs[3];
  arrayRegion.GetLoCorner(ofs);
  ofs[0]=-ofs[0];
  ofs[1]=-ofs[1];
  ofs[2]=-ofs[2];
  vtkAMRBox arrayDims(arrayRegion);
  arrayDims.Shift(ofs);
  vtkAMRBox destDims(destRegion);
  destDims.Shift(ofs);
  // Quick sanity check.
  if (!arrayRegion.Contains(destRegion))
    {
    vtkGenericWarningMacro(
         << "ERROR: Array must enclose the destination region. "
         << "Aborting the fill.");
    }
  // Get the bounds of the indices we fill.
  int destLo[3];
  destDims.GetLoCorner(destLo);
  int destHi[3];
  destDims.GetHiCorner(destHi);
  // Get the array dimensions.
  int arrayHi[3];
  arrayDims.GetNumberOfCells(arrayHi);
  // Fill.
  for (int k=destLo[2]; k<=destHi[2]; ++k)
    {
    vtkIdType kOfs=k*arrayHi[0]*arrayHi[1];
    for (int j=destLo[1]; j<=destHi[1]; ++j) 
      {
      vtkIdType idx=kOfs+j*arrayHi[0]+destLo[0];
      for (int i=destLo[0]; i<=destHi[0]; ++i)
        {
        pArray[idx]=fillValue;
        ++idx;
        }
      }
    }
}

void Split(const int N[3], const int minSide[3], vtkstd::vector<vtkAMRBox> &decomp);

void Split(const int minSide[3], vtkstd::vector<vtkAMRBox> &decomp);

#endif

---