// python wrapper for vtkHyperOctree
//
#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include "vtkPythonArgs.h"
#include "vtkPythonOverload.h"
#include "vtkConfigure.h"
#include <cstddef>
#include <sstream>
#include "vtkVariant.h"
#include "vtkIndent.h"
#include "vtkHyperOctree.h"

extern "C" { VTK_ABI_EXPORT void PyVTKAddFile_vtkHyperOctree(PyObject *); }
extern "C" { VTK_ABI_EXPORT PyObject *PyvtkHyperOctree_ClassNew(); }

#ifndef DECLARED_PyvtkDataSet_ClassNew
extern "C" { PyObject *PyvtkDataSet_ClassNew(); }
#define DECLARED_PyvtkDataSet_ClassNew
#endif

static const char *PyvtkHyperOctree_Doc =
  "vtkHyperOctree - A dataset structured as a tree where each node has\nexactly 2^n children.\n\n"
  "Superclass: vtkDataSet\n\n"
  "An hyperoctree is a dataset where each node has either exactly 2^n\n"
  "children or no child at all if the node is a leaf. `n' is the\n"
  "dimension of the dataset (1 (binary tree), 2 (quadtree) or 3 (octree)\n"
  "). The class name comes from the following paper:\n\n\n"
  " @ARTICLE{yau-srihari-1983,\n"
  "  author={Mann-May Yau and Sargur N. Srihari},\n"
  "  title={A Hierarchical Data Structure for Multidimensional Digital Images},\n"
  "  journal={Communications of the ACM},\n"
  "  month={July},\n"
  "  year={1983},\n"
  "  volume={26},\n"
  "  number={7},\n"
  "  pages={504--515}\n"
  "  }\n"
  " \n\n"
  "Each node is a cell. Attributes are associated with cells, not with\n"
  "points. The geometry is implicitly given by the size of the root node\n"
  "on each axis and position of the center and the orientation. (TODO:\n"
  "review center position and orientation). The geometry is then not\n"
  "limited to an hybercube but can have a rectangular shape. Attributes\n"
  "are associated with leaves. For LOD (Level-Of-Detail) purpose,\n"
  "attributes can be computed on none-leaf nodes by computing the\n"
  "average values from its children (which can be leaves or not).\n\n"
  "By construction, an hyperoctree is efficient in memory usage when the\n"
  "geometry is sparse. The LOD feature allows to cull quickly part of\n"
  "the dataset.\n\n"
  "A couple of filters can be applied on this dataset: contour, outline,\n"
  "geometry.\n\n"
  "* 3D case (octree) for each node, each child index (from 0 to 7) is\n"
  "  encoded in the following orientation. It is easy to access each\n"
  "  child as a cell of a grid. Note also that the binary representation\n"
  "is relevant, each bit code a side: bit 0 encodes -x side (0) or +x\n"
  "  side (1) bit 1 encodes -y side (0) or +y side (1) bit 2 encodes -z\n"
  "  side (0) or +z side (2)\n"
  "- the -z side first\n"
  "- 0: -y -x sides\n"
  "- 1: -y +x sides\n"
  "- 2: +y -x sides\n"
  "- 3: +y +x sides\n"
  "              +y\n"
  " +-+-+        ^\n"
  " |2|3|        |\n"
  " +-+-+  O +z  +-> +x\n"
  " |0|1|\n"
  " +-+-+\n"
  " \n\n"
  "- then the +z side, in counter-clockwise\n"
  "- 4: -y -x sides\n"
  "- 5: -y +x sides\n"
  "- 6: +y -x sides\n"
  "- 7: +y +x sides\n"
  "              +y\n"
  " +-+-+        ^\n"
  " |6|7|        |\n"
  " +-+-+  O +z  +-> +x\n"
  " |4|5|\n"
  " +-+-+\n"
  " \n\n"
  "The cases with fewer dimensions are consistent with the octree case:\n\n"
  "* Quadtree: in counter-clockwise\n"
  "- 0: -y -x edges\n"
  "- 1: -y +x edges\n"
  "- 2: +y -x edges\n"
  "- 3: +y +x edges\n"
  "         +y\n"
  " +-+-+   ^\n"
  " |2|3|   |\n"
  " +-+-+  O+-> +x\n"
  " |0|1|\n"
  " +-+-+\n"
  " \n\n"
  "* Binary tree:\n"
  " +0+1+  O+-> +x\n"
  " \n\n"
  "@warning\n"
  "It is not a spatial search object! If you looking for this kind of\n"
  "octree see vtkCellLocator instead.\n\n"
  "@sa\n"
  "vtkHyperOctreeAlgorithm\n\n";


static PyObject *
PyvtkHyperOctree_LEVELS(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "LEVELS");

  PyObject *result = nullptr;

  if (ap.CheckArgCount(0))
  {
    vtkInformationIntegerKey *tempr = vtkHyperOctree::LEVELS();

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_DIMENSION(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "DIMENSION");

  PyObject *result = nullptr;

  if (ap.CheckArgCount(0))
  {
    vtkInformationIntegerKey *tempr = vtkHyperOctree::DIMENSION();

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_SIZES(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "SIZES");

  PyObject *result = nullptr;

  if (ap.CheckArgCount(0))
  {
    vtkInformationDoubleVectorKey *tempr = vtkHyperOctree::SIZES();

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_IsTypeOf(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "IsTypeOf");

  char *temp0 = nullptr;
  PyObject *result = nullptr;

  if (ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    int tempr = vtkHyperOctree::IsTypeOf(temp0);

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_IsA(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "IsA");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  char *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    int tempr = (ap.IsBound() ?
      op->IsA(temp0) :
      op->vtkHyperOctree::IsA(temp0));

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_SafeDownCast(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "SafeDownCast");

  vtkObjectBase *temp0 = nullptr;
  PyObject *result = nullptr;

  if (ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkObjectBase"))
  {
    vtkHyperOctree *tempr = vtkHyperOctree::SafeDownCast(temp0);

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_NewInstance(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "NewInstance");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkHyperOctree *tempr = (ap.IsBound() ?
      op->NewInstance() :
      op->vtkHyperOctree::NewInstance());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
      if (result && PyVTKObject_Check(result))
      {
        PyVTKObject_GetObject(result)->UnRegister(0);
        PyVTKObject_SetFlag(result, VTK_PYTHON_IGNORE_UNREGISTER, 1);
      }
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetDataObjectType(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetDataObjectType");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    int tempr = (ap.IsBound() ?
      op->GetDataObjectType() :
      op->vtkHyperOctree::GetDataObjectType());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_CopyStructure(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "CopyStructure");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkDataSet *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkDataSet"))
  {
    if (ap.IsBound())
    {
      op->CopyStructure(temp0);
    }
    else
    {
      op->vtkHyperOctree::CopyStructure(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetDimension(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetDimension");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    int tempr = (ap.IsBound() ?
      op->GetDimension() :
      op->vtkHyperOctree::GetDimension());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_SetDimension(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetDimension");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  int temp0;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    if (ap.IsBound())
    {
      op->SetDimension(temp0);
    }
    else
    {
      op->vtkHyperOctree::SetDimension(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetNumberOfCells(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetNumberOfCells");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkIdType tempr = (ap.IsBound() ?
      op->GetNumberOfCells() :
      op->vtkHyperOctree::GetNumberOfCells());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetNumberOfLeaves(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetNumberOfLeaves");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkIdType tempr = (ap.IsBound() ?
      op->GetNumberOfLeaves() :
      op->vtkHyperOctree::GetNumberOfLeaves());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetNumberOfPoints(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetNumberOfPoints");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkIdType tempr = (ap.IsBound() ?
      op->GetNumberOfPoints() :
      op->vtkHyperOctree::GetNumberOfPoints());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetMaxNumberOfPoints(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetMaxNumberOfPoints");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  int temp0;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    vtkIdType tempr = (ap.IsBound() ?
      op->GetMaxNumberOfPoints(temp0) :
      op->vtkHyperOctree::GetMaxNumberOfPoints(temp0));

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetMaxNumberOfPointsOnBoundary(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetMaxNumberOfPointsOnBoundary");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  int temp0;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    vtkIdType tempr = (ap.IsBound() ?
      op->GetMaxNumberOfPointsOnBoundary(temp0) :
      op->vtkHyperOctree::GetMaxNumberOfPointsOnBoundary(temp0));

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetMaxNumberOfCellsOnBoundary(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetMaxNumberOfCellsOnBoundary");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  int temp0;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    vtkIdType tempr = (ap.IsBound() ?
      op->GetMaxNumberOfCellsOnBoundary(temp0) :
      op->vtkHyperOctree::GetMaxNumberOfCellsOnBoundary(temp0));

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetNumberOfLevels(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetNumberOfLevels");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkIdType tempr = (ap.IsBound() ?
      op->GetNumberOfLevels() :
      op->vtkHyperOctree::GetNumberOfLevels());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_SetSize_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSize");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  double temp0;
  double temp1;
  double temp2;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(3) &&
      ap.GetValue(temp0) &&
      ap.GetValue(temp1) &&
      ap.GetValue(temp2))
  {
    if (ap.IsBound())
    {
      op->SetSize(temp0, temp1, temp2);
    }
    else
    {
      op->vtkHyperOctree::SetSize(temp0, temp1, temp2);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_SetSize_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSize");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  const int size0 = 3;
  double temp0[3];
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetArray(temp0, size0))
  {
    if (ap.IsBound())
    {
      op->SetSize(temp0);
    }
    else
    {
      op->vtkHyperOctree::SetSize(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_SetSize(PyObject *self, PyObject *args)
{
  int nargs = vtkPythonArgs::GetArgCount(self, args);

  switch(nargs)
  {
    case 3:
      return PyvtkHyperOctree_SetSize_s1(self, args);
    case 1:
      return PyvtkHyperOctree_SetSize_s2(self, args);
  }

  vtkPythonArgs::ArgCountError(nargs, "SetSize");
  return nullptr;
}



static PyObject *
PyvtkHyperOctree_GetSize(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSize");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  int sizer = 3;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    double *tempr = (ap.IsBound() ?
      op->GetSize() :
      op->vtkHyperOctree::GetSize());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildTuple(tempr, sizer);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_SetOrigin_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetOrigin");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  double temp0;
  double temp1;
  double temp2;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(3) &&
      ap.GetValue(temp0) &&
      ap.GetValue(temp1) &&
      ap.GetValue(temp2))
  {
    if (ap.IsBound())
    {
      op->SetOrigin(temp0, temp1, temp2);
    }
    else
    {
      op->vtkHyperOctree::SetOrigin(temp0, temp1, temp2);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_SetOrigin_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetOrigin");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  const int size0 = 3;
  double temp0[3];
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetArray(temp0, size0))
  {
    if (ap.IsBound())
    {
      op->SetOrigin(temp0);
    }
    else
    {
      op->vtkHyperOctree::SetOrigin(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_SetOrigin(PyObject *self, PyObject *args)
{
  int nargs = vtkPythonArgs::GetArgCount(self, args);

  switch(nargs)
  {
    case 3:
      return PyvtkHyperOctree_SetOrigin_s1(self, args);
    case 1:
      return PyvtkHyperOctree_SetOrigin_s2(self, args);
  }

  vtkPythonArgs::ArgCountError(nargs, "SetOrigin");
  return nullptr;
}



static PyObject *
PyvtkHyperOctree_GetOrigin(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetOrigin");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  int sizer = 3;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    double *tempr = (ap.IsBound() ?
      op->GetOrigin() :
      op->vtkHyperOctree::GetOrigin());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildTuple(tempr, sizer);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_NewCellCursor(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "NewCellCursor");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkHyperOctreeCursor *tempr = (ap.IsBound() ?
      op->NewCellCursor() :
      op->vtkHyperOctree::NewCellCursor());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_SubdivideLeaf(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SubdivideLeaf");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkHyperOctreeCursor *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkHyperOctreeCursor"))
  {
    if (ap.IsBound())
    {
      op->SubdivideLeaf(temp0);
    }
    else
    {
      op->vtkHyperOctree::SubdivideLeaf(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_CollapseTerminalNode(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "CollapseTerminalNode");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkHyperOctreeCursor *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkHyperOctreeCursor"))
  {
    if (ap.IsBound())
    {
      op->CollapseTerminalNode(temp0);
    }
    else
    {
      op->vtkHyperOctree::CollapseTerminalNode(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetPoint_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetPoint");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkIdType temp0;
  int sizer = 3;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    double *tempr = (ap.IsBound() ?
      op->GetPoint(temp0) :
      op->vtkHyperOctree::GetPoint(temp0));

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildTuple(tempr, sizer);
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_GetPoint_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetPoint");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkIdType temp0;
  const int size1 = 3;
  double temp1[3];
  double save1[3];
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(2) &&
      ap.GetValue(temp0) &&
      ap.GetArray(temp1, size1))
  {
    ap.SaveArray(temp1, save1, size1);

    if (ap.IsBound())
    {
      op->GetPoint(temp0, temp1);
    }
    else
    {
      op->vtkHyperOctree::GetPoint(temp0, temp1);
    }

    if (ap.ArrayHasChanged(temp1, save1, size1) &&
        !ap.ErrorOccurred())
    {
      ap.SetArray(1, temp1, size1);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_GetPoint(PyObject *self, PyObject *args)
{
  int nargs = vtkPythonArgs::GetArgCount(self, args);

  switch(nargs)
  {
    case 1:
      return PyvtkHyperOctree_GetPoint_s1(self, args);
    case 2:
      return PyvtkHyperOctree_GetPoint_s2(self, args);
  }

  vtkPythonArgs::ArgCountError(nargs, "GetPoint");
  return nullptr;
}



static PyObject *
PyvtkHyperOctree_GetCell_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetCell");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkIdType temp0;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    vtkCell *tempr = (ap.IsBound() ?
      op->GetCell(temp0) :
      op->vtkHyperOctree::GetCell(temp0));

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_GetCell_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetCell");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkIdType temp0;
  vtkGenericCell *temp1 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(2) &&
      ap.GetValue(temp0) &&
      ap.GetVTKObject(temp1, "vtkGenericCell"))
  {
    if (ap.IsBound())
    {
      op->GetCell(temp0, temp1);
    }
    else
    {
      op->vtkHyperOctree::GetCell(temp0, temp1);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_GetCell_s3(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetCell");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  int temp0;
  int temp1;
  int temp2;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(3) &&
      ap.GetValue(temp0) &&
      ap.GetValue(temp1) &&
      ap.GetValue(temp2))
  {
    vtkCell *tempr = (ap.IsBound() ?
      op->GetCell(temp0, temp1, temp2) :
      op->vtkHyperOctree::GetCell(temp0, temp1, temp2));

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_GetCell(PyObject *self, PyObject *args)
{
  int nargs = vtkPythonArgs::GetArgCount(self, args);

  switch(nargs)
  {
    case 1:
      return PyvtkHyperOctree_GetCell_s1(self, args);
    case 2:
      return PyvtkHyperOctree_GetCell_s2(self, args);
    case 3:
      return PyvtkHyperOctree_GetCell_s3(self, args);
  }

  vtkPythonArgs::ArgCountError(nargs, "GetCell");
  return nullptr;
}



static PyObject *
PyvtkHyperOctree_GetCellType(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetCellType");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkIdType temp0;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    int tempr = (ap.IsBound() ?
      op->GetCellType(temp0) :
      op->vtkHyperOctree::GetCellType(temp0));

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetCellPoints_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetCellPoints");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkIdType temp0;
  vtkIdList *temp1 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(2) &&
      ap.GetValue(temp0) &&
      ap.GetVTKObject(temp1, "vtkIdList"))
  {
    if (ap.IsBound())
    {
      op->GetCellPoints(temp0, temp1);
    }
    else
    {
      op->vtkHyperOctree::GetCellPoints(temp0, temp1);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_GetCellPoints_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetCellPoints");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkIdType temp0;
  vtkIdType temp1;
  int size2 = ap.GetArgSize(2);
  vtkPythonArgs::Array<vtkIdType> store2(2*size2);
  vtkIdType *temp2 = store2.Data();
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(3) &&
      ap.GetValue(temp0) &&
      ap.GetValue(temp1) &&
      ap.GetArray(temp2, size2))
  {
    if (ap.IsBound())
    {
      op->GetCellPoints(temp0, temp1, temp2);
    }
    else
    {
      op->vtkHyperOctree::GetCellPoints(temp0, temp1, temp2);
    }

    if (!ap.ErrorOccurred())
    {
      ap.SetArgValue(1, temp1);
    }
    if (!ap.ErrorOccurred())
    {
      ap.SetArgValue(2, temp2, size2);
    }
    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_GetCellPoints(PyObject *self, PyObject *args)
{
  int nargs = vtkPythonArgs::GetArgCount(self, args);

  switch(nargs)
  {
    case 2:
      return PyvtkHyperOctree_GetCellPoints_s1(self, args);
    case 3:
      return PyvtkHyperOctree_GetCellPoints_s2(self, args);
  }

  vtkPythonArgs::ArgCountError(nargs, "GetCellPoints");
  return nullptr;
}



static PyObject *
PyvtkHyperOctree_GetPointCells(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetPointCells");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkIdType temp0;
  vtkIdList *temp1 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(2) &&
      ap.GetValue(temp0) &&
      ap.GetVTKObject(temp1, "vtkIdList"))
  {
    if (ap.IsBound())
    {
      op->GetPointCells(temp0, temp1);
    }
    else
    {
      op->vtkHyperOctree::GetPointCells(temp0, temp1);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetCellNeighbors(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetCellNeighbors");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkIdType temp0;
  vtkIdList *temp1 = nullptr;
  vtkIdList *temp2 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(3) &&
      ap.GetValue(temp0) &&
      ap.GetVTKObject(temp1, "vtkIdList") &&
      ap.GetVTKObject(temp2, "vtkIdList"))
  {
    if (ap.IsBound())
    {
      op->GetCellNeighbors(temp0, temp1, temp2);
    }
    else
    {
      op->vtkHyperOctree::GetCellNeighbors(temp0, temp1, temp2);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_FindPoint(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "FindPoint");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  const int size0 = 3;
  double temp0[3];
  double save0[3];
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetArray(temp0, size0))
  {
    ap.SaveArray(temp0, save0, size0);

    vtkIdType tempr = (ap.IsBound() ?
      op->FindPoint(temp0) :
      op->vtkHyperOctree::FindPoint(temp0));

    if (ap.ArrayHasChanged(temp0, save0, size0) &&
        !ap.ErrorOccurred())
    {
      ap.SetArray(0, temp0, size0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_FindCell_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "FindCell");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  const int size0 = 3;
  double temp0[3];
  double save0[3];
  vtkCell *temp1 = nullptr;
  vtkIdType temp2;
  double temp3;
  int temp4;
  const int size5 = 3;
  double temp5[3];
  double save5[3];
  int size6 = ap.GetArgSize(6);
  vtkPythonArgs::Array<double> store6(2*size6);
  double *temp6 = store6.Data();
  double *save6 = (size6 == 0 ? nullptr : temp6 + size6);
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(7) &&
      ap.GetArray(temp0, size0) &&
      ap.GetVTKObject(temp1, "vtkCell") &&
      ap.GetValue(temp2) &&
      ap.GetValue(temp3) &&
      ap.GetValue(temp4) &&
      ap.GetArray(temp5, size5) &&
      ap.GetArray(temp6, size6))
  {
    ap.SaveArray(temp0, save0, size0);
    ap.SaveArray(temp5, save5, size5);
    ap.SaveArray(temp6, save6, size6);

    vtkIdType tempr = (ap.IsBound() ?
      op->FindCell(temp0, temp1, temp2, temp3, temp4, temp5, temp6) :
      op->vtkHyperOctree::FindCell(temp0, temp1, temp2, temp3, temp4, temp5, temp6));

    if (ap.ArrayHasChanged(temp0, save0, size0) &&
        !ap.ErrorOccurred())
    {
      ap.SetArray(0, temp0, size0);
    }

    if (!ap.ErrorOccurred())
    {
      ap.SetArgValue(4, temp4);
    }
    if (ap.ArrayHasChanged(temp5, save5, size5) &&
        !ap.ErrorOccurred())
    {
      ap.SetArray(5, temp5, size5);
    }

    if (ap.ArrayHasChanged(temp6, save6, size6) &&
        !ap.ErrorOccurred())
    {
      ap.SetArray(6, temp6, size6);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_FindCell_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "FindCell");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  const int size0 = 3;
  double temp0[3];
  double save0[3];
  vtkCell *temp1 = nullptr;
  vtkGenericCell *temp2 = nullptr;
  vtkIdType temp3;
  double temp4;
  int temp5;
  const int size6 = 3;
  double temp6[3];
  double save6[3];
  int size7 = ap.GetArgSize(7);
  vtkPythonArgs::Array<double> store7(2*size7);
  double *temp7 = store7.Data();
  double *save7 = (size7 == 0 ? nullptr : temp7 + size7);
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(8) &&
      ap.GetArray(temp0, size0) &&
      ap.GetVTKObject(temp1, "vtkCell") &&
      ap.GetVTKObject(temp2, "vtkGenericCell") &&
      ap.GetValue(temp3) &&
      ap.GetValue(temp4) &&
      ap.GetValue(temp5) &&
      ap.GetArray(temp6, size6) &&
      ap.GetArray(temp7, size7))
  {
    ap.SaveArray(temp0, save0, size0);
    ap.SaveArray(temp6, save6, size6);
    ap.SaveArray(temp7, save7, size7);

    vtkIdType tempr = (ap.IsBound() ?
      op->FindCell(temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7) :
      op->vtkHyperOctree::FindCell(temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7));

    if (ap.ArrayHasChanged(temp0, save0, size0) &&
        !ap.ErrorOccurred())
    {
      ap.SetArray(0, temp0, size0);
    }

    if (!ap.ErrorOccurred())
    {
      ap.SetArgValue(5, temp5);
    }
    if (ap.ArrayHasChanged(temp6, save6, size6) &&
        !ap.ErrorOccurred())
    {
      ap.SetArray(6, temp6, size6);
    }

    if (ap.ArrayHasChanged(temp7, save7, size7) &&
        !ap.ErrorOccurred())
    {
      ap.SetArray(7, temp7, size7);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_FindCell(PyObject *self, PyObject *args)
{
  int nargs = vtkPythonArgs::GetArgCount(self, args);

  switch(nargs)
  {
    case 7:
      return PyvtkHyperOctree_FindCell_s1(self, args);
    case 8:
      return PyvtkHyperOctree_FindCell_s2(self, args);
  }

  vtkPythonArgs::ArgCountError(nargs, "FindCell");
  return nullptr;
}



static PyObject *
PyvtkHyperOctree_Initialize(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "Initialize");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    if (ap.IsBound())
    {
      op->Initialize();
    }
    else
    {
      op->vtkHyperOctree::Initialize();
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetMaxCellSize(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetMaxCellSize");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    int tempr = (ap.IsBound() ?
      op->GetMaxCellSize() :
      op->vtkHyperOctree::GetMaxCellSize());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_ShallowCopy(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ShallowCopy");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkDataObject *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkDataObject"))
  {
    if (ap.IsBound())
    {
      op->ShallowCopy(temp0);
    }
    else
    {
      op->vtkHyperOctree::ShallowCopy(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_DeepCopy(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "DeepCopy");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkDataObject *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkDataObject"))
  {
    if (ap.IsBound())
    {
      op->DeepCopy(temp0);
    }
    else
    {
      op->vtkHyperOctree::DeepCopy(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetPointsOnFace(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetPointsOnFace");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkHyperOctreeCursor *temp0 = nullptr;
  int temp1;
  int temp2;
  vtkHyperOctreePointsGrabber *temp3 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(4) &&
      ap.GetVTKObject(temp0, "vtkHyperOctreeCursor") &&
      ap.GetValue(temp1) &&
      ap.GetValue(temp2) &&
      ap.GetVTKObject(temp3, "vtkHyperOctreePointsGrabber"))
  {
    if (ap.IsBound())
    {
      op->GetPointsOnFace(temp0, temp1, temp2, temp3);
    }
    else
    {
      op->vtkHyperOctree::GetPointsOnFace(temp0, temp1, temp2, temp3);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetPointsOnParentFaces(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetPointsOnParentFaces");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  const int size0 = 3;
  int temp0[3];
  int save0[3];
  int temp1;
  vtkHyperOctreeCursor *temp2 = nullptr;
  vtkHyperOctreePointsGrabber *temp3 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(4) &&
      ap.GetArray(temp0, size0) &&
      ap.GetValue(temp1) &&
      ap.GetVTKObject(temp2, "vtkHyperOctreeCursor") &&
      ap.GetVTKObject(temp3, "vtkHyperOctreePointsGrabber"))
  {
    ap.SaveArray(temp0, save0, size0);

    if (ap.IsBound())
    {
      op->GetPointsOnParentFaces(temp0, temp1, temp2, temp3);
    }
    else
    {
      op->vtkHyperOctree::GetPointsOnParentFaces(temp0, temp1, temp2, temp3);
    }

    if (ap.ArrayHasChanged(temp0, save0, size0) &&
        !ap.ErrorOccurred())
    {
      ap.SetArray(0, temp0, size0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetPointsOnEdge(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetPointsOnEdge");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkHyperOctreeCursor *temp0 = nullptr;
  int temp1;
  int temp2;
  int temp3;
  int temp4;
  vtkHyperOctreePointsGrabber *temp5 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(6) &&
      ap.GetVTKObject(temp0, "vtkHyperOctreeCursor") &&
      ap.GetValue(temp1) &&
      ap.GetValue(temp2) &&
      ap.GetValue(temp3) &&
      ap.GetValue(temp4) &&
      ap.GetVTKObject(temp5, "vtkHyperOctreePointsGrabber"))
  {
    if (ap.IsBound())
    {
      op->GetPointsOnEdge(temp0, temp1, temp2, temp3, temp4, temp5);
    }
    else
    {
      op->vtkHyperOctree::GetPointsOnEdge(temp0, temp1, temp2, temp3, temp4, temp5);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetPointsOnParentEdge(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetPointsOnParentEdge");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkHyperOctreeCursor *temp0 = nullptr;
  int temp1;
  int temp2;
  int temp3;
  int temp4;
  vtkHyperOctreePointsGrabber *temp5 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(6) &&
      ap.GetVTKObject(temp0, "vtkHyperOctreeCursor") &&
      ap.GetValue(temp1) &&
      ap.GetValue(temp2) &&
      ap.GetValue(temp3) &&
      ap.GetValue(temp4) &&
      ap.GetVTKObject(temp5, "vtkHyperOctreePointsGrabber"))
  {
    if (ap.IsBound())
    {
      op->GetPointsOnParentEdge(temp0, temp1, temp2, temp3, temp4, temp5);
    }
    else
    {
      op->vtkHyperOctree::GetPointsOnParentEdge(temp0, temp1, temp2, temp3, temp4, temp5);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetPointsOnEdge2D(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetPointsOnEdge2D");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkHyperOctreeCursor *temp0 = nullptr;
  int temp1;
  int temp2;
  vtkHyperOctreePointsGrabber *temp3 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(4) &&
      ap.GetVTKObject(temp0, "vtkHyperOctreeCursor") &&
      ap.GetValue(temp1) &&
      ap.GetValue(temp2) &&
      ap.GetVTKObject(temp3, "vtkHyperOctreePointsGrabber"))
  {
    if (ap.IsBound())
    {
      op->GetPointsOnEdge2D(temp0, temp1, temp2, temp3);
    }
    else
    {
      op->vtkHyperOctree::GetPointsOnEdge2D(temp0, temp1, temp2, temp3);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetPointsOnParentEdge2D(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetPointsOnParentEdge2D");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  vtkHyperOctreeCursor *temp0 = nullptr;
  int temp1;
  int temp2;
  vtkHyperOctreePointsGrabber *temp3 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(4) &&
      ap.GetVTKObject(temp0, "vtkHyperOctreeCursor") &&
      ap.GetValue(temp1) &&
      ap.GetValue(temp2) &&
      ap.GetVTKObject(temp3, "vtkHyperOctreePointsGrabber"))
  {
    if (ap.IsBound())
    {
      op->GetPointsOnParentEdge2D(temp0, temp1, temp2, temp3);
    }
    else
    {
      op->vtkHyperOctree::GetPointsOnParentEdge2D(temp0, temp1, temp2, temp3);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetLeafData(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetLeafData");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkDataSetAttributes *tempr = (ap.IsBound() ?
      op->GetLeafData() :
      op->vtkHyperOctree::GetLeafData());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_SetDualGridFlag(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetDualGridFlag");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  int temp0;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    if (ap.IsBound())
    {
      op->SetDualGridFlag(temp0);
    }
    else
    {
      op->vtkHyperOctree::SetDualGridFlag(temp0);
    }

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetDualGridFlag(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetDualGridFlag");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    int tempr = (ap.IsBound() ?
      op->GetDualGridFlag() :
      op->vtkHyperOctree::GetDualGridFlag());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetActualMemorySize(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetActualMemorySize");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkHyperOctree *op = static_cast<vtkHyperOctree *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    unsigned long tempr = (ap.IsBound() ?
      op->GetActualMemorySize() :
      op->vtkHyperOctree::GetActualMemorySize());

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctree_GetData_s1(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "GetData");

  vtkInformation *temp0 = nullptr;
  PyObject *result = nullptr;

  if (ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkInformation"))
  {
    vtkHyperOctree *tempr = vtkHyperOctree::GetData(temp0);

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}

static PyObject *
PyvtkHyperOctree_GetData_s2(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "GetData");

  vtkInformationVector *temp0 = nullptr;
  int temp1 = 0;
  PyObject *result = nullptr;

  if (ap.CheckArgCount(1, 2) &&
      ap.GetVTKObject(temp0, "vtkInformationVector") &&
      (ap.NoArgsLeft() || ap.GetValue(temp1)))
  {
    vtkHyperOctree *tempr = vtkHyperOctree::GetData(temp0, temp1);

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}

static PyMethodDef PyvtkHyperOctree_GetData_Methods[] = {
  {nullptr, PyvtkHyperOctree_GetData_s1, METH_VARARGS | METH_STATIC,
   "V *vtkInformation"},
  {nullptr, PyvtkHyperOctree_GetData_s2, METH_VARARGS | METH_STATIC,
   "V|i *vtkInformationVector"},
  {nullptr, nullptr, 0, nullptr}
};

static PyObject *
PyvtkHyperOctree_GetData(PyObject *self, PyObject *args)
{
  PyMethodDef *methods = PyvtkHyperOctree_GetData_Methods;
  int nargs = vtkPythonArgs::GetArgCount(args);

  switch(nargs)
  {
    case 2:
      return PyvtkHyperOctree_GetData_s2(self, args);
    case 1:
      return vtkPythonOverload::CallMethod(methods, self, args);
  }

  vtkPythonArgs::ArgCountError(nargs, "GetData");
  return nullptr;
}


static PyMethodDef PyvtkHyperOctree_Methods[] = {
  {"LEVELS", PyvtkHyperOctree_LEVELS, METH_VARARGS,
   "V.LEVELS() -> vtkInformationIntegerKey\nC++: static vtkInformationIntegerKey *LEVELS()\n\n"},
  {"DIMENSION", PyvtkHyperOctree_DIMENSION, METH_VARARGS,
   "V.DIMENSION() -> vtkInformationIntegerKey\nC++: static vtkInformationIntegerKey *DIMENSION()\n\n"},
  {"SIZES", PyvtkHyperOctree_SIZES, METH_VARARGS,
   "V.SIZES() -> vtkInformationDoubleVectorKey\nC++: static vtkInformationDoubleVectorKey *SIZES()\n\n"},
  {"IsTypeOf", PyvtkHyperOctree_IsTypeOf, METH_VARARGS,
   "V.IsTypeOf(string) -> int\nC++: static vtkTypeBool IsTypeOf(const char *type)\n\nReturn 1 if this class type is the same type of (or a subclass\nof) the named class. Returns 0 otherwise. This method works in\ncombination with vtkTypeMacro found in vtkSetGet.h.\n"},
  {"IsA", PyvtkHyperOctree_IsA, METH_VARARGS,
   "V.IsA(string) -> int\nC++: vtkTypeBool IsA(const char *type) override;\n\nReturn 1 if this class is the same type of (or a subclass of) the\nnamed class. Returns 0 otherwise. This method works in\ncombination with vtkTypeMacro found in vtkSetGet.h.\n"},
  {"SafeDownCast", PyvtkHyperOctree_SafeDownCast, METH_VARARGS,
   "V.SafeDownCast(vtkObjectBase) -> vtkHyperOctree\nC++: static vtkHyperOctree *SafeDownCast(vtkObjectBase *o)\n\n"},
  {"NewInstance", PyvtkHyperOctree_NewInstance, METH_VARARGS,
   "V.NewInstance() -> vtkHyperOctree\nC++: vtkHyperOctree *NewInstance()\n\n"},
  {"GetDataObjectType", PyvtkHyperOctree_GetDataObjectType, METH_VARARGS,
   "V.GetDataObjectType() -> int\nC++: int GetDataObjectType() override;\n\nReturn what type of dataset this is.\n"},
  {"CopyStructure", PyvtkHyperOctree_CopyStructure, METH_VARARGS,
   "V.CopyStructure(vtkDataSet)\nC++: void CopyStructure(vtkDataSet *ds) override;\n\nCopy the geometric and topological structure of an input\nrectilinear grid object.\n"},
  {"GetDimension", PyvtkHyperOctree_GetDimension, METH_VARARGS,
   "V.GetDimension() -> int\nC++: int GetDimension()\n\nReturn the dimension of the tree (1D:binary tree(2 children),\n2D:quadtree(4 children), 3D:octree (8 children))\n\\post valid_result: result>=1 && result<=3\n"},
  {"SetDimension", PyvtkHyperOctree_SetDimension, METH_VARARGS,
   "V.SetDimension(int)\nC++: void SetDimension(int dim)\n\nSet the dimension of the tree with `dim'. See GetDimension() for\ndetails.\n\\pre valid_dim: dim>=1 && dim<=3\n\\post dimension_is_set: GetDimension()==dim\n"},
  {"GetNumberOfCells", PyvtkHyperOctree_GetNumberOfCells, METH_VARARGS,
   "V.GetNumberOfCells() -> int\nC++: vtkIdType GetNumberOfCells() override;\n\nReturn the number of cells in the dual grid.\n\\post positive_result: result>=0\n"},
  {"GetNumberOfLeaves", PyvtkHyperOctree_GetNumberOfLeaves, METH_VARARGS,
   "V.GetNumberOfLeaves() -> int\nC++: vtkIdType GetNumberOfLeaves()\n\nGet the number of leaves in the tree.\n"},
  {"GetNumberOfPoints", PyvtkHyperOctree_GetNumberOfPoints, METH_VARARGS,
   "V.GetNumberOfPoints() -> int\nC++: vtkIdType GetNumberOfPoints() override;\n\nReturn the number of points in the dual grid.\n\\post positive_result: result>=0\n"},
  {"GetMaxNumberOfPoints", PyvtkHyperOctree_GetMaxNumberOfPoints, METH_VARARGS,
   "V.GetMaxNumberOfPoints(int) -> int\nC++: vtkIdType GetMaxNumberOfPoints(int level)\n\nReturn the number of points corresponding to an hyperoctree\nstarting at level `level' where all the leaves at at the last\nlevel. In this case, the hyperoctree is like a uniform grid. So\nthis number is the number of points of the uniform grid.\n\\pre positive_level: level>=0 && level<this->GetNumberOfLevels()\n\\post definition:\n    result==(2^(GetNumberOfLevels()-level-1)+1)^GetDimension()\n"},
  {"GetMaxNumberOfPointsOnBoundary", PyvtkHyperOctree_GetMaxNumberOfPointsOnBoundary, METH_VARARGS,
   "V.GetMaxNumberOfPointsOnBoundary(int) -> int\nC++: vtkIdType GetMaxNumberOfPointsOnBoundary(int level)\n\nReturn the number of points corresponding to the boundary of an\nhyperoctree starting at level `level' where all the leaves at at\nthe last level. In this case, the hyperoctree is like a uniform\ngrid. So this number is the number of points of on the boundary\nof the uniform grid. For an octree, the boundary are the faces.\nFor a quadtree, the boundary are the edges.\n\\pre 2d_or_3d: this->GetDimension()==2 || this->GetDimension()==3\n\\pre positive_level: level>=0 && level<this->GetNumberOfLevels()\n\\post min_result:\n    result>=GetMaxNumberOfPoints(this->GetNumberOfLevels()-1)\n\\post max_result: result<=GetMaxNumberOfPoints(level)\n"},
  {"GetMaxNumberOfCellsOnBoundary", PyvtkHyperOctree_GetMaxNumberOfCellsOnBoundary, METH_VARARGS,
   "V.GetMaxNumberOfCellsOnBoundary(int) -> int\nC++: vtkIdType GetMaxNumberOfCellsOnBoundary(int level)\n\nReturn the number of cells corresponding to the boundary of a\ncell of level `level' where all the leaves at at the last level.\n\\pre positive_level: level>=0 && level<this->GetNumberOfLevels()\n\\post positive_result: result>=0\n"},
  {"GetNumberOfLevels", PyvtkHyperOctree_GetNumberOfLevels, METH_VARARGS,
   "V.GetNumberOfLevels() -> int\nC++: vtkIdType GetNumberOfLevels()\n\nReturn the number of levels.\n\\post result_greater_or_equal_to_one: result>=1\n"},
  {"SetSize", PyvtkHyperOctree_SetSize, METH_VARARGS,
   "V.SetSize(float, float, float)\nC++: void SetSize(double, double, double)\nV.SetSize((float, float, float))\nC++: void SetSize(double a[3])\n\n"},
  {"GetSize", PyvtkHyperOctree_GetSize, METH_VARARGS,
   "V.GetSize() -> (float, float, float)\nC++: double *GetSize()\n\n"},
  {"SetOrigin", PyvtkHyperOctree_SetOrigin, METH_VARARGS,
   "V.SetOrigin(float, float, float)\nC++: void SetOrigin(double, double, double)\nV.SetOrigin((float, float, float))\nC++: void SetOrigin(double a[3])\n\n"},
  {"GetOrigin", PyvtkHyperOctree_GetOrigin, METH_VARARGS,
   "V.GetOrigin() -> (float, float, float)\nC++: double *GetOrigin()\n\n"},
  {"NewCellCursor", PyvtkHyperOctree_NewCellCursor, METH_VARARGS,
   "V.NewCellCursor() -> vtkHyperOctreeCursor\nC++: vtkHyperOctreeCursor *NewCellCursor()\n\nCreate a new cursor: an object that can traverse the cell of an\nhyperoctree.\n\\post result_exists: result!=0\n"},
  {"SubdivideLeaf", PyvtkHyperOctree_SubdivideLeaf, METH_VARARGS,
   "V.SubdivideLeaf(vtkHyperOctreeCursor)\nC++: void SubdivideLeaf(vtkHyperOctreeCursor *leaf)\n\nSubdivide node pointed by cursor, only if its a leaf. At the end,\ncursor points on the node that used to be leaf.\n\\pre leaf_exists: leaf!=0\n\\pre is_a_leaf: leaf->CurrentIsLeaf()\n"},
  {"CollapseTerminalNode", PyvtkHyperOctree_CollapseTerminalNode, METH_VARARGS,
   "V.CollapseTerminalNode(vtkHyperOctreeCursor)\nC++: void CollapseTerminalNode(vtkHyperOctreeCursor *node)\n\nCollapse a node for which all children are leaves. At the end,\ncursor points on the leaf that used to be a node.\n\\pre node_exists: node!=0\n\\pre node_is_node: !node->CurrentIsLeaf()\n\\pre children_are_leaves: node->CurrentIsTerminalNode()\n"},
  {"GetPoint", PyvtkHyperOctree_GetPoint, METH_VARARGS,
   "V.GetPoint(int) -> (float, float, float)\nC++: double *GetPoint(vtkIdType ptId) override;\nV.GetPoint(int, [float, float, float])\nC++: void GetPoint(vtkIdType id, double x[3]) override;\n\nGet point coordinates with ptId such that: 0 <= ptId <\nNumberOfPoints. THIS METHOD IS NOT THREAD SAFE.\n"},
  {"GetCell", PyvtkHyperOctree_GetCell, METH_VARARGS,
   "V.GetCell(int) -> vtkCell\nC++: vtkCell *GetCell(vtkIdType cellId) override;\nV.GetCell(int, vtkGenericCell)\nC++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)\n    override;\nV.GetCell(int, int, int) -> vtkCell\nC++: virtual vtkCell *GetCell(int i, int j, int k)\n\nGet cell with cellId such that: 0 <= cellId < NumberOfCells. THIS\nMETHOD IS NOT THREAD SAFE.\n"},
  {"GetCellType", PyvtkHyperOctree_GetCellType, METH_VARARGS,
   "V.GetCellType(int) -> int\nC++: int GetCellType(vtkIdType cellId) override;\n\nGet type of cell with cellId such that: 0 <= cellId <\nNumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A\nSINGLE THREAD AND THE DATASET IS NOT MODIFIED\n"},
  {"GetCellPoints", PyvtkHyperOctree_GetCellPoints, METH_VARARGS,
   "V.GetCellPoints(int, vtkIdList)\nC++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)\n    override;\nV.GetCellPoints(int, int, [int, ...])\nC++: virtual void GetCellPoints(vtkIdType cellId, vtkIdType &npts,\n     vtkIdType *&pts)\n\nTopological inquiry to get points defining cell. THIS METHOD IS\nTHREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET\nIS NOT MODIFIED\n"},
  {"GetPointCells", PyvtkHyperOctree_GetPointCells, METH_VARARGS,
   "V.GetPointCells(int, vtkIdList)\nC++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)\n    override;\n\nTopological inquiry to get cells using point. THIS METHOD IS\nTHREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET\nIS NOT MODIFIED\n"},
  {"GetCellNeighbors", PyvtkHyperOctree_GetCellNeighbors, METH_VARARGS,
   "V.GetCellNeighbors(int, vtkIdList, vtkIdList)\nC++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,\n    vtkIdList *cellIds) override;\n\nTopological inquiry to get all cells using list of points\nexclusive of cell specified (e.g., cellId). Note that the list\nconsists of only cells that use ALL the points provided. THIS\nMETHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND\nTHE DATASET IS NOT MODIFIED\n"},
  {"FindPoint", PyvtkHyperOctree_FindPoint, METH_VARARGS,
   "V.FindPoint([float, float, float]) -> int\nC++: vtkIdType FindPoint(double x[3]) override;\n\nLocate the closest point to the global coordinate x. Return the\npoint id. If point id < 0; then no point found. (This may arise\nwhen point is outside of dataset.) THIS METHOD IS THREAD SAFE IF\nFIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED\n"},
  {"FindCell", PyvtkHyperOctree_FindCell, METH_VARARGS,
   "V.FindCell([float, float, float], vtkCell, int, float, int,\n    [float, float, float], [float, ...]) -> int\nC++: vtkIdType FindCell(double x[3], vtkCell *cell,\n    vtkIdType cellId, double tol2, int &subId, double pcoords[3],\n    double *weights) override;\nV.FindCell([float, float, float], vtkCell, vtkGenericCell, int,\n    float, int, [float, float, float], [float, ...]) -> int\nC++: vtkIdType FindCell(double x[3], vtkCell *cell,\n    vtkGenericCell *gencell, vtkIdType cellId, double tol2,\n    int &subId, double pcoords[3], double *weights) override;\n\nLocate cell based on global coordinate x and tolerance squared.\nIf cell and cellId is non-nullptr, then search starts from this\ncell and looks at immediate neighbors.  Returns cellId >= 0 if\ninside, < 0 otherwise.  The parametric coordinates are provided\nin pcoords[3]. The interpolation weights are returned in\nweights[]. (The number of weights is equal to the number of\npoints in the found cell). Tolerance is used to control how close\nthe point is to be considered \"in\" the cell. THIS METHOD IS NOT\nTHREAD SAFE.\n"},
  {"Initialize", PyvtkHyperOctree_Initialize, METH_VARARGS,
   "V.Initialize()\nC++: void Initialize() override;\n\nRestore data object to initial state, THIS METHOD IS NOT THREAD\nSAFE.\n"},
  {"GetMaxCellSize", PyvtkHyperOctree_GetMaxCellSize, METH_VARARGS,
   "V.GetMaxCellSize() -> int\nC++: int GetMaxCellSize() override;\n\nConvenience method returns largest cell size in dataset. This is\ngenerally used to allocate memory for supporting data structures.\nThis is the number of points of a cell. THIS METHOD IS THREAD\nSAFE\n"},
  {"ShallowCopy", PyvtkHyperOctree_ShallowCopy, METH_VARARGS,
   "V.ShallowCopy(vtkDataObject)\nC++: void ShallowCopy(vtkDataObject *src) override;\n\nShallow and Deep copy.\n"},
  {"DeepCopy", PyvtkHyperOctree_DeepCopy, METH_VARARGS,
   "V.DeepCopy(vtkDataObject)\nC++: void DeepCopy(vtkDataObject *src) override;\n\nShallow and Deep copy.\n"},
  {"GetPointsOnFace", PyvtkHyperOctree_GetPointsOnFace, METH_VARARGS,
   "V.GetPointsOnFace(vtkHyperOctreeCursor, int, int,\n    vtkHyperOctreePointsGrabber)\nC++: void GetPointsOnFace(vtkHyperOctreeCursor *sibling, int face,\n     int level, vtkHyperOctreePointsGrabber *grabber)\n\nGet the points of node `sibling' on its face `face'.\n\\pre sibling_exists: sibling!=0\n\\pre sibling_not_leaf: !sibling->CurrentIsLeaf()\n\\pre sibling_3d: sibling->GetDimension()==3\n\\pre valid_face: face>=0 && face<6\n\\pre valid_level_not_leaf: level>=0\n    level<(this->GetNumberOfLevels()-1)\n"},
  {"GetPointsOnParentFaces", PyvtkHyperOctree_GetPointsOnParentFaces, METH_VARARGS,
   "V.GetPointsOnParentFaces([int, int, int], int,\n    vtkHyperOctreeCursor, vtkHyperOctreePointsGrabber)\nC++: void GetPointsOnParentFaces(int faces[3], int level,\n    vtkHyperOctreeCursor *cursor,\n    vtkHyperOctreePointsGrabber *grabber)\n\nGet the points of the parent node of `cursor' on its faces\n`faces' at level `level' or deeper.\n\\pre cursor_exists: cursor!=0\n\\pre cursor_3d: cursor->GetDimension()==3\n\\pre valid_level: level>=0\n\\pre boolean_faces: (faces[0]==0 || faces[0]==1) && (faces[1]==0\n    || faces[1]==1) && (faces[2]==0 || faces[2]==1)\n"},
  {"GetPointsOnEdge", PyvtkHyperOctree_GetPointsOnEdge, METH_VARARGS,
   "V.GetPointsOnEdge(vtkHyperOctreeCursor, int, int, int, int,\n    vtkHyperOctreePointsGrabber)\nC++: void GetPointsOnEdge(vtkHyperOctreeCursor *sibling,\n    int level, int axis, int k, int j,\n    vtkHyperOctreePointsGrabber *grabber)\n\nGet the points of node `sibling' on its edge `axis','k','j'. If\naxis==0, the edge is X-aligned and k gives the z coordinate and j\nthe y-coordinate. If axis==1, the edge is Y-aligned and k gives\nthe x coordinate and j the z coordinate. If axis==2, the edge is\nZ-aligned and k gives the y coordinate and j the x coordinate.\n\\pre sibling_exists: sibling!=0\n\\pre sibling_3d: sibling->GetDimension()==3\n\\pre sibling_not_leaf: !sibling->CurrentIsLeaf()\n\\pre valid_axis: axis>=0 && axis<3\n\\pre valid_k: k>=0 && k<=1\n\\pre valid_j: j>=0 && j<=1\n\\pre valid_level_not_leaf: level>=0\n    level<(this->Input->GetNumberOfLevels()-1)\n"},
  {"GetPointsOnParentEdge", PyvtkHyperOctree_GetPointsOnParentEdge, METH_VARARGS,
   "V.GetPointsOnParentEdge(vtkHyperOctreeCursor, int, int, int, int,\n    vtkHyperOctreePointsGrabber)\nC++: void GetPointsOnParentEdge(vtkHyperOctreeCursor *cursor,\n    int level, int axis, int k, int j,\n    vtkHyperOctreePointsGrabber *grabber)\n\nGet the points of the parent node of `cursor' on its edge\n`axis','k','j' at level `level' or deeper. If axis==0, the edge\nis X-aligned and k gives the z coordinate and j the y-coordinate.\nIf axis==1, the edge is Y-aligned and k gives the x coordinate\nand j the z coordinate. If axis==2, the edge is Z-aligned and k\ngives the y coordinate and j the x coordinate.\n\\pre cursor_exists: cursor!=0\n\\pre cursor_3d: cursor->GetDimension()==3\n\\pre valid_level: level>=0\n\\pre valid_range_axis: axis>=0 && axis<3\n\\pre valid_range_k: k>=0 && k<=1\n\\pre valid_range_j: j>=0 && j<=1\n"},
  {"GetPointsOnEdge2D", PyvtkHyperOctree_GetPointsOnEdge2D, METH_VARARGS,
   "V.GetPointsOnEdge2D(vtkHyperOctreeCursor, int, int,\n    vtkHyperOctreePointsGrabber)\nC++: void GetPointsOnEdge2D(vtkHyperOctreeCursor *sibling,\n    int edge, int level, vtkHyperOctreePointsGrabber *grabber)\n\nGet the points of node `sibling' on its edge `edge'.\n\\pre sibling_exists: sibling!=0\n\\pre sibling_not_leaf: !sibling->CurrentIsLeaf()\n\\pre sibling_2d: sibling->GetDimension()==2\n\\pre valid_edge: edge>=0 && edge<4\n\\pre valid_level_not_leaf: level>=0\n    level<(this->Input->GetNumberOfLevels()-1)\n"},
  {"GetPointsOnParentEdge2D", PyvtkHyperOctree_GetPointsOnParentEdge2D, METH_VARARGS,
   "V.GetPointsOnParentEdge2D(vtkHyperOctreeCursor, int, int,\n    vtkHyperOctreePointsGrabber)\nC++: void GetPointsOnParentEdge2D(vtkHyperOctreeCursor *cursor,\n    int edge, int level, vtkHyperOctreePointsGrabber *grabber)\n\nGet the points of the parent node of `cursor' on its edge `edge'\nat level `level' or deeper. (edge=0 for -X, 1 for +X, 2 for -Y, 3\nfor +Y)\n\\pre cursor_exists: cursor!=0\n\\pre cursor_2d: cursor->GetDimension()==2\n\\pre valid_level: level>=0\n\\pre valid_edge: edge>=0 && edge<4\n"},
  {"GetLeafData", PyvtkHyperOctree_GetLeafData, METH_VARARGS,
   "V.GetLeafData() -> vtkDataSetAttributes\nC++: vtkDataSetAttributes *GetLeafData()\n\nA generic way to set the leaf data attributes. This can be either\npoint data for dual or cell data for normal grid.\n"},
  {"SetDualGridFlag", PyvtkHyperOctree_SetDualGridFlag, METH_VARARGS,
   "V.SetDualGridFlag(int)\nC++: void SetDualGridFlag(int flag)\n\nSwitch between returning leaves as cells, or the dual grid.\n"},
  {"GetDualGridFlag", PyvtkHyperOctree_GetDualGridFlag, METH_VARARGS,
   "V.GetDualGridFlag() -> int\nC++: virtual int GetDualGridFlag()\n\nSwitch between returning leaves as cells, or the dual grid.\n"},
  {"GetActualMemorySize", PyvtkHyperOctree_GetActualMemorySize, METH_VARARGS,
   "V.GetActualMemorySize() -> int\nC++: unsigned long GetActualMemorySize() override;\n\nReturn the actual size of the data in kibibytes (1024 bytes).\nThis number is valid only after the pipeline has updated. The\nmemory size returned is guaranteed to be greater than or equal to\nthe memory required to represent the data (e.g., extra space in\narrays, etc. are not included in the return value). THIS METHOD\nIS THREAD SAFE.\n"},
  {"GetData", PyvtkHyperOctree_GetData, METH_VARARGS,
   "V.GetData(vtkInformation) -> vtkHyperOctree\nC++: static vtkHyperOctree *GetData(vtkInformation *info)\nV.GetData(vtkInformationVector, int) -> vtkHyperOctree\nC++: static vtkHyperOctree *GetData(vtkInformationVector *v,\n    int i=0)\n\nRetrieve an instance of this class from an information object.\n"},
  {nullptr, nullptr, 0, nullptr}
};

static PyTypeObject PyvtkHyperOctree_Type = {
  PyVarObject_HEAD_INIT(&PyType_Type, 0)
  "vtkCommonDataModelPython.vtkHyperOctree", // tp_name
  sizeof(PyVTKObject), // tp_basicsize
  0, // tp_itemsize
  PyVTKObject_Delete, // tp_dealloc
  0, // tp_print
  nullptr, // tp_getattr
  nullptr, // tp_setattr
  nullptr, // tp_compare
  PyVTKObject_Repr, // tp_repr
  nullptr, // tp_as_number
  nullptr, // tp_as_sequence
  nullptr, // tp_as_mapping
  nullptr, // tp_hash
  nullptr, // tp_call
  PyVTKObject_String, // tp_str
  PyObject_GenericGetAttr, // tp_getattro
  PyObject_GenericSetAttr, // tp_setattro
  &PyVTKObject_AsBuffer, // tp_as_buffer
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_BASETYPE, // tp_flags
  PyvtkHyperOctree_Doc, // tp_doc
  PyVTKObject_Traverse, // tp_traverse
  nullptr, // tp_clear
  nullptr, // tp_richcompare
  offsetof(PyVTKObject, vtk_weakreflist), // tp_weaklistoffset
  nullptr, // tp_iter
  nullptr, // tp_iternext
  nullptr, // tp_methods
  nullptr, // tp_members
  PyVTKObject_GetSet, // tp_getset
  nullptr, // tp_base
  nullptr, // tp_dict
  nullptr, // tp_descr_get
  nullptr, // tp_descr_set
  offsetof(PyVTKObject, vtk_dict), // tp_dictoffset
  nullptr, // tp_init
  nullptr, // tp_alloc
  PyVTKObject_New, // tp_new
  PyObject_GC_Del, // tp_free
  nullptr, // tp_is_gc
  nullptr, // tp_bases
  nullptr, // tp_mro
  nullptr, // tp_cache
  nullptr, // tp_subclasses
  nullptr, // tp_weaklist
  VTK_WRAP_PYTHON_SUPPRESS_UNINITIALIZED
};

static vtkObjectBase *PyvtkHyperOctree_StaticNew()
{
  return vtkHyperOctree::New();
}

PyObject *PyvtkHyperOctree_ClassNew()
{
  PyVTKClass_Add(
    &PyvtkHyperOctree_Type, PyvtkHyperOctree_Methods,
    "vtkHyperOctree",
 &PyvtkHyperOctree_StaticNew);

  PyTypeObject *pytype = &PyvtkHyperOctree_Type;

  if ((pytype->tp_flags & Py_TPFLAGS_READY) != 0)
  {
    return (PyObject *)pytype;
  }

#if !defined(VTK_PY3K) && PY_VERSION_HEX >= 0x02060000
  pytype->tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
#endif

  pytype->tp_base = (PyTypeObject *)PyvtkDataSet_ClassNew();

  PyType_Ready(pytype);
  return (PyObject *)pytype;
}


static const char *PyvtkHyperOctreeLightWeightCursor_Doc =
  "vtkHyperOctreeLightWeightCursor - no description provided.\n\n"

  "vtkHyperOctreeLightWeightCursor()\n"
  "vtkHyperOctreeLightWeightCursor(\n    const &vtkHyperOctreeLightWeightCursor)\n";


static PyObject *
PyvtkHyperOctreeLightWeightCursor_Initialize(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "Initialize");
  void *vp = ap.GetSelfSpecialPointer(self, args);
  vtkHyperOctreeLightWeightCursor *op = static_cast<vtkHyperOctreeLightWeightCursor *>(vp);

  vtkHyperOctree *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkHyperOctree"))
  {
    op->Initialize(temp0);

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctreeLightWeightCursor_ToRoot(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ToRoot");
  void *vp = ap.GetSelfSpecialPointer(self, args);
  vtkHyperOctreeLightWeightCursor *op = static_cast<vtkHyperOctreeLightWeightCursor *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    op->ToRoot();

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctreeLightWeightCursor_ToChild(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ToChild");
  void *vp = ap.GetSelfSpecialPointer(self, args);
  vtkHyperOctreeLightWeightCursor *op = static_cast<vtkHyperOctreeLightWeightCursor *>(vp);

  int temp0;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetValue(temp0))
  {
    op->ToChild(temp0);

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctreeLightWeightCursor_GetIsLeaf(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetIsLeaf");
  void *vp = ap.GetSelfSpecialPointer(self, args);
  vtkHyperOctreeLightWeightCursor *op = static_cast<vtkHyperOctreeLightWeightCursor *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    unsigned short tempr = op->GetIsLeaf();

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctreeLightWeightCursor_GetLeafIndex(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetLeafIndex");
  void *vp = ap.GetSelfSpecialPointer(self, args);
  vtkHyperOctreeLightWeightCursor *op = static_cast<vtkHyperOctreeLightWeightCursor *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    int tempr = op->GetLeafIndex();

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctreeLightWeightCursor_GetTree(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetTree");
  void *vp = ap.GetSelfSpecialPointer(self, args);
  vtkHyperOctreeLightWeightCursor *op = static_cast<vtkHyperOctreeLightWeightCursor *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkHyperOctree *tempr = op->GetTree();

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildVTKObject(tempr);
    }
  }

  return result;
}


static PyObject *
PyvtkHyperOctreeLightWeightCursor_GetLevel(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetLevel");
  void *vp = ap.GetSelfSpecialPointer(self, args);
  vtkHyperOctreeLightWeightCursor *op = static_cast<vtkHyperOctreeLightWeightCursor *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    unsigned short tempr = op->GetLevel();

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}

static PyMethodDef PyvtkHyperOctreeLightWeightCursor_Methods[] = {
  {"Initialize", PyvtkHyperOctreeLightWeightCursor_Initialize, METH_VARARGS,
   "V.Initialize(vtkHyperOctree)\nC++: void Initialize(vtkHyperOctree *tree)\n\n"},
  {"ToRoot", PyvtkHyperOctreeLightWeightCursor_ToRoot, METH_VARARGS,
   "V.ToRoot()\nC++: void ToRoot()\n\n"},
  {"ToChild", PyvtkHyperOctreeLightWeightCursor_ToChild, METH_VARARGS,
   "V.ToChild(int)\nC++: void ToChild(int child)\n\n"},
  {"GetIsLeaf", PyvtkHyperOctreeLightWeightCursor_GetIsLeaf, METH_VARARGS,
   "V.GetIsLeaf() -> int\nC++: unsigned short GetIsLeaf()\n\n"},
  {"GetLeafIndex", PyvtkHyperOctreeLightWeightCursor_GetLeafIndex, METH_VARARGS,
   "V.GetLeafIndex() -> int\nC++: int GetLeafIndex()\n\n"},
  {"GetTree", PyvtkHyperOctreeLightWeightCursor_GetTree, METH_VARARGS,
   "V.GetTree() -> vtkHyperOctree\nC++: vtkHyperOctree *GetTree()\n\n"},
  {"GetLevel", PyvtkHyperOctreeLightWeightCursor_GetLevel, METH_VARARGS,
   "V.GetLevel() -> int\nC++: unsigned short GetLevel()\n\n"},
  {nullptr, nullptr, 0, nullptr}
};


static PyObject *
PyvtkHyperOctreeLightWeightCursor_vtkHyperOctreeLightWeightCursor_s1(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "vtkHyperOctreeLightWeightCursor");

  PyObject *result = nullptr;

  if (ap.CheckArgCount(0))
  {
    vtkHyperOctreeLightWeightCursor *op = new vtkHyperOctreeLightWeightCursor();

    result = PyVTKSpecialObject_New("vtkHyperOctreeLightWeightCursor", op);
  }

  return result;
}

static PyObject *
PyvtkHyperOctreeLightWeightCursor_vtkHyperOctreeLightWeightCursor_s2(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "vtkHyperOctreeLightWeightCursor");

  vtkHyperOctreeLightWeightCursor *temp0 = nullptr;
  PyObject *pobj0 = nullptr;
  PyObject *result = nullptr;

  if (ap.CheckArgCount(1) &&
      ap.GetSpecialObject(temp0, pobj0, "vtkHyperOctreeLightWeightCursor"))
  {
    vtkHyperOctreeLightWeightCursor *op = new vtkHyperOctreeLightWeightCursor(*temp0);

    result = PyVTKSpecialObject_New("vtkHyperOctreeLightWeightCursor", op);
  }

  Py_XDECREF(pobj0);

  return result;
}

static PyMethodDef PyvtkHyperOctreeLightWeightCursor_vtkHyperOctreeLightWeightCursor_Methods[] = {
  {nullptr, PyvtkHyperOctreeLightWeightCursor_vtkHyperOctreeLightWeightCursor_s2, METH_VARARGS,
   "@W vtkHyperOctreeLightWeightCursor"},
  {nullptr, nullptr, 0, nullptr}
};

static PyObject *
PyvtkHyperOctreeLightWeightCursor_vtkHyperOctreeLightWeightCursor(PyObject *self, PyObject *args)
{
  int nargs = vtkPythonArgs::GetArgCount(args);

  switch(nargs)
  {
    case 0:
      return PyvtkHyperOctreeLightWeightCursor_vtkHyperOctreeLightWeightCursor_s1(self, args);
    case 1:
      return PyvtkHyperOctreeLightWeightCursor_vtkHyperOctreeLightWeightCursor_s2(self, args);
  }

  vtkPythonArgs::ArgCountError(nargs, "vtkHyperOctreeLightWeightCursor");
  return nullptr;
}


static PyObject *
PyvtkHyperOctreeLightWeightCursor_New(PyTypeObject *, PyObject *args, PyObject *kwds)
{
  if (kwds && PyDict_Size(kwds))
  {
    PyErr_SetString(PyExc_TypeError,
                    "this function takes no keyword arguments");
    return nullptr;
  }

  return PyvtkHyperOctreeLightWeightCursor_vtkHyperOctreeLightWeightCursor(nullptr, args);
}

static void PyvtkHyperOctreeLightWeightCursor_Delete(PyObject *self)
{
  PyVTKSpecialObject *obj = (PyVTKSpecialObject *)self;
  delete static_cast<vtkHyperOctreeLightWeightCursor *>(obj->vtk_ptr);
  PyObject_Del(self);
}

static Py_hash_t PyvtkHyperOctreeLightWeightCursor_Hash(PyObject *self)
{
#if PY_VERSION_HEX >= 0x020600B2
  return PyObject_HashNotImplemented(self);
#else
  char text[256];
  sprintf(text, "unhashable type: '%s'", Py_TYPE(self)->tp_name);
  PyErr_SetString(PyExc_TypeError, text);
  return -1;
#endif
}

static PyTypeObject PyvtkHyperOctreeLightWeightCursor_Type = {
  PyVarObject_HEAD_INIT(&PyType_Type, 0)
  "vtkCommonDataModelPython.vtkHyperOctreeLightWeightCursor", // tp_name
  sizeof(PyVTKSpecialObject), // tp_basicsize
  0, // tp_itemsize
  PyvtkHyperOctreeLightWeightCursor_Delete, // tp_dealloc
  0, // tp_print
  nullptr, // tp_getattr
  nullptr, // tp_setattr
  nullptr, // tp_compare
  PyVTKSpecialObject_Repr, // tp_repr
  nullptr, // tp_as_number
  nullptr, // tp_as_sequence
  nullptr, // tp_as_mapping
  PyvtkHyperOctreeLightWeightCursor_Hash, // tp_hash
  nullptr, // tp_call
  nullptr, // tp_str
  PyObject_GenericGetAttr, // tp_getattro
  nullptr, // tp_setattro
  nullptr, // tp_as_buffer
  Py_TPFLAGS_DEFAULT, // tp_flags
  PyvtkHyperOctreeLightWeightCursor_Doc, // tp_doc
  nullptr, // tp_traverse
  nullptr, // tp_clear
  nullptr, // tp_richcompare
  0, // tp_weaklistoffset
  nullptr, // tp_iter
  nullptr, // tp_iternext
  nullptr, // tp_methods
  nullptr, // tp_members
  nullptr, // tp_getset
  nullptr, // tp_base
  nullptr, // tp_dict
  nullptr, // tp_descr_get
  nullptr, // tp_descr_set
  0, // tp_dictoffset
  nullptr, // tp_init
  nullptr, // tp_alloc
  PyvtkHyperOctreeLightWeightCursor_New, // tp_new
  PyObject_Del, // tp_free
  nullptr, // tp_is_gc
  nullptr, // tp_bases
  nullptr, // tp_mro
  nullptr, // tp_cache
  nullptr, // tp_subclasses
  nullptr, // tp_weaklist
  VTK_WRAP_PYTHON_SUPPRESS_UNINITIALIZED
};

static void *PyvtkHyperOctreeLightWeightCursor_CCopy(const void *obj)
{
  if (obj)
  {
    return new vtkHyperOctreeLightWeightCursor(*static_cast<const vtkHyperOctreeLightWeightCursor*>(obj));
  }
  return 0;
}

extern "C" { VTK_ABI_EXPORT PyObject *PyvtkHyperOctreeLightWeightCursor_TypeNew(); }

PyObject *PyvtkHyperOctreeLightWeightCursor_TypeNew()
{
  PyVTKSpecialType_Add(
    &PyvtkHyperOctreeLightWeightCursor_Type,
    PyvtkHyperOctreeLightWeightCursor_Methods,
    PyvtkHyperOctreeLightWeightCursor_vtkHyperOctreeLightWeightCursor_Methods,
    &PyvtkHyperOctreeLightWeightCursor_CCopy);

  PyTypeObject *pytype = &PyvtkHyperOctreeLightWeightCursor_Type;

  if ((pytype->tp_flags & Py_TPFLAGS_READY) != 0)
  {
    return (PyObject *)pytype;
  }

  PyType_Ready(pytype);
  return (PyObject *)pytype;
}

void PyVTKAddFile_vtkHyperOctree(
  PyObject *dict)
{
  PyObject *o;
  o = PyvtkHyperOctree_ClassNew();

  if (o && PyDict_SetItemString(dict, "vtkHyperOctree", o) != 0)
  {
    Py_DECREF(o);
  }

  o = PyvtkHyperOctreeLightWeightCursor_TypeNew();

  if (o && PyDict_SetItemString(dict, "vtkHyperOctreeLightWeightCursor", o) != 0)
  {
    Py_DECREF(o);
  }

}