/Users/kitware/Dashboards/MyTests/VTK_BLD_Release_docs/Utilities/Doxygen/dox/Common/DataModel/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 "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
#include "vtkStructuredData.h" // For VTK_XYZ_GRID definition

class VTKCOMMONDATAMODEL_EXPORT vtkAMRBox
{
 public:
  vtkAMRBox();

  vtkAMRBox(const vtkAMRBox &other);


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


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


  vtkAMRBox(const double* origin, const int* dimensions, const double* spacing,
            const double* globalOrigin, int gridDescription=VTK_XYZ_GRID);

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

  vtkAMRBox(const int dims[6]);


  vtkAMRBox &operator=(const vtkAMRBox &other);

  virtual ~vtkAMRBox(){}


  void Invalidate()
  {
    this->LoCorner[0]=this->LoCorner[1]=this->LoCorner[2]=0;
    this->HiCorner[0]=this->HiCorner[1]=this->HiCorner[2]=-2;
  }

  bool EmptyDimension(int i) const{ return HiCorner[i]<=LoCorner[i]-1;}


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

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

  void SetDimensions(const int dims[6], int desc = VTK_XYZ_GRID);

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

  void GetDimensions(int dims[6]) const;


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


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

  int ComputeDimension() const;


  const int *GetLoCorner() const { return this->LoCorner; }
  const int *GetHiCorner() const { return this->HiCorner; }

  void GetValidHiCorner(int hi[3]) const;

  bool Empty() const
   {return this->IsInvalid();}


  bool IsInvalid() const
  {
    return ((this->HiCorner[0] < this->LoCorner[0]-1) ||
            (this->HiCorner[1] < this->LoCorner[1]-1) ||
            (this->HiCorner[2] < this->LoCorner[2]-1));
  }

  bool operator==(const vtkAMRBox &other) const;


  bool operator!=(const vtkAMRBox &other) const
    { return( !(*this == other) ); }

  ostream &Print(ostream &os) const;


  void Serialize( unsigned char*& buffer, vtkIdType &bytesize );
  void Serialize(int* buffer) const;

  void Deserialize( unsigned char* buffer, const vtkIdType &bytesize );

  bool DoesBoxIntersectAlongDimension(const vtkAMRBox &other, const int q) const;

  bool DoesIntersect(const vtkAMRBox &other) const;

  void Coarsen(int r);

  void Refine(int r);


  void Grow(int byN);
  void Shrink(int byN);


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

  bool Intersect(const vtkAMRBox &other);


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

  bool Contains(const vtkAMRBox&) const;

  void GetGhostVector(int r, int nghost[6]) const;

  void RemoveGhosts(int r);

 public:
  static vtkIdType GetBytesize(){return 6*sizeof(int); };

  static int GetCellLinearIndex(const vtkAMRBox& box, const int i, const int j, const int k, int imageDimension[3] );

  static void GetBounds(const vtkAMRBox& box, const double origin[3], const double spacing[3],double bounds[6]) ;

  static void GetBoxOrigin(const vtkAMRBox& box, const double X0[3], const double spacing[3],double x0[3]);

  static bool HasPoint(const vtkAMRBox& box, const double origin[3], const double spacing[3], double x, double y,  double z );


  static int ComputeStructuredCoordinates(const vtkAMRBox& box, const double dataOrigin[3],
                                          const double h[3], const double x[3],  int ijk[3],  double pcoords[3]);

 protected:
  void Initialize( );

  bool IntersectBoxAlongDimension(const vtkAMRBox &other, const int q);

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


  void BuildAMRBox(
      const int ilo, const int jlo, const int klo,
      const int ihi, const int jhi, const int khi );
};


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

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];
  ofs[0]=-arrayRegion.GetLoCorner()[0];
  ofs[1]=-arrayRegion.GetLoCorner()[1];
  ofs[2]=-arrayRegion.GetLoCorner()[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.
  const int* destLo = destDims.GetLoCorner();
  int destHi[3];
  destDims.GetValidHiCorner(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;
        }
      }
    }

}

#endif
// VTK-HeaderTest-Exclude: vtkAMRBox.h