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

extern "C" { VTK_ABI_EXPORT void PyVTKAddFile_vtkImageResliceMapper(PyObject *); }
extern "C" { VTK_ABI_EXPORT PyObject *PyvtkImageResliceMapper_ClassNew(); }

#ifndef DECLARED_PyvtkImageMapper3D_ClassNew
extern "C" { PyObject *PyvtkImageMapper3D_ClassNew(); }
#define DECLARED_PyvtkImageMapper3D_ClassNew
#endif

static const char *PyvtkImageResliceMapper_Doc =
  "vtkImageResliceMapper - map a slice of a vtkImageData to the screen\n\n"
  "Superclass: vtkImageMapper3D\n\n"
  "vtkImageResliceMapper will cut a 3D image with an abitrary slice\n"
  "plane and draw the results on the screen.  The slice can be set to\n"
  "automatically follow the camera, so that the camera controls the\n"
  "slicing.@par Thanks: Thanks to David Gobbi at the Seaman Family MR\n"
  "Centre and Dept. of Clinical Neurosciences, Foothills Medical Centre,\n"
  "Calgary, for providing this class.\n"
  "@sa\n"
  "vtkImageSlice vtkImageProperty vtkImageSliceMapper\n\n";


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

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

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

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

  return result;
}


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

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

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

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

  return result;
}


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

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

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

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

  return result;
}


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

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkImageResliceMapper *tempr = (ap.IsBound() ?
      op->NewInstance() :
      op->vtkImageResliceMapper::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 *
PyvtkImageResliceMapper_SetSlicePlane(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSlicePlane");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  vtkPlane *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkPlane"))
  {
    if (ap.IsBound())
    {
      op->SetSlicePlane(temp0);
    }
    else
    {
      op->vtkImageResliceMapper::SetSlicePlane(temp0);
    }

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetJumpToNearestSlice(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetJumpToNearestSlice");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  int temp0;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_JumpToNearestSliceOn(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "JumpToNearestSliceOn");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_JumpToNearestSliceOff(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "JumpToNearestSliceOff");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetJumpToNearestSlice(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetJumpToNearestSlice");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetSlabThickness(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSlabThickness");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  double temp0;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetSlabThickness(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSlabThickness");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    double tempr = (ap.IsBound() ?
      op->GetSlabThickness() :
      op->vtkImageResliceMapper::GetSlabThickness());

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetSlabType(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSlabType");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  int temp0;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetSlabTypeMinValue(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSlabTypeMinValue");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetSlabTypeMaxValue(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSlabTypeMaxValue");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetSlabType(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSlabType");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetSlabTypeToMin(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSlabTypeToMin");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetSlabTypeToMax(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSlabTypeToMax");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetSlabTypeToMean(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSlabTypeToMean");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetSlabTypeToSum(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSlabTypeToSum");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetSlabTypeAsString(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSlabTypeAsString");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    const char *tempr = (ap.IsBound() ?
      op->GetSlabTypeAsString() :
      op->vtkImageResliceMapper::GetSlabTypeAsString());

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetSlabSampleFactor(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSlabSampleFactor");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  int temp0;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetSlabSampleFactorMinValue(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSlabSampleFactorMinValue");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetSlabSampleFactorMaxValue(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSlabSampleFactorMaxValue");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetSlabSampleFactor(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSlabSampleFactor");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetImageSampleFactor(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetImageSampleFactor");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  int temp0;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetImageSampleFactorMinValue(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetImageSampleFactorMinValue");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetImageSampleFactorMaxValue(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetImageSampleFactorMaxValue");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetImageSampleFactor(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetImageSampleFactor");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetAutoAdjustImageQuality(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetAutoAdjustImageQuality");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  int temp0;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_AutoAdjustImageQualityOn(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "AutoAdjustImageQualityOn");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_AutoAdjustImageQualityOff(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "AutoAdjustImageQualityOff");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetAutoAdjustImageQuality(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetAutoAdjustImageQuality");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetResampleToScreenPixels(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetResampleToScreenPixels");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  int temp0;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_ResampleToScreenPixelsOn(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ResampleToScreenPixelsOn");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_ResampleToScreenPixelsOff(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ResampleToScreenPixelsOff");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetResampleToScreenPixels(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetResampleToScreenPixels");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetSeparateWindowLevelOperation(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetSeparateWindowLevelOperation");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  int temp0;
  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SeparateWindowLevelOperationOn(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SeparateWindowLevelOperationOn");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SeparateWindowLevelOperationOff(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SeparateWindowLevelOperationOff");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetSeparateWindowLevelOperation(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetSeparateWindowLevelOperation");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_SetInterpolator(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "SetInterpolator");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  vtkAbstractImageInterpolator *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkAbstractImageInterpolator"))
  {
    if (ap.IsBound())
    {
      op->SetInterpolator(temp0);
    }
    else
    {
      op->vtkImageResliceMapper::SetInterpolator(temp0);
    }

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetInterpolator(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetInterpolator");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(0))
  {
    vtkAbstractImageInterpolator *tempr = (ap.IsBound() ?
      op->GetInterpolator() :
      op->vtkImageResliceMapper::GetInterpolator());

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_Render(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "Render");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  vtkRenderer *temp0 = nullptr;
  vtkImageSlice *temp1 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(2) &&
      ap.GetVTKObject(temp0, "vtkRenderer") &&
      ap.GetVTKObject(temp1, "vtkImageSlice"))
  {
    if (ap.IsBound())
    {
      op->Render(temp0, temp1);
    }
    else
    {
      op->vtkImageResliceMapper::Render(temp0, temp1);
    }

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_ReleaseGraphicsResources(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "ReleaseGraphicsResources");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  vtkWindow *temp0 = nullptr;
  PyObject *result = nullptr;

  if (op && ap.CheckArgCount(1) &&
      ap.GetVTKObject(temp0, "vtkWindow"))
  {
    if (ap.IsBound())
    {
      op->ReleaseGraphicsResources(temp0);
    }
    else
    {
      op->vtkImageResliceMapper::ReleaseGraphicsResources(temp0);
    }

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetMTime(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetMTime");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}


static PyObject *
PyvtkImageResliceMapper_GetBounds_s1(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetBounds");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

  PyObject *result = nullptr;

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

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

  return result;
}

static PyObject *
PyvtkImageResliceMapper_GetBounds_s2(PyObject *self, PyObject *args)
{
  vtkPythonArgs ap(self, args, "GetBounds");
  vtkObjectBase *vp = ap.GetSelfPointer(self, args);
  vtkImageResliceMapper *op = static_cast<vtkImageResliceMapper *>(vp);

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

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

    if (ap.IsBound())
    {
      op->GetBounds(temp0);
    }
    else
    {
      op->vtkImageResliceMapper::GetBounds(temp0);
    }

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

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

  return result;
}

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

  switch(nargs)
  {
    case 0:
      return PyvtkImageResliceMapper_GetBounds_s1(self, args);
    case 1:
      return PyvtkImageResliceMapper_GetBounds_s2(self, args);
  }

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


static PyMethodDef PyvtkImageResliceMapper_Methods[] = {
  {"IsTypeOf", PyvtkImageResliceMapper_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", PyvtkImageResliceMapper_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", PyvtkImageResliceMapper_SafeDownCast, METH_VARARGS,
   "V.SafeDownCast(vtkObjectBase) -> vtkImageResliceMapper\nC++: static vtkImageResliceMapper *SafeDownCast(vtkObjectBase *o)\n\n"},
  {"NewInstance", PyvtkImageResliceMapper_NewInstance, METH_VARARGS,
   "V.NewInstance() -> vtkImageResliceMapper\nC++: vtkImageResliceMapper *NewInstance()\n\n"},
  {"SetSlicePlane", PyvtkImageResliceMapper_SetSlicePlane, METH_VARARGS,
   "V.SetSlicePlane(vtkPlane)\nC++: virtual void SetSlicePlane(vtkPlane *plane)\n\nSet the slice that will be used to cut through the image. This\nslice should be in world coordinates, rather than data\ncoordinates.  Use SliceFacesCamera and SliceAtFocalPoint if you\nwant the slice to automatically follow the camera.\n"},
  {"SetJumpToNearestSlice", PyvtkImageResliceMapper_SetJumpToNearestSlice, METH_VARARGS,
   "V.SetJumpToNearestSlice(int)\nC++: virtual void SetJumpToNearestSlice(int _arg)\n\nWhen using SliceAtFocalPoint, this causes the slicing to occur at\nthe closest slice to the focal point, instead of the default\nbehavior where a new slice is interpolated between the original\nslices.  This flag is ignored if the slicing is oblique to the\noriginal slices.\n"},
  {"JumpToNearestSliceOn", PyvtkImageResliceMapper_JumpToNearestSliceOn, METH_VARARGS,
   "V.JumpToNearestSliceOn()\nC++: virtual void JumpToNearestSliceOn()\n\nWhen using SliceAtFocalPoint, this causes the slicing to occur at\nthe closest slice to the focal point, instead of the default\nbehavior where a new slice is interpolated between the original\nslices.  This flag is ignored if the slicing is oblique to the\noriginal slices.\n"},
  {"JumpToNearestSliceOff", PyvtkImageResliceMapper_JumpToNearestSliceOff, METH_VARARGS,
   "V.JumpToNearestSliceOff()\nC++: virtual void JumpToNearestSliceOff()\n\nWhen using SliceAtFocalPoint, this causes the slicing to occur at\nthe closest slice to the focal point, instead of the default\nbehavior where a new slice is interpolated between the original\nslices.  This flag is ignored if the slicing is oblique to the\noriginal slices.\n"},
  {"GetJumpToNearestSlice", PyvtkImageResliceMapper_GetJumpToNearestSlice, METH_VARARGS,
   "V.GetJumpToNearestSlice() -> int\nC++: virtual int GetJumpToNearestSlice()\n\nWhen using SliceAtFocalPoint, this causes the slicing to occur at\nthe closest slice to the focal point, instead of the default\nbehavior where a new slice is interpolated between the original\nslices.  This flag is ignored if the slicing is oblique to the\noriginal slices.\n"},
  {"SetSlabThickness", PyvtkImageResliceMapper_SetSlabThickness, METH_VARARGS,
   "V.SetSlabThickness(float)\nC++: virtual void SetSlabThickness(double _arg)\n\nThe slab thickness, for thick slicing (default: zero)\n"},
  {"GetSlabThickness", PyvtkImageResliceMapper_GetSlabThickness, METH_VARARGS,
   "V.GetSlabThickness() -> float\nC++: virtual double GetSlabThickness()\n\nThe slab thickness, for thick slicing (default: zero)\n"},
  {"SetSlabType", PyvtkImageResliceMapper_SetSlabType, METH_VARARGS,
   "V.SetSlabType(int)\nC++: virtual void SetSlabType(int _arg)\n\nThe slab type, for thick slicing (default: Mean). The resulting\nview is a parallel projection through the volume.  This method\ncan be used to generate a facsimile of a digitally-reconstructed\nradiograph or a minimum-intensity projection as long as\nperspective geometry is not required.  Note that the Sum mode\nprovides an output with units of intensity times distance, while\nall other modes provide an output with units of intensity.\n"},
  {"GetSlabTypeMinValue", PyvtkImageResliceMapper_GetSlabTypeMinValue, METH_VARARGS,
   "V.GetSlabTypeMinValue() -> int\nC++: virtual int GetSlabTypeMinValue()\n\nThe slab type, for thick slicing (default: Mean). The resulting\nview is a parallel projection through the volume.  This method\ncan be used to generate a facsimile of a digitally-reconstructed\nradiograph or a minimum-intensity projection as long as\nperspective geometry is not required.  Note that the Sum mode\nprovides an output with units of intensity times distance, while\nall other modes provide an output with units of intensity.\n"},
  {"GetSlabTypeMaxValue", PyvtkImageResliceMapper_GetSlabTypeMaxValue, METH_VARARGS,
   "V.GetSlabTypeMaxValue() -> int\nC++: virtual int GetSlabTypeMaxValue()\n\nThe slab type, for thick slicing (default: Mean). The resulting\nview is a parallel projection through the volume.  This method\ncan be used to generate a facsimile of a digitally-reconstructed\nradiograph or a minimum-intensity projection as long as\nperspective geometry is not required.  Note that the Sum mode\nprovides an output with units of intensity times distance, while\nall other modes provide an output with units of intensity.\n"},
  {"GetSlabType", PyvtkImageResliceMapper_GetSlabType, METH_VARARGS,
   "V.GetSlabType() -> int\nC++: virtual int GetSlabType()\n\nThe slab type, for thick slicing (default: Mean). The resulting\nview is a parallel projection through the volume.  This method\ncan be used to generate a facsimile of a digitally-reconstructed\nradiograph or a minimum-intensity projection as long as\nperspective geometry is not required.  Note that the Sum mode\nprovides an output with units of intensity times distance, while\nall other modes provide an output with units of intensity.\n"},
  {"SetSlabTypeToMin", PyvtkImageResliceMapper_SetSlabTypeToMin, METH_VARARGS,
   "V.SetSlabTypeToMin()\nC++: void SetSlabTypeToMin()\n\nThe slab type, for thick slicing (default: Mean). The resulting\nview is a parallel projection through the volume.  This method\ncan be used to generate a facsimile of a digitally-reconstructed\nradiograph or a minimum-intensity projection as long as\nperspective geometry is not required.  Note that the Sum mode\nprovides an output with units of intensity times distance, while\nall other modes provide an output with units of intensity.\n"},
  {"SetSlabTypeToMax", PyvtkImageResliceMapper_SetSlabTypeToMax, METH_VARARGS,
   "V.SetSlabTypeToMax()\nC++: void SetSlabTypeToMax()\n\nThe slab type, for thick slicing (default: Mean). The resulting\nview is a parallel projection through the volume.  This method\ncan be used to generate a facsimile of a digitally-reconstructed\nradiograph or a minimum-intensity projection as long as\nperspective geometry is not required.  Note that the Sum mode\nprovides an output with units of intensity times distance, while\nall other modes provide an output with units of intensity.\n"},
  {"SetSlabTypeToMean", PyvtkImageResliceMapper_SetSlabTypeToMean, METH_VARARGS,
   "V.SetSlabTypeToMean()\nC++: void SetSlabTypeToMean()\n\nThe slab type, for thick slicing (default: Mean). The resulting\nview is a parallel projection through the volume.  This method\ncan be used to generate a facsimile of a digitally-reconstructed\nradiograph or a minimum-intensity projection as long as\nperspective geometry is not required.  Note that the Sum mode\nprovides an output with units of intensity times distance, while\nall other modes provide an output with units of intensity.\n"},
  {"SetSlabTypeToSum", PyvtkImageResliceMapper_SetSlabTypeToSum, METH_VARARGS,
   "V.SetSlabTypeToSum()\nC++: void SetSlabTypeToSum()\n\nThe slab type, for thick slicing (default: Mean). The resulting\nview is a parallel projection through the volume.  This method\ncan be used to generate a facsimile of a digitally-reconstructed\nradiograph or a minimum-intensity projection as long as\nperspective geometry is not required.  Note that the Sum mode\nprovides an output with units of intensity times distance, while\nall other modes provide an output with units of intensity.\n"},
  {"GetSlabTypeAsString", PyvtkImageResliceMapper_GetSlabTypeAsString, METH_VARARGS,
   "V.GetSlabTypeAsString() -> string\nC++: virtual const char *GetSlabTypeAsString()\n\nThe slab type, for thick slicing (default: Mean). The resulting\nview is a parallel projection through the volume.  This method\ncan be used to generate a facsimile of a digitally-reconstructed\nradiograph or a minimum-intensity projection as long as\nperspective geometry is not required.  Note that the Sum mode\nprovides an output with units of intensity times distance, while\nall other modes provide an output with units of intensity.\n"},
  {"SetSlabSampleFactor", PyvtkImageResliceMapper_SetSlabSampleFactor, METH_VARARGS,
   "V.SetSlabSampleFactor(int)\nC++: virtual void SetSlabSampleFactor(int _arg)\n\nSet the number of slab samples to use as a factor of the number\nof input slices within the slab thickness.  The default value is\n2, but 1 will increase speed with very little loss of quality.\n"},
  {"GetSlabSampleFactorMinValue", PyvtkImageResliceMapper_GetSlabSampleFactorMinValue, METH_VARARGS,
   "V.GetSlabSampleFactorMinValue() -> int\nC++: virtual int GetSlabSampleFactorMinValue()\n\nSet the number of slab samples to use as a factor of the number\nof input slices within the slab thickness.  The default value is\n2, but 1 will increase speed with very little loss of quality.\n"},
  {"GetSlabSampleFactorMaxValue", PyvtkImageResliceMapper_GetSlabSampleFactorMaxValue, METH_VARARGS,
   "V.GetSlabSampleFactorMaxValue() -> int\nC++: virtual int GetSlabSampleFactorMaxValue()\n\nSet the number of slab samples to use as a factor of the number\nof input slices within the slab thickness.  The default value is\n2, but 1 will increase speed with very little loss of quality.\n"},
  {"GetSlabSampleFactor", PyvtkImageResliceMapper_GetSlabSampleFactor, METH_VARARGS,
   "V.GetSlabSampleFactor() -> int\nC++: virtual int GetSlabSampleFactor()\n\nSet the number of slab samples to use as a factor of the number\nof input slices within the slab thickness.  The default value is\n2, but 1 will increase speed with very little loss of quality.\n"},
  {"SetImageSampleFactor", PyvtkImageResliceMapper_SetImageSampleFactor, METH_VARARGS,
   "V.SetImageSampleFactor(int)\nC++: virtual void SetImageSampleFactor(int _arg)\n\nSet the reslice sample frequency as in relation to the input\nimage sample frequency.  The default value is 1, but higher\nvalues can be used to improve the results.  This is cheaper than\nturning on ResampleToScreenPixels.\n"},
  {"GetImageSampleFactorMinValue", PyvtkImageResliceMapper_GetImageSampleFactorMinValue, METH_VARARGS,
   "V.GetImageSampleFactorMinValue() -> int\nC++: virtual int GetImageSampleFactorMinValue()\n\nSet the reslice sample frequency as in relation to the input\nimage sample frequency.  The default value is 1, but higher\nvalues can be used to improve the results.  This is cheaper than\nturning on ResampleToScreenPixels.\n"},
  {"GetImageSampleFactorMaxValue", PyvtkImageResliceMapper_GetImageSampleFactorMaxValue, METH_VARARGS,
   "V.GetImageSampleFactorMaxValue() -> int\nC++: virtual int GetImageSampleFactorMaxValue()\n\nSet the reslice sample frequency as in relation to the input\nimage sample frequency.  The default value is 1, but higher\nvalues can be used to improve the results.  This is cheaper than\nturning on ResampleToScreenPixels.\n"},
  {"GetImageSampleFactor", PyvtkImageResliceMapper_GetImageSampleFactor, METH_VARARGS,
   "V.GetImageSampleFactor() -> int\nC++: virtual int GetImageSampleFactor()\n\nSet the reslice sample frequency as in relation to the input\nimage sample frequency.  The default value is 1, but higher\nvalues can be used to improve the results.  This is cheaper than\nturning on ResampleToScreenPixels.\n"},
  {"SetAutoAdjustImageQuality", PyvtkImageResliceMapper_SetAutoAdjustImageQuality, METH_VARARGS,
   "V.SetAutoAdjustImageQuality(int)\nC++: virtual void SetAutoAdjustImageQuality(int _arg)\n\nAutomatically reduce the rendering quality for greater speed when\ndoing an interactive render.  This is on by default.\n"},
  {"AutoAdjustImageQualityOn", PyvtkImageResliceMapper_AutoAdjustImageQualityOn, METH_VARARGS,
   "V.AutoAdjustImageQualityOn()\nC++: virtual void AutoAdjustImageQualityOn()\n\nAutomatically reduce the rendering quality for greater speed when\ndoing an interactive render.  This is on by default.\n"},
  {"AutoAdjustImageQualityOff", PyvtkImageResliceMapper_AutoAdjustImageQualityOff, METH_VARARGS,
   "V.AutoAdjustImageQualityOff()\nC++: virtual void AutoAdjustImageQualityOff()\n\nAutomatically reduce the rendering quality for greater speed when\ndoing an interactive render.  This is on by default.\n"},
  {"GetAutoAdjustImageQuality", PyvtkImageResliceMapper_GetAutoAdjustImageQuality, METH_VARARGS,
   "V.GetAutoAdjustImageQuality() -> int\nC++: virtual int GetAutoAdjustImageQuality()\n\nAutomatically reduce the rendering quality for greater speed when\ndoing an interactive render.  This is on by default.\n"},
  {"SetResampleToScreenPixels", PyvtkImageResliceMapper_SetResampleToScreenPixels, METH_VARARGS,
   "V.SetResampleToScreenPixels(int)\nC++: virtual void SetResampleToScreenPixels(int _arg)\n\nResample the image directly to the screen pixels, instead of\nusing a texture to scale the image after resampling.  This is\nslower and uses more memory, but provides high-quality results.\nIt is On by default.\n"},
  {"ResampleToScreenPixelsOn", PyvtkImageResliceMapper_ResampleToScreenPixelsOn, METH_VARARGS,
   "V.ResampleToScreenPixelsOn()\nC++: virtual void ResampleToScreenPixelsOn()\n\nResample the image directly to the screen pixels, instead of\nusing a texture to scale the image after resampling.  This is\nslower and uses more memory, but provides high-quality results.\nIt is On by default.\n"},
  {"ResampleToScreenPixelsOff", PyvtkImageResliceMapper_ResampleToScreenPixelsOff, METH_VARARGS,
   "V.ResampleToScreenPixelsOff()\nC++: virtual void ResampleToScreenPixelsOff()\n\nResample the image directly to the screen pixels, instead of\nusing a texture to scale the image after resampling.  This is\nslower and uses more memory, but provides high-quality results.\nIt is On by default.\n"},
  {"GetResampleToScreenPixels", PyvtkImageResliceMapper_GetResampleToScreenPixels, METH_VARARGS,
   "V.GetResampleToScreenPixels() -> int\nC++: virtual int GetResampleToScreenPixels()\n\nResample the image directly to the screen pixels, instead of\nusing a texture to scale the image after resampling.  This is\nslower and uses more memory, but provides high-quality results.\nIt is On by default.\n"},
  {"SetSeparateWindowLevelOperation", PyvtkImageResliceMapper_SetSeparateWindowLevelOperation, METH_VARARGS,
   "V.SetSeparateWindowLevelOperation(int)\nC++: virtual void SetSeparateWindowLevelOperation(int _arg)\n\nKeep the color mapping stage distinct from the reslicing stage.\nThis will improve the quality and possibly the speed of\ninteractive window/level operations, but it uses more memory and\nmight slow down interactive slicing operations.  On by default.\n"},
  {"SeparateWindowLevelOperationOn", PyvtkImageResliceMapper_SeparateWindowLevelOperationOn, METH_VARARGS,
   "V.SeparateWindowLevelOperationOn()\nC++: virtual void SeparateWindowLevelOperationOn()\n\nKeep the color mapping stage distinct from the reslicing stage.\nThis will improve the quality and possibly the speed of\ninteractive window/level operations, but it uses more memory and\nmight slow down interactive slicing operations.  On by default.\n"},
  {"SeparateWindowLevelOperationOff", PyvtkImageResliceMapper_SeparateWindowLevelOperationOff, METH_VARARGS,
   "V.SeparateWindowLevelOperationOff()\nC++: virtual void SeparateWindowLevelOperationOff()\n\nKeep the color mapping stage distinct from the reslicing stage.\nThis will improve the quality and possibly the speed of\ninteractive window/level operations, but it uses more memory and\nmight slow down interactive slicing operations.  On by default.\n"},
  {"GetSeparateWindowLevelOperation", PyvtkImageResliceMapper_GetSeparateWindowLevelOperation, METH_VARARGS,
   "V.GetSeparateWindowLevelOperation() -> int\nC++: virtual int GetSeparateWindowLevelOperation()\n\nKeep the color mapping stage distinct from the reslicing stage.\nThis will improve the quality and possibly the speed of\ninteractive window/level operations, but it uses more memory and\nmight slow down interactive slicing operations.  On by default.\n"},
  {"SetInterpolator", PyvtkImageResliceMapper_SetInterpolator, METH_VARARGS,
   "V.SetInterpolator(vtkAbstractImageInterpolator)\nC++: virtual void SetInterpolator(\n    vtkAbstractImageInterpolator *sampler)\n\nSet a custom interpolator.  This will only be used if the\nResampleToScreenPixels option is on.\n"},
  {"GetInterpolator", PyvtkImageResliceMapper_GetInterpolator, METH_VARARGS,
   "V.GetInterpolator() -> vtkAbstractImageInterpolator\nC++: virtual vtkAbstractImageInterpolator *GetInterpolator()\n\nSet a custom interpolator.  This will only be used if the\nResampleToScreenPixels option is on.\n"},
  {"Render", PyvtkImageResliceMapper_Render, METH_VARARGS,
   "V.Render(vtkRenderer, vtkImageSlice)\nC++: void Render(vtkRenderer *renderer, vtkImageSlice *prop)\n    override;\n\nThis should only be called by the renderer.\n"},
  {"ReleaseGraphicsResources", PyvtkImageResliceMapper_ReleaseGraphicsResources, METH_VARARGS,
   "V.ReleaseGraphicsResources(vtkWindow)\nC++: void ReleaseGraphicsResources(vtkWindow *) override;\n\nRelease any graphics resources that are being consumed by this\nmapper.  The parameter window is used to determine which graphic\nresources to release.\n"},
  {"GetMTime", PyvtkImageResliceMapper_GetMTime, METH_VARARGS,
   "V.GetMTime() -> int\nC++: vtkMTimeType GetMTime() override;\n\nGet the mtime for the mapper.\n"},
  {"GetBounds", PyvtkImageResliceMapper_GetBounds, METH_VARARGS,
   "V.GetBounds() -> (float, ...)\nC++: double *GetBounds() override;\nV.GetBounds([float, float, float, float, float, float])\nC++: void GetBounds(double bounds[6]) override;\n\nThe bounding box (array of six doubles) of the data expressed as\n(xmin,xmax, ymin,ymax, zmin,zmax).\n"},
  {nullptr, nullptr, 0, nullptr}
};

static PyTypeObject PyvtkImageResliceMapper_Type = {
  PyVarObject_HEAD_INIT(&PyType_Type, 0)
  "vtkRenderingImagePython.vtkImageResliceMapper", // 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
  PyvtkImageResliceMapper_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 *PyvtkImageResliceMapper_StaticNew()
{
  return vtkImageResliceMapper::New();
}

PyObject *PyvtkImageResliceMapper_ClassNew()
{
  PyVTKClass_Add(
    &PyvtkImageResliceMapper_Type, PyvtkImageResliceMapper_Methods,
    "vtkImageResliceMapper",
 &PyvtkImageResliceMapper_StaticNew);

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

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

void PyVTKAddFile_vtkImageResliceMapper(
  PyObject *dict)
{
  PyObject *o;
  o = PyvtkImageResliceMapper_ClassNew();

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

}