vtkAMRBox.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkAMRBox_h
#define vtkAMRBox_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
#include "vtkStructuredData.h" // For vtkStructuredData::VTK_STRUCTURED_XYZ_GRID definition
 
VTK_ABI_NAMESPACE_BEGIN
class vtkUniformGrid;
class VTKCOMMONDATAMODEL_EXPORT vtkAMRBox
{
public:
  vtkAMRBox();

  vtkAMRBox(const vtkAMRBox& other);

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

  vtkAMRBox(const double* origin, const int* dimensions, const double* spacing,
    const double* globalOrigin, int gridDescription = vtkStructuredData::VTK_STRUCTURED_XYZ_GRID);

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

  vtkAMRBox& operator=(const vtkAMRBox& other);
 
  virtual ~vtkAMRBox() = default;


  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 = vtkStructuredData::VTK_STRUCTURED_XYZ_GRID);

  void SetDimensions(
    const int lo[3], const int hi[3], int desc = vtkStructuredData::VTK_STRUCTURED_XYZ_GRID);

  void SetDimensions(const int dims[6], int desc = vtkStructuredData::VTK_STRUCTURED_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, 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]);


  void Add(int i, int j, int k);
  void Add(const int ijk[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);

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

  static int GetCellLinearIndex(const vtkAMRBox& box, int i, int j, 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]);

  int InitializeGrid(vtkUniformGrid* grid, double* origin, double* spacing) const;

  int InitializeGrid(vtkUniformGrid* grid, double* origin, double* spacing, int nGhosts) const;

  int InitializeGrid(
    vtkUniformGrid* grid, double* origin, double* spacing, const int nGhosts[3]) const;

  int InitializeGrid(vtkUniformGrid* grid, double* origin, double* spacing, int nGhostsI,
    int nGhostsJ, int nGhostsK) const;
 
protected:
  void Initialize();

  bool IntersectBoxAlongDimension(const vtkAMRBox& other, int q);
 
private:
  int LoCorner[3]; // lo corner cell id.
  int HiCorner[3]; // hi corner cell id.


  void BuildAMRBox(int ilo, int jlo, int klo, int ihi, int jhi, 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;
      }
    }
  }
}
 
VTK_ABI_NAMESPACE_END
#endif
// VTK-HeaderTest-Exclude: vtkAMRBox.h