// python wrapper for vtkImageAccumulate
//
#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 "vtkImageAccumulate.h"

extern "C" { VTK_ABI_EXPORT void PyVTKAddFile_vtkImageAccumulate(PyObject *); }
extern "C" { VTK_ABI_EXPORT PyObject *PyvtkImageAccumulate_ClassNew(); }

#ifndef DECLARED_PyvtkImageAlgorithm_ClassNew
extern "C" { PyObject *PyvtkImageAlgorithm_ClassNew(); }
#define DECLARED_PyvtkImageAlgorithm_ClassNew
#endif

static const char *PyvtkImageAccumulate_Doc =
  "vtkImageAccumulate - Generalized histograms up to 3 dimensions.\n\n"
  "Superclass: vtkImageAlgorithm\n\n"
  "vtkImageAccumulate - This filter divides component space into\n"
  "discrete bins.  It then counts the number of pixels associated with\n"
  "each bin. The dimensionality of the output depends on how many\n"
  "components the input pixels have. An input images with N components\n"
  "per pixels will result in an N-dimensional histogram, where N can be\n"
  "1, 2, or 3. The input can be any type, but the output is always int.\n"
  "Some statistics are computed on the pixel values at the same time.\n"
  "The SetStencil and ReverseStencil functions allow the statistics to\n"
  "be computed on an arbitrary portion of the input data. See the\n"
  "documentation for vtkImageStencilData for more information.\n\n"
  "This filter also supports ignoring pixels with value equal to 0.\n"
  "Using this option with vtkImageMask may result in results being\n"
  "slightly off since 0 could be a valid value from your input.\n\n";


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

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

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

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

  return result;
}


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

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

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

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

  return result;
}


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

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

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

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

  return result;
}


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

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkImageAccumulate *tempr = (ap.IsBound() ?
      op->NewInstance() :
      op->vtkImageAccumulate::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 *
PyvtkImageAccumulate_SetComponentSpacing_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetComponentSpacing");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(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->SetComponentSpacing(temp0, temp1, temp2);
    }
    else
    {
      op->vtkImageAccumulate::SetComponentSpacing(temp0, temp1, temp2);
    }

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

  return result;
}

static PyObject *
PyvtkImageAccumulate_SetComponentSpacing_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetComponentSpacing");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

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

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

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

  return result;
}

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

  switch(nargs)
  {
    case 3:
      return PyvtkImageAccumulate_SetComponentSpacing_s1(self, args);
    case 1:
      return PyvtkImageAccumulate_SetComponentSpacing_s2(self, args);
  }

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



static PyObject *
PyvtkImageAccumulate_GetComponentSpacing(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetComponentSpacing");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  int sizer = 3;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_SetComponentOrigin_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetComponentOrigin");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(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->SetComponentOrigin(temp0, temp1, temp2);
    }
    else
    {
      op->vtkImageAccumulate::SetComponentOrigin(temp0, temp1, temp2);
    }

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

  return result;
}

static PyObject *
PyvtkImageAccumulate_SetComponentOrigin_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetComponentOrigin");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

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

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

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

  return result;
}

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

  switch(nargs)
  {
    case 3:
      return PyvtkImageAccumulate_SetComponentOrigin_s1(self, args);
    case 1:
      return PyvtkImageAccumulate_SetComponentOrigin_s2(self, args);
  }

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



static PyObject *
PyvtkImageAccumulate_GetComponentOrigin(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetComponentOrigin");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  int sizer = 3;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_SetComponentExtent_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetComponentExtent");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

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

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

    if (ap.IsBound())
    {
      op->SetComponentExtent(temp0);
    }
    else
    {
      op->vtkImageAccumulate::SetComponentExtent(temp0);
    }

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

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

  return result;
}

static PyObject *
PyvtkImageAccumulate_SetComponentExtent_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetComponentExtent");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

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

  if (op && ap.CheckArgCount(6) &&
      ap.GetValue(temp0) &&
      ap.GetValue(temp1) &&
      ap.GetValue(temp2) &&
      ap.GetValue(temp3) &&
      ap.GetValue(temp4) &&
      ap.GetValue(temp5))
  {
    if (ap.IsBound())
    {
      op->SetComponentExtent(temp0, temp1, temp2, temp3, temp4, temp5);
    }
    else
    {
      op->vtkImageAccumulate::SetComponentExtent(temp0, temp1, temp2, temp3, temp4, temp5);
    }

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

  return result;
}

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

  switch(nargs)
  {
    case 1:
      return PyvtkImageAccumulate_SetComponentExtent_s1(self, args);
    case 6:
      return PyvtkImageAccumulate_SetComponentExtent_s2(self, args);
  }

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



static PyObject *
PyvtkImageAccumulate_GetComponentExtent_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetComponentExtent");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

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

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

    if (ap.IsBound())
    {
      op->GetComponentExtent(temp0);
    }
    else
    {
      op->vtkImageAccumulate::GetComponentExtent(temp0);
    }

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

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

  return result;
}

static PyObject *
PyvtkImageAccumulate_GetComponentExtent_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetComponentExtent");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  int sizer = 6;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    int *tempr = (ap.IsBound() ?
      op->GetComponentExtent() :
      op->vtkImageAccumulate::GetComponentExtent());

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

  return result;
}

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

  switch(nargs)
  {
    case 1:
      return PyvtkImageAccumulate_GetComponentExtent_s1(self, args);
    case 0:
      return PyvtkImageAccumulate_GetComponentExtent_s2(self, args);
  }

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



static PyObject *
PyvtkImageAccumulate_SetStencilData(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetStencilData");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  vtkImageStencilData *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkImageStencilData"))
  {
    if (ap.IsBound())
    {
      op->SetStencilData(temp0);
    }
    else
    {
      op->vtkImageAccumulate::SetStencilData(temp0);
    }

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetStencil(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetStencil");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkImageStencilData *tempr = (ap.IsBound() ?
      op->GetStencil() :
      op->vtkImageAccumulate::GetStencil());

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_SetReverseStencil(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetReverseStencil");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  int temp0;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetReverseStencilMinValue(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetReverseStencilMinValue");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetReverseStencilMaxValue(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetReverseStencilMaxValue");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_ReverseStencilOn(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ReverseStencilOn");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_ReverseStencilOff(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ReverseStencilOff");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetReverseStencil(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetReverseStencil");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetMin(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetMin");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  int sizer = 3;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetMax(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetMax");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  int sizer = 3;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetMean(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetMean");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  int sizer = 3;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetStandardDeviation(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetStandardDeviation");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  int sizer = 3;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetVoxelCount(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetVoxelCount");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_SetIgnoreZero(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetIgnoreZero");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  int temp0;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetIgnoreZeroMinValue(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetIgnoreZeroMinValue");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetIgnoreZeroMaxValue(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetIgnoreZeroMaxValue");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_GetIgnoreZero(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetIgnoreZero");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_IgnoreZeroOn(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "IgnoreZeroOn");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageAccumulate_IgnoreZeroOff(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "IgnoreZeroOff");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageAccumulate *op = static_cast<vtkImageAccumulate *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}

static PyMethodDef PyvtkImageAccumulate_Methods[] = {
  {"IsTypeOf", PyvtkImageAccumulate_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", PyvtkImageAccumulate_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", PyvtkImageAccumulate_SafeDownCast, METH_VARARGS,
   "V.SafeDownCast(vtkObjectBase) -> vtkImageAccumulate\nC++: static vtkImageAccumulate *SafeDownCast(vtkObjectBase *o)\n\n"},
  {"NewInstance", PyvtkImageAccumulate_NewInstance, METH_VARARGS,
   "V.NewInstance() -> vtkImageAccumulate\nC++: vtkImageAccumulate *NewInstance()\n\n"},
  {"SetComponentSpacing", PyvtkImageAccumulate_SetComponentSpacing, METH_VARARGS,
   "V.SetComponentSpacing(float, float, float)\nC++: void SetComponentSpacing(double, double, double)\nV.SetComponentSpacing((float, float, float))\nC++: void SetComponentSpacing(double a[3])\n\n"},
  {"GetComponentSpacing", PyvtkImageAccumulate_GetComponentSpacing, METH_VARARGS,
   "V.GetComponentSpacing() -> (float, float, float)\nC++: double *GetComponentSpacing()\n\n"},
  {"SetComponentOrigin", PyvtkImageAccumulate_SetComponentOrigin, METH_VARARGS,
   "V.SetComponentOrigin(float, float, float)\nC++: void SetComponentOrigin(double, double, double)\nV.SetComponentOrigin((float, float, float))\nC++: void SetComponentOrigin(double a[3])\n\n"},
  {"GetComponentOrigin", PyvtkImageAccumulate_GetComponentOrigin, METH_VARARGS,
   "V.GetComponentOrigin() -> (float, float, float)\nC++: double *GetComponentOrigin()\n\n"},
  {"SetComponentExtent", PyvtkImageAccumulate_SetComponentExtent, METH_VARARGS,
   "V.SetComponentExtent([int, int, int, int, int, int])\nC++: void SetComponentExtent(int extent[6])\nV.SetComponentExtent(int, int, int, int, int, int)\nC++: void SetComponentExtent(int minX, int maxX, int minY,\n    int maxY, int minZ, int maxZ)\n\nSet/Get - The component extent sets the number/extent of the\nbins. For a 1D histogram with 10 bins spanning the values 1000 to\n2000, this extent should be set to 0, 9, 0, 0, 0, 0. The extent\nspecifies inclusive min/max values. This implies that the top\nextent should be set to the number of bins - 1. Initial value is\n(0,255,0,0,0,0)\n"},
  {"GetComponentExtent", PyvtkImageAccumulate_GetComponentExtent, METH_VARARGS,
   "V.GetComponentExtent([int, int, int, int, int, int])\nC++: void GetComponentExtent(int extent[6])\nV.GetComponentExtent() -> (int, int, int, int, int, int)\nC++: int *GetComponentExtent()\n\nSet/Get - The component extent sets the number/extent of the\nbins. For a 1D histogram with 10 bins spanning the values 1000 to\n2000, this extent should be set to 0, 9, 0, 0, 0, 0. The extent\nspecifies inclusive min/max values. This implies that the top\nextent should be set to the number of bins - 1. Initial value is\n(0,255,0,0,0,0)\n"},
  {"SetStencilData", PyvtkImageAccumulate_SetStencilData, METH_VARARGS,
   "V.SetStencilData(vtkImageStencilData)\nC++: void SetStencilData(vtkImageStencilData *stencil)\n\nUse a stencil to specify which voxels to accumulate.\nBackcompatible methods. It set and get the stencil on input port\n1. Initial value is nullptr.\n"},
  {"GetStencil", PyvtkImageAccumulate_GetStencil, METH_VARARGS,
   "V.GetStencil() -> vtkImageStencilData\nC++: vtkImageStencilData *GetStencil()\n\nUse a stencil to specify which voxels to accumulate.\nBackcompatible methods. It set and get the stencil on input port\n1. Initial value is nullptr.\n"},
  {"SetReverseStencil", PyvtkImageAccumulate_SetReverseStencil, METH_VARARGS,
   "V.SetReverseStencil(int)\nC++: virtual void SetReverseStencil(int _arg)\n\nReverse the stencil. Initial value is false.\n"},
  {"GetReverseStencilMinValue", PyvtkImageAccumulate_GetReverseStencilMinValue, METH_VARARGS,
   "V.GetReverseStencilMinValue() -> int\nC++: virtual int GetReverseStencilMinValue()\n\nReverse the stencil. Initial value is false.\n"},
  {"GetReverseStencilMaxValue", PyvtkImageAccumulate_GetReverseStencilMaxValue, METH_VARARGS,
   "V.GetReverseStencilMaxValue() -> int\nC++: virtual int GetReverseStencilMaxValue()\n\nReverse the stencil. Initial value is false.\n"},
  {"ReverseStencilOn", PyvtkImageAccumulate_ReverseStencilOn, METH_VARARGS,
   "V.ReverseStencilOn()\nC++: virtual void ReverseStencilOn()\n\nReverse the stencil. Initial value is false.\n"},
  {"ReverseStencilOff", PyvtkImageAccumulate_ReverseStencilOff, METH_VARARGS,
   "V.ReverseStencilOff()\nC++: virtual void ReverseStencilOff()\n\nReverse the stencil. Initial value is false.\n"},
  {"GetReverseStencil", PyvtkImageAccumulate_GetReverseStencil, METH_VARARGS,
   "V.GetReverseStencil() -> int\nC++: virtual int GetReverseStencil()\n\nReverse the stencil. Initial value is false.\n"},
  {"GetMin", PyvtkImageAccumulate_GetMin, METH_VARARGS,
   "V.GetMin() -> (float, float, float)\nC++: double *GetMin()\n\n"},
  {"GetMax", PyvtkImageAccumulate_GetMax, METH_VARARGS,
   "V.GetMax() -> (float, float, float)\nC++: double *GetMax()\n\n"},
  {"GetMean", PyvtkImageAccumulate_GetMean, METH_VARARGS,
   "V.GetMean() -> (float, float, float)\nC++: double *GetMean()\n\n"},
  {"GetStandardDeviation", PyvtkImageAccumulate_GetStandardDeviation, METH_VARARGS,
   "V.GetStandardDeviation() -> (float, float, float)\nC++: double *GetStandardDeviation()\n\n"},
  {"GetVoxelCount", PyvtkImageAccumulate_GetVoxelCount, METH_VARARGS,
   "V.GetVoxelCount() -> int\nC++: virtual vtkIdType GetVoxelCount()\n\nGet the statistics information for the data. The values only make\nsense after the execution of the filter. Initial values are 0.\n"},
  {"SetIgnoreZero", PyvtkImageAccumulate_SetIgnoreZero, METH_VARARGS,
   "V.SetIgnoreZero(int)\nC++: virtual void SetIgnoreZero(int _arg)\n\nShould the data with value 0 be ignored? Initial value is false.\n"},
  {"GetIgnoreZeroMinValue", PyvtkImageAccumulate_GetIgnoreZeroMinValue, METH_VARARGS,
   "V.GetIgnoreZeroMinValue() -> int\nC++: virtual int GetIgnoreZeroMinValue()\n\nShould the data with value 0 be ignored? Initial value is false.\n"},
  {"GetIgnoreZeroMaxValue", PyvtkImageAccumulate_GetIgnoreZeroMaxValue, METH_VARARGS,
   "V.GetIgnoreZeroMaxValue() -> int\nC++: virtual int GetIgnoreZeroMaxValue()\n\nShould the data with value 0 be ignored? Initial value is false.\n"},
  {"GetIgnoreZero", PyvtkImageAccumulate_GetIgnoreZero, METH_VARARGS,
   "V.GetIgnoreZero() -> int\nC++: virtual int GetIgnoreZero()\n\nShould the data with value 0 be ignored? Initial value is false.\n"},
  {"IgnoreZeroOn", PyvtkImageAccumulate_IgnoreZeroOn, METH_VARARGS,
   "V.IgnoreZeroOn()\nC++: virtual void IgnoreZeroOn()\n\nShould the data with value 0 be ignored? Initial value is false.\n"},
  {"IgnoreZeroOff", PyvtkImageAccumulate_IgnoreZeroOff, METH_VARARGS,
   "V.IgnoreZeroOff()\nC++: virtual void IgnoreZeroOff()\n\nShould the data with value 0 be ignored? Initial value is false.\n"},
  {nullptr, nullptr, 0, nullptr}
};

static PyTypeObject PyvtkImageAccumulate_Type = {
  PyVarObject_HEAD_INIT(&PyType_Type, 0)
  "vtkImagingStatisticsPython.vtkImageAccumulate", // 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
  PyvtkImageAccumulate_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 *PyvtkImageAccumulate_StaticNew()
{
  return vtkImageAccumulate::New();
}

PyObject *PyvtkImageAccumulate_ClassNew()
{
  PyVTKClass_Add(
    &PyvtkImageAccumulate_Type, PyvtkImageAccumulate_Methods,
    "vtkImageAccumulate",
 &PyvtkImageAccumulate_StaticNew);

  PyTypeObject *pytype = &PyvtkImageAccumulate_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 *)PyvtkImageAlgorithm_ClassNew();

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

void PyVTKAddFile_vtkImageAccumulate(
  PyObject *dict)
{
  PyObject *o;
  o = PyvtkImageAccumulate_ClassNew();

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

}