/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>

#include "vtkPolyDataSourceWidgetWrap.h"
#include "vtkImagePlaneWidgetWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkAlgorithmOutputWrap.h"
#include "vtkImageDataWrap.h"
#include "vtkPolyDataWrap.h"
#include "vtkPolyDataAlgorithmWrap.h"
#include "vtkTextureWrap.h"
#include "vtkImageMapToColorsWrap.h"
#include "vtkPropertyWrap.h"
#include "vtkAbstractPropPickerWrap.h"
#include "vtkLookupTableWrap.h"
#include "vtkTextPropertyWrap.h"
#include "vtkMatrix4x4Wrap.h"
#include "vtkImageResliceWrap.h"
#include "../../plus/plus.h"

using namespace v8;

extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkImagePlaneWidgetWrap::ptpl;

VtkImagePlaneWidgetWrap::VtkImagePlaneWidgetWrap()
{ }

VtkImagePlaneWidgetWrap::VtkImagePlaneWidgetWrap(vtkSmartPointer<vtkImagePlaneWidget> _native)
{ native = _native; }

VtkImagePlaneWidgetWrap::~VtkImagePlaneWidgetWrap()
{ }

void VtkImagePlaneWidgetWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkImagePlaneWidget").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("ImagePlaneWidget").ToLocalChecked(), ConstructorGetter);
}

void VtkImagePlaneWidgetWrap::ConstructorGetter(
	v8::Local<v8::String> property,
	const Nan::PropertyCallbackInfo<v8::Value>& info)
{
	InitPtpl();
	info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}

void VtkImagePlaneWidgetWrap::InitPtpl()
{
	if (!ptpl.IsEmpty()) return;
	v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
	VtkPolyDataSourceWidgetWrap::InitPtpl( );
	tpl->Inherit(Nan::New<FunctionTemplate>(VtkPolyDataSourceWidgetWrap::ptpl));
	tpl->SetClassName(Nan::New("VtkImagePlaneWidgetWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "DisplayTextOff", DisplayTextOff);
	Nan::SetPrototypeMethod(tpl, "displayTextOff", DisplayTextOff);

	Nan::SetPrototypeMethod(tpl, "DisplayTextOn", DisplayTextOn);
	Nan::SetPrototypeMethod(tpl, "displayTextOn", DisplayTextOn);

	Nan::SetPrototypeMethod(tpl, "GetCenter", GetCenter);
	Nan::SetPrototypeMethod(tpl, "getCenter", GetCenter);

	Nan::SetPrototypeMethod(tpl, "GetColorMap", GetColorMap);
	Nan::SetPrototypeMethod(tpl, "getColorMap", GetColorMap);

	Nan::SetPrototypeMethod(tpl, "GetCurrentCursorPosition", GetCurrentCursorPosition);
	Nan::SetPrototypeMethod(tpl, "getCurrentCursorPosition", GetCurrentCursorPosition);

	Nan::SetPrototypeMethod(tpl, "GetCurrentImageValue", GetCurrentImageValue);
	Nan::SetPrototypeMethod(tpl, "getCurrentImageValue", GetCurrentImageValue);

	Nan::SetPrototypeMethod(tpl, "GetCursorData", GetCursorData);
	Nan::SetPrototypeMethod(tpl, "getCursorData", GetCursorData);

	Nan::SetPrototypeMethod(tpl, "GetCursorDataStatus", GetCursorDataStatus);
	Nan::SetPrototypeMethod(tpl, "getCursorDataStatus", GetCursorDataStatus);

	Nan::SetPrototypeMethod(tpl, "GetCursorProperty", GetCursorProperty);
	Nan::SetPrototypeMethod(tpl, "getCursorProperty", GetCursorProperty);

	Nan::SetPrototypeMethod(tpl, "GetDisplayText", GetDisplayText);
	Nan::SetPrototypeMethod(tpl, "getDisplayText", GetDisplayText);

	Nan::SetPrototypeMethod(tpl, "GetInteraction", GetInteraction);
	Nan::SetPrototypeMethod(tpl, "getInteraction", GetInteraction);

	Nan::SetPrototypeMethod(tpl, "GetLeftButtonAction", GetLeftButtonAction);
	Nan::SetPrototypeMethod(tpl, "getLeftButtonAction", GetLeftButtonAction);

	Nan::SetPrototypeMethod(tpl, "GetLeftButtonActionMaxValue", GetLeftButtonActionMaxValue);
	Nan::SetPrototypeMethod(tpl, "getLeftButtonActionMaxValue", GetLeftButtonActionMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetLeftButtonActionMinValue", GetLeftButtonActionMinValue);
	Nan::SetPrototypeMethod(tpl, "getLeftButtonActionMinValue", GetLeftButtonActionMinValue);

	Nan::SetPrototypeMethod(tpl, "GetLeftButtonAutoModifier", GetLeftButtonAutoModifier);
	Nan::SetPrototypeMethod(tpl, "getLeftButtonAutoModifier", GetLeftButtonAutoModifier);

	Nan::SetPrototypeMethod(tpl, "GetLeftButtonAutoModifierMaxValue", GetLeftButtonAutoModifierMaxValue);
	Nan::SetPrototypeMethod(tpl, "getLeftButtonAutoModifierMaxValue", GetLeftButtonAutoModifierMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetLeftButtonAutoModifierMinValue", GetLeftButtonAutoModifierMinValue);
	Nan::SetPrototypeMethod(tpl, "getLeftButtonAutoModifierMinValue", GetLeftButtonAutoModifierMinValue);

	Nan::SetPrototypeMethod(tpl, "GetLevel", GetLevel);
	Nan::SetPrototypeMethod(tpl, "getLevel", GetLevel);

	Nan::SetPrototypeMethod(tpl, "GetLookupTable", GetLookupTable);
	Nan::SetPrototypeMethod(tpl, "getLookupTable", GetLookupTable);

	Nan::SetPrototypeMethod(tpl, "GetMarginProperty", GetMarginProperty);
	Nan::SetPrototypeMethod(tpl, "getMarginProperty", GetMarginProperty);

	Nan::SetPrototypeMethod(tpl, "GetMarginSizeX", GetMarginSizeX);
	Nan::SetPrototypeMethod(tpl, "getMarginSizeX", GetMarginSizeX);

	Nan::SetPrototypeMethod(tpl, "GetMarginSizeXMaxValue", GetMarginSizeXMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMarginSizeXMaxValue", GetMarginSizeXMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMarginSizeXMinValue", GetMarginSizeXMinValue);
	Nan::SetPrototypeMethod(tpl, "getMarginSizeXMinValue", GetMarginSizeXMinValue);

	Nan::SetPrototypeMethod(tpl, "GetMarginSizeY", GetMarginSizeY);
	Nan::SetPrototypeMethod(tpl, "getMarginSizeY", GetMarginSizeY);

	Nan::SetPrototypeMethod(tpl, "GetMarginSizeYMaxValue", GetMarginSizeYMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMarginSizeYMaxValue", GetMarginSizeYMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMarginSizeYMinValue", GetMarginSizeYMinValue);
	Nan::SetPrototypeMethod(tpl, "getMarginSizeYMinValue", GetMarginSizeYMinValue);

	Nan::SetPrototypeMethod(tpl, "GetMiddleButtonAction", GetMiddleButtonAction);
	Nan::SetPrototypeMethod(tpl, "getMiddleButtonAction", GetMiddleButtonAction);

	Nan::SetPrototypeMethod(tpl, "GetMiddleButtonActionMaxValue", GetMiddleButtonActionMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMiddleButtonActionMaxValue", GetMiddleButtonActionMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMiddleButtonActionMinValue", GetMiddleButtonActionMinValue);
	Nan::SetPrototypeMethod(tpl, "getMiddleButtonActionMinValue", GetMiddleButtonActionMinValue);

	Nan::SetPrototypeMethod(tpl, "GetMiddleButtonAutoModifier", GetMiddleButtonAutoModifier);
	Nan::SetPrototypeMethod(tpl, "getMiddleButtonAutoModifier", GetMiddleButtonAutoModifier);

	Nan::SetPrototypeMethod(tpl, "GetMiddleButtonAutoModifierMaxValue", GetMiddleButtonAutoModifierMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMiddleButtonAutoModifierMaxValue", GetMiddleButtonAutoModifierMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMiddleButtonAutoModifierMinValue", GetMiddleButtonAutoModifierMinValue);
	Nan::SetPrototypeMethod(tpl, "getMiddleButtonAutoModifierMinValue", GetMiddleButtonAutoModifierMinValue);

	Nan::SetPrototypeMethod(tpl, "GetNormal", GetNormal);
	Nan::SetPrototypeMethod(tpl, "getNormal", GetNormal);

	Nan::SetPrototypeMethod(tpl, "GetOrigin", GetOrigin);
	Nan::SetPrototypeMethod(tpl, "getOrigin", GetOrigin);

	Nan::SetPrototypeMethod(tpl, "GetPlaneOrientation", GetPlaneOrientation);
	Nan::SetPrototypeMethod(tpl, "getPlaneOrientation", GetPlaneOrientation);

	Nan::SetPrototypeMethod(tpl, "GetPlaneProperty", GetPlaneProperty);
	Nan::SetPrototypeMethod(tpl, "getPlaneProperty", GetPlaneProperty);

	Nan::SetPrototypeMethod(tpl, "GetPoint1", GetPoint1);
	Nan::SetPrototypeMethod(tpl, "getPoint1", GetPoint1);

	Nan::SetPrototypeMethod(tpl, "GetPoint2", GetPoint2);
	Nan::SetPrototypeMethod(tpl, "getPoint2", GetPoint2);

	Nan::SetPrototypeMethod(tpl, "GetPolyData", GetPolyData);
	Nan::SetPrototypeMethod(tpl, "getPolyData", GetPolyData);

	Nan::SetPrototypeMethod(tpl, "GetPolyDataAlgorithm", GetPolyDataAlgorithm);
	Nan::SetPrototypeMethod(tpl, "getPolyDataAlgorithm", GetPolyDataAlgorithm);

	Nan::SetPrototypeMethod(tpl, "GetReslice", GetReslice);
	Nan::SetPrototypeMethod(tpl, "getReslice", GetReslice);

	Nan::SetPrototypeMethod(tpl, "GetResliceAxes", GetResliceAxes);
	Nan::SetPrototypeMethod(tpl, "getResliceAxes", GetResliceAxes);

	Nan::SetPrototypeMethod(tpl, "GetResliceInterpolate", GetResliceInterpolate);
	Nan::SetPrototypeMethod(tpl, "getResliceInterpolate", GetResliceInterpolate);

	Nan::SetPrototypeMethod(tpl, "GetResliceOutput", GetResliceOutput);
	Nan::SetPrototypeMethod(tpl, "getResliceOutput", GetResliceOutput);

	Nan::SetPrototypeMethod(tpl, "GetRestrictPlaneToVolume", GetRestrictPlaneToVolume);
	Nan::SetPrototypeMethod(tpl, "getRestrictPlaneToVolume", GetRestrictPlaneToVolume);

	Nan::SetPrototypeMethod(tpl, "GetRightButtonAction", GetRightButtonAction);
	Nan::SetPrototypeMethod(tpl, "getRightButtonAction", GetRightButtonAction);

	Nan::SetPrototypeMethod(tpl, "GetRightButtonActionMaxValue", GetRightButtonActionMaxValue);
	Nan::SetPrototypeMethod(tpl, "getRightButtonActionMaxValue", GetRightButtonActionMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetRightButtonActionMinValue", GetRightButtonActionMinValue);
	Nan::SetPrototypeMethod(tpl, "getRightButtonActionMinValue", GetRightButtonActionMinValue);

	Nan::SetPrototypeMethod(tpl, "GetRightButtonAutoModifier", GetRightButtonAutoModifier);
	Nan::SetPrototypeMethod(tpl, "getRightButtonAutoModifier", GetRightButtonAutoModifier);

	Nan::SetPrototypeMethod(tpl, "GetRightButtonAutoModifierMaxValue", GetRightButtonAutoModifierMaxValue);
	Nan::SetPrototypeMethod(tpl, "getRightButtonAutoModifierMaxValue", GetRightButtonAutoModifierMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetRightButtonAutoModifierMinValue", GetRightButtonAutoModifierMinValue);
	Nan::SetPrototypeMethod(tpl, "getRightButtonAutoModifierMinValue", GetRightButtonAutoModifierMinValue);

	Nan::SetPrototypeMethod(tpl, "GetSelectedPlaneProperty", GetSelectedPlaneProperty);
	Nan::SetPrototypeMethod(tpl, "getSelectedPlaneProperty", GetSelectedPlaneProperty);

	Nan::SetPrototypeMethod(tpl, "GetSliceIndex", GetSliceIndex);
	Nan::SetPrototypeMethod(tpl, "getSliceIndex", GetSliceIndex);

	Nan::SetPrototypeMethod(tpl, "GetSlicePosition", GetSlicePosition);
	Nan::SetPrototypeMethod(tpl, "getSlicePosition", GetSlicePosition);

	Nan::SetPrototypeMethod(tpl, "GetTextProperty", GetTextProperty);
	Nan::SetPrototypeMethod(tpl, "getTextProperty", GetTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetTexture", GetTexture);
	Nan::SetPrototypeMethod(tpl, "getTexture", GetTexture);

	Nan::SetPrototypeMethod(tpl, "GetTextureInterpolate", GetTextureInterpolate);
	Nan::SetPrototypeMethod(tpl, "getTextureInterpolate", GetTextureInterpolate);

	Nan::SetPrototypeMethod(tpl, "GetTexturePlaneProperty", GetTexturePlaneProperty);
	Nan::SetPrototypeMethod(tpl, "getTexturePlaneProperty", GetTexturePlaneProperty);

	Nan::SetPrototypeMethod(tpl, "GetTextureVisibility", GetTextureVisibility);
	Nan::SetPrototypeMethod(tpl, "getTextureVisibility", GetTextureVisibility);

	Nan::SetPrototypeMethod(tpl, "GetUseContinuousCursor", GetUseContinuousCursor);
	Nan::SetPrototypeMethod(tpl, "getUseContinuousCursor", GetUseContinuousCursor);

	Nan::SetPrototypeMethod(tpl, "GetUserControlledLookupTable", GetUserControlledLookupTable);
	Nan::SetPrototypeMethod(tpl, "getUserControlledLookupTable", GetUserControlledLookupTable);

	Nan::SetPrototypeMethod(tpl, "GetVector1", GetVector1);
	Nan::SetPrototypeMethod(tpl, "getVector1", GetVector1);

	Nan::SetPrototypeMethod(tpl, "GetVector2", GetVector2);
	Nan::SetPrototypeMethod(tpl, "getVector2", GetVector2);

	Nan::SetPrototypeMethod(tpl, "GetWindow", GetWindow);
	Nan::SetPrototypeMethod(tpl, "getWindow", GetWindow);

	Nan::SetPrototypeMethod(tpl, "GetWindowLevel", GetWindowLevel);
	Nan::SetPrototypeMethod(tpl, "getWindowLevel", GetWindowLevel);

	Nan::SetPrototypeMethod(tpl, "InteractionOff", InteractionOff);
	Nan::SetPrototypeMethod(tpl, "interactionOff", InteractionOff);

	Nan::SetPrototypeMethod(tpl, "InteractionOn", InteractionOn);
	Nan::SetPrototypeMethod(tpl, "interactionOn", InteractionOn);

	Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
	Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);

	Nan::SetPrototypeMethod(tpl, "PlaceWidget", PlaceWidget);
	Nan::SetPrototypeMethod(tpl, "placeWidget", PlaceWidget);

	Nan::SetPrototypeMethod(tpl, "RestrictPlaneToVolumeOff", RestrictPlaneToVolumeOff);
	Nan::SetPrototypeMethod(tpl, "restrictPlaneToVolumeOff", RestrictPlaneToVolumeOff);

	Nan::SetPrototypeMethod(tpl, "RestrictPlaneToVolumeOn", RestrictPlaneToVolumeOn);
	Nan::SetPrototypeMethod(tpl, "restrictPlaneToVolumeOn", RestrictPlaneToVolumeOn);

	Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
	Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);

	Nan::SetPrototypeMethod(tpl, "SetColorMap", SetColorMap);
	Nan::SetPrototypeMethod(tpl, "setColorMap", SetColorMap);

	Nan::SetPrototypeMethod(tpl, "SetCursorProperty", SetCursorProperty);
	Nan::SetPrototypeMethod(tpl, "setCursorProperty", SetCursorProperty);

	Nan::SetPrototypeMethod(tpl, "SetDisplayText", SetDisplayText);
	Nan::SetPrototypeMethod(tpl, "setDisplayText", SetDisplayText);

	Nan::SetPrototypeMethod(tpl, "SetEnabled", SetEnabled);
	Nan::SetPrototypeMethod(tpl, "setEnabled", SetEnabled);

	Nan::SetPrototypeMethod(tpl, "SetInputConnection", SetInputConnection);
	Nan::SetPrototypeMethod(tpl, "setInputConnection", SetInputConnection);

	Nan::SetPrototypeMethod(tpl, "SetInteraction", SetInteraction);
	Nan::SetPrototypeMethod(tpl, "setInteraction", SetInteraction);

	Nan::SetPrototypeMethod(tpl, "SetLeftButtonAction", SetLeftButtonAction);
	Nan::SetPrototypeMethod(tpl, "setLeftButtonAction", SetLeftButtonAction);

	Nan::SetPrototypeMethod(tpl, "SetLeftButtonAutoModifier", SetLeftButtonAutoModifier);
	Nan::SetPrototypeMethod(tpl, "setLeftButtonAutoModifier", SetLeftButtonAutoModifier);

	Nan::SetPrototypeMethod(tpl, "SetLookupTable", SetLookupTable);
	Nan::SetPrototypeMethod(tpl, "setLookupTable", SetLookupTable);

	Nan::SetPrototypeMethod(tpl, "SetMarginProperty", SetMarginProperty);
	Nan::SetPrototypeMethod(tpl, "setMarginProperty", SetMarginProperty);

	Nan::SetPrototypeMethod(tpl, "SetMarginSizeX", SetMarginSizeX);
	Nan::SetPrototypeMethod(tpl, "setMarginSizeX", SetMarginSizeX);

	Nan::SetPrototypeMethod(tpl, "SetMarginSizeY", SetMarginSizeY);
	Nan::SetPrototypeMethod(tpl, "setMarginSizeY", SetMarginSizeY);

	Nan::SetPrototypeMethod(tpl, "SetMiddleButtonAction", SetMiddleButtonAction);
	Nan::SetPrototypeMethod(tpl, "setMiddleButtonAction", SetMiddleButtonAction);

	Nan::SetPrototypeMethod(tpl, "SetMiddleButtonAutoModifier", SetMiddleButtonAutoModifier);
	Nan::SetPrototypeMethod(tpl, "setMiddleButtonAutoModifier", SetMiddleButtonAutoModifier);

	Nan::SetPrototypeMethod(tpl, "SetOrigin", SetOrigin);
	Nan::SetPrototypeMethod(tpl, "setOrigin", SetOrigin);

	Nan::SetPrototypeMethod(tpl, "SetPicker", SetPicker);
	Nan::SetPrototypeMethod(tpl, "setPicker", SetPicker);

	Nan::SetPrototypeMethod(tpl, "SetPlaneOrientation", SetPlaneOrientation);
	Nan::SetPrototypeMethod(tpl, "setPlaneOrientation", SetPlaneOrientation);

	Nan::SetPrototypeMethod(tpl, "SetPlaneOrientationToXAxes", SetPlaneOrientationToXAxes);
	Nan::SetPrototypeMethod(tpl, "setPlaneOrientationToXAxes", SetPlaneOrientationToXAxes);

	Nan::SetPrototypeMethod(tpl, "SetPlaneOrientationToYAxes", SetPlaneOrientationToYAxes);
	Nan::SetPrototypeMethod(tpl, "setPlaneOrientationToYAxes", SetPlaneOrientationToYAxes);

	Nan::SetPrototypeMethod(tpl, "SetPlaneOrientationToZAxes", SetPlaneOrientationToZAxes);
	Nan::SetPrototypeMethod(tpl, "setPlaneOrientationToZAxes", SetPlaneOrientationToZAxes);

	Nan::SetPrototypeMethod(tpl, "SetPlaneProperty", SetPlaneProperty);
	Nan::SetPrototypeMethod(tpl, "setPlaneProperty", SetPlaneProperty);

	Nan::SetPrototypeMethod(tpl, "SetPoint1", SetPoint1);
	Nan::SetPrototypeMethod(tpl, "setPoint1", SetPoint1);

	Nan::SetPrototypeMethod(tpl, "SetPoint2", SetPoint2);
	Nan::SetPrototypeMethod(tpl, "setPoint2", SetPoint2);

	Nan::SetPrototypeMethod(tpl, "SetResliceInterpolate", SetResliceInterpolate);
	Nan::SetPrototypeMethod(tpl, "setResliceInterpolate", SetResliceInterpolate);

	Nan::SetPrototypeMethod(tpl, "SetResliceInterpolateToCubic", SetResliceInterpolateToCubic);
	Nan::SetPrototypeMethod(tpl, "setResliceInterpolateToCubic", SetResliceInterpolateToCubic);

	Nan::SetPrototypeMethod(tpl, "SetResliceInterpolateToLinear", SetResliceInterpolateToLinear);
	Nan::SetPrototypeMethod(tpl, "setResliceInterpolateToLinear", SetResliceInterpolateToLinear);

	Nan::SetPrototypeMethod(tpl, "SetResliceInterpolateToNearestNeighbour", SetResliceInterpolateToNearestNeighbour);
	Nan::SetPrototypeMethod(tpl, "setResliceInterpolateToNearestNeighbour", SetResliceInterpolateToNearestNeighbour);

	Nan::SetPrototypeMethod(tpl, "SetRestrictPlaneToVolume", SetRestrictPlaneToVolume);
	Nan::SetPrototypeMethod(tpl, "setRestrictPlaneToVolume", SetRestrictPlaneToVolume);

	Nan::SetPrototypeMethod(tpl, "SetRightButtonAction", SetRightButtonAction);
	Nan::SetPrototypeMethod(tpl, "setRightButtonAction", SetRightButtonAction);

	Nan::SetPrototypeMethod(tpl, "SetRightButtonAutoModifier", SetRightButtonAutoModifier);
	Nan::SetPrototypeMethod(tpl, "setRightButtonAutoModifier", SetRightButtonAutoModifier);

	Nan::SetPrototypeMethod(tpl, "SetSelectedPlaneProperty", SetSelectedPlaneProperty);
	Nan::SetPrototypeMethod(tpl, "setSelectedPlaneProperty", SetSelectedPlaneProperty);

	Nan::SetPrototypeMethod(tpl, "SetSliceIndex", SetSliceIndex);
	Nan::SetPrototypeMethod(tpl, "setSliceIndex", SetSliceIndex);

	Nan::SetPrototypeMethod(tpl, "SetSlicePosition", SetSlicePosition);
	Nan::SetPrototypeMethod(tpl, "setSlicePosition", SetSlicePosition);

	Nan::SetPrototypeMethod(tpl, "SetTextProperty", SetTextProperty);
	Nan::SetPrototypeMethod(tpl, "setTextProperty", SetTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetTextureInterpolate", SetTextureInterpolate);
	Nan::SetPrototypeMethod(tpl, "setTextureInterpolate", SetTextureInterpolate);

	Nan::SetPrototypeMethod(tpl, "SetTexturePlaneProperty", SetTexturePlaneProperty);
	Nan::SetPrototypeMethod(tpl, "setTexturePlaneProperty", SetTexturePlaneProperty);

	Nan::SetPrototypeMethod(tpl, "SetTextureVisibility", SetTextureVisibility);
	Nan::SetPrototypeMethod(tpl, "setTextureVisibility", SetTextureVisibility);

	Nan::SetPrototypeMethod(tpl, "SetUseContinuousCursor", SetUseContinuousCursor);
	Nan::SetPrototypeMethod(tpl, "setUseContinuousCursor", SetUseContinuousCursor);

	Nan::SetPrototypeMethod(tpl, "SetUserControlledLookupTable", SetUserControlledLookupTable);
	Nan::SetPrototypeMethod(tpl, "setUserControlledLookupTable", SetUserControlledLookupTable);

	Nan::SetPrototypeMethod(tpl, "SetWindowLevel", SetWindowLevel);
	Nan::SetPrototypeMethod(tpl, "setWindowLevel", SetWindowLevel);

	Nan::SetPrototypeMethod(tpl, "TextureInterpolateOff", TextureInterpolateOff);
	Nan::SetPrototypeMethod(tpl, "textureInterpolateOff", TextureInterpolateOff);

	Nan::SetPrototypeMethod(tpl, "TextureInterpolateOn", TextureInterpolateOn);
	Nan::SetPrototypeMethod(tpl, "textureInterpolateOn", TextureInterpolateOn);

	Nan::SetPrototypeMethod(tpl, "TextureVisibilityOff", TextureVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "textureVisibilityOff", TextureVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "TextureVisibilityOn", TextureVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "textureVisibilityOn", TextureVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "UpdatePlacement", UpdatePlacement);
	Nan::SetPrototypeMethod(tpl, "updatePlacement", UpdatePlacement);

	Nan::SetPrototypeMethod(tpl, "UseContinuousCursorOff", UseContinuousCursorOff);
	Nan::SetPrototypeMethod(tpl, "useContinuousCursorOff", UseContinuousCursorOff);

	Nan::SetPrototypeMethod(tpl, "UseContinuousCursorOn", UseContinuousCursorOn);
	Nan::SetPrototypeMethod(tpl, "useContinuousCursorOn", UseContinuousCursorOn);

	Nan::SetPrototypeMethod(tpl, "UserControlledLookupTableOff", UserControlledLookupTableOff);
	Nan::SetPrototypeMethod(tpl, "userControlledLookupTableOff", UserControlledLookupTableOff);

	Nan::SetPrototypeMethod(tpl, "UserControlledLookupTableOn", UserControlledLookupTableOn);
	Nan::SetPrototypeMethod(tpl, "userControlledLookupTableOn", UserControlledLookupTableOn);

#ifdef VTK_NODE_PLUS_VTKIMAGEPLANEWIDGETWRAP_INITPTPL
	VTK_NODE_PLUS_VTKIMAGEPLANEWIDGETWRAP_INITPTPL
#endif
	ptpl.Reset( tpl );
}

void VtkImagePlaneWidgetWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	if(!info.IsConstructCall())
	{
		Nan::ThrowError("Constructor not called in a construct call.");
		return;
	}

	if(info.Length() == 0)
	{
		vtkSmartPointer<vtkImagePlaneWidget> native = vtkSmartPointer<vtkImagePlaneWidget>::New();
		VtkImagePlaneWidgetWrap* obj = new VtkImagePlaneWidgetWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

	info.GetReturnValue().Set(info.This());
}

void VtkImagePlaneWidgetWrap::DisplayTextOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->DisplayTextOff();
}

void VtkImagePlaneWidgetWrap::DisplayTextOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->DisplayTextOn();
}

void VtkImagePlaneWidgetWrap::GetCenter(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetCenter(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetCenter(
			b0
		);
		return;
	}
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetCenter();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkImagePlaneWidgetWrap::GetColorMap(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkImageMapToColors * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetColorMap();
	VtkImageMapToColorsWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkImageMapToColorsWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkImageMapToColorsWrap *w = new VtkImageMapToColorsWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetCurrentCursorPosition(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetCurrentCursorPosition();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkImagePlaneWidgetWrap::GetCurrentImageValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetCurrentImageValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetCursorData(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 4 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetCursorData(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[4];
		if( a0->Length() < 4 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 4; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetCursorData(
			b0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::GetCursorDataStatus(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetCursorDataStatus();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetCursorProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetCursorProperty();
	VtkPropertyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkPropertyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkPropertyWrap *w = new VtkPropertyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetDisplayText(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetDisplayText();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetInteraction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetInteraction();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetLeftButtonAction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLeftButtonAction();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetLeftButtonActionMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLeftButtonActionMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetLeftButtonActionMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLeftButtonActionMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetLeftButtonAutoModifier(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLeftButtonAutoModifier();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetLeftButtonAutoModifierMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLeftButtonAutoModifierMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetLeftButtonAutoModifierMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLeftButtonAutoModifierMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetLevel(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLevel();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetLookupTable(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkLookupTable * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLookupTable();
	VtkLookupTableWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkLookupTableWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkLookupTableWrap *w = new VtkLookupTableWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetMarginProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMarginProperty();
	VtkPropertyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkPropertyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkPropertyWrap *w = new VtkPropertyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetMarginSizeX(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMarginSizeX();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMarginSizeXMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMarginSizeXMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMarginSizeXMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMarginSizeXMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMarginSizeY(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMarginSizeY();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMarginSizeYMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMarginSizeYMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMarginSizeYMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMarginSizeYMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMiddleButtonAction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMiddleButtonAction();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMiddleButtonActionMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMiddleButtonActionMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMiddleButtonActionMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMiddleButtonActionMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMiddleButtonAutoModifier(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMiddleButtonAutoModifier();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMiddleButtonAutoModifierMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMiddleButtonAutoModifierMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetMiddleButtonAutoModifierMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMiddleButtonAutoModifierMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetNormal(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetNormal(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetNormal(
			b0
		);
		return;
	}
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNormal();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkImagePlaneWidgetWrap::GetOrigin(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetOrigin(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetOrigin(
			b0
		);
		return;
	}
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetOrigin();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkImagePlaneWidgetWrap::GetPlaneOrientation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetPlaneOrientation();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetPlaneProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetPlaneProperty();
	VtkPropertyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkPropertyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkPropertyWrap *w = new VtkPropertyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetPoint1(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetPoint1(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetPoint1(
			b0
		);
		return;
	}
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetPoint1();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkImagePlaneWidgetWrap::GetPoint2(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetPoint2(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetPoint2(
			b0
		);
		return;
	}
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetPoint2();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkImagePlaneWidgetWrap::GetPolyData(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPolyDataWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPolyDataWrap *a0 = ObjectWrap::Unwrap<VtkPolyDataWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetPolyData(
			(vtkPolyData *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::GetPolyDataAlgorithm(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkPolyDataAlgorithm * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetPolyDataAlgorithm();
	VtkPolyDataAlgorithmWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkPolyDataAlgorithmWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkPolyDataAlgorithmWrap *w = new VtkPolyDataAlgorithmWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetReslice(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkImageReslice * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetReslice();
	VtkImageResliceWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkImageResliceWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkImageResliceWrap *w = new VtkImageResliceWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetResliceAxes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkMatrix4x4 * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetResliceAxes();
	VtkMatrix4x4Wrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkMatrix4x4Wrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkMatrix4x4Wrap *w = new VtkMatrix4x4Wrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetResliceInterpolate(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetResliceInterpolate();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetResliceOutput(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkImageData * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetResliceOutput();
	VtkImageDataWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkImageDataWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkImageDataWrap *w = new VtkImageDataWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetRestrictPlaneToVolume(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetRestrictPlaneToVolume();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetRightButtonAction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetRightButtonAction();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetRightButtonActionMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetRightButtonActionMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetRightButtonActionMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetRightButtonActionMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetRightButtonAutoModifier(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetRightButtonAutoModifier();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetRightButtonAutoModifierMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetRightButtonAutoModifierMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetRightButtonAutoModifierMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetRightButtonAutoModifierMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetSelectedPlaneProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSelectedPlaneProperty();
	VtkPropertyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkPropertyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkPropertyWrap *w = new VtkPropertyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetSliceIndex(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSliceIndex();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetSlicePosition(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSlicePosition();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkTextProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTextProperty();
	VtkTextPropertyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkTextPropertyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkTextPropertyWrap *w = new VtkTextPropertyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetTexture(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkTexture * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTexture();
	VtkTextureWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkTextureWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkTextureWrap *w = new VtkTextureWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetTextureInterpolate(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTextureInterpolate();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetTexturePlaneProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTexturePlaneProperty();
	VtkPropertyWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkPropertyWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkPropertyWrap *w = new VtkPropertyWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::GetTextureVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTextureVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetUseContinuousCursor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetUseContinuousCursor();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetUserControlledLookupTable(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetUserControlledLookupTable();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetVector1(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetVector1(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetVector1(
			b0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::GetVector2(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetVector2(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetVector2(
			b0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::GetWindow(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetWindow();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkImagePlaneWidgetWrap::GetWindowLevel(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetWindowLevel(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->GetWindowLevel(
			b0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::InteractionOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->InteractionOff();
}

void VtkImagePlaneWidgetWrap::InteractionOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->InteractionOn();
}

void VtkImagePlaneWidgetWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	vtkImagePlaneWidget * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->NewInstance();
	VtkImagePlaneWidgetWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkImagePlaneWidgetWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkImagePlaneWidgetWrap *w = new VtkImagePlaneWidgetWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkImagePlaneWidgetWrap::PlaceWidget(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 6 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->PlaceWidget(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[6];
		if( a0->Length() < 6 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 6; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->PlaceWidget(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				if(info.Length() > 3 && info[3]->IsNumber())
				{
					if(info.Length() > 4 && info[4]->IsNumber())
					{
						if(info.Length() > 5 && info[5]->IsNumber())
						{
														if(info.Length() != 6)
							{
								Nan::ThrowError("Too many parameters.");
								return;
							}
							native->PlaceWidget(
								info[0]->NumberValue(),
								info[1]->NumberValue(),
								info[2]->NumberValue(),
								info[3]->NumberValue(),
								info[4]->NumberValue(),
								info[5]->NumberValue()
							);
							return;
						}
					}
				}
			}
		}
	}
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->PlaceWidget();
}

void VtkImagePlaneWidgetWrap::RestrictPlaneToVolumeOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->RestrictPlaneToVolumeOff();
}

void VtkImagePlaneWidgetWrap::RestrictPlaneToVolumeOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->RestrictPlaneToVolumeOn();
}

void VtkImagePlaneWidgetWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectBaseWrap::ptpl))->HasInstance(info[0]))
	{
		VtkObjectBaseWrap *a0 = ObjectWrap::Unwrap<VtkObjectBaseWrap>(info[0]->ToObject());
		vtkImagePlaneWidget * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->SafeDownCast(
			(vtkObjectBase *) a0->native.GetPointer()
		);
		VtkImagePlaneWidgetWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkImagePlaneWidgetWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkImagePlaneWidgetWrap *w = new VtkImagePlaneWidgetWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetColorMap(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkImageMapToColorsWrap::ptpl))->HasInstance(info[0]))
	{
		VtkImageMapToColorsWrap *a0 = ObjectWrap::Unwrap<VtkImageMapToColorsWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetColorMap(
			(vtkImageMapToColors *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetCursorProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPropertyWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPropertyWrap *a0 = ObjectWrap::Unwrap<VtkPropertyWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetCursorProperty(
			(vtkProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetDisplayText(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetDisplayText(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetEnabled(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetEnabled(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetInputConnection(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkAlgorithmOutputWrap::ptpl))->HasInstance(info[0]))
	{
		VtkAlgorithmOutputWrap *a0 = ObjectWrap::Unwrap<VtkAlgorithmOutputWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetInputConnection(
			(vtkAlgorithmOutput *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetInteraction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetInteraction(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetLeftButtonAction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLeftButtonAction(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetLeftButtonAutoModifier(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLeftButtonAutoModifier(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetLookupTable(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkLookupTableWrap::ptpl))->HasInstance(info[0]))
	{
		VtkLookupTableWrap *a0 = ObjectWrap::Unwrap<VtkLookupTableWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLookupTable(
			(vtkLookupTable *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetMarginProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPropertyWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPropertyWrap *a0 = ObjectWrap::Unwrap<VtkPropertyWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMarginProperty(
			(vtkProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetMarginSizeX(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMarginSizeX(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetMarginSizeY(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMarginSizeY(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetMiddleButtonAction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMiddleButtonAction(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetMiddleButtonAutoModifier(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMiddleButtonAutoModifier(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetOrigin(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetOrigin(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetOrigin(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetOrigin(
					info[0]->NumberValue(),
					info[1]->NumberValue(),
					info[2]->NumberValue()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetPicker(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkAbstractPropPickerWrap::ptpl))->HasInstance(info[0]))
	{
		VtkAbstractPropPickerWrap *a0 = ObjectWrap::Unwrap<VtkAbstractPropPickerWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPicker(
			(vtkAbstractPropPicker *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetPlaneOrientation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPlaneOrientation(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetPlaneOrientationToXAxes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetPlaneOrientationToXAxes();
}

void VtkImagePlaneWidgetWrap::SetPlaneOrientationToYAxes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetPlaneOrientationToYAxes();
}

void VtkImagePlaneWidgetWrap::SetPlaneOrientationToZAxes(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetPlaneOrientationToZAxes();
}

void VtkImagePlaneWidgetWrap::SetPlaneProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPropertyWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPropertyWrap *a0 = ObjectWrap::Unwrap<VtkPropertyWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPlaneProperty(
			(vtkProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetPoint1(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPoint1(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPoint1(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetPoint1(
					info[0]->NumberValue(),
					info[1]->NumberValue(),
					info[2]->NumberValue()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetPoint2(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPoint2(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPoint2(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetPoint2(
					info[0]->NumberValue(),
					info[1]->NumberValue(),
					info[2]->NumberValue()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetResliceInterpolate(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetResliceInterpolate(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetResliceInterpolateToCubic(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetResliceInterpolateToCubic();
}

void VtkImagePlaneWidgetWrap::SetResliceInterpolateToLinear(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetResliceInterpolateToLinear();
}

void VtkImagePlaneWidgetWrap::SetResliceInterpolateToNearestNeighbour(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetResliceInterpolateToNearestNeighbour();
}

void VtkImagePlaneWidgetWrap::SetRestrictPlaneToVolume(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetRestrictPlaneToVolume(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetRightButtonAction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetRightButtonAction(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetRightButtonAutoModifier(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetRightButtonAutoModifier(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetSelectedPlaneProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPropertyWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPropertyWrap *a0 = ObjectWrap::Unwrap<VtkPropertyWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSelectedPlaneProperty(
			(vtkProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetSliceIndex(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSliceIndex(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetSlicePosition(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSlicePosition(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetTextProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkTextPropertyWrap::ptpl))->HasInstance(info[0]))
	{
		VtkTextPropertyWrap *a0 = ObjectWrap::Unwrap<VtkTextPropertyWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetTextProperty(
			(vtkTextProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetTextureInterpolate(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetTextureInterpolate(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetTexturePlaneProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPropertyWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPropertyWrap *a0 = ObjectWrap::Unwrap<VtkPropertyWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetTexturePlaneProperty(
			(vtkProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetTextureVisibility(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetTextureVisibility(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetUseContinuousCursor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetUseContinuousCursor(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetUserControlledLookupTable(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetUserControlledLookupTable(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::SetWindowLevel(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsInt32())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetWindowLevel(
					info[0]->NumberValue(),
					info[1]->NumberValue(),
					info[2]->Int32Value()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePlaneWidgetWrap::TextureInterpolateOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->TextureInterpolateOff();
}

void VtkImagePlaneWidgetWrap::TextureInterpolateOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->TextureInterpolateOn();
}

void VtkImagePlaneWidgetWrap::TextureVisibilityOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->TextureVisibilityOff();
}

void VtkImagePlaneWidgetWrap::TextureVisibilityOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->TextureVisibilityOn();
}

void VtkImagePlaneWidgetWrap::UpdatePlacement(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UpdatePlacement();
}

void VtkImagePlaneWidgetWrap::UseContinuousCursorOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UseContinuousCursorOff();
}

void VtkImagePlaneWidgetWrap::UseContinuousCursorOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UseContinuousCursorOn();
}

void VtkImagePlaneWidgetWrap::UserControlledLookupTableOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UserControlledLookupTableOff();
}

void VtkImagePlaneWidgetWrap::UserControlledLookupTableOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePlaneWidgetWrap *wrapper = ObjectWrap::Unwrap<VtkImagePlaneWidgetWrap>(info.Holder());
	vtkImagePlaneWidget *native = (vtkImagePlaneWidget *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->UserControlledLookupTableOn();
}