/* 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 "vtkObjectWrap.h"
#include "vtkImagePropertyWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkScalarsToColorsWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkImagePropertyWrap::VtkImagePropertyWrap()
{ }

VtkImagePropertyWrap::VtkImagePropertyWrap(vtkSmartPointer<vtkImageProperty> _native)
{ native = _native; }

VtkImagePropertyWrap::~VtkImagePropertyWrap()
{ }

void VtkImagePropertyWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkImageProperty").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("ImageProperty").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "BackingOff", BackingOff);
	Nan::SetPrototypeMethod(tpl, "backingOff", BackingOff);

	Nan::SetPrototypeMethod(tpl, "BackingOn", BackingOn);
	Nan::SetPrototypeMethod(tpl, "backingOn", BackingOn);

	Nan::SetPrototypeMethod(tpl, "CheckerboardOff", CheckerboardOff);
	Nan::SetPrototypeMethod(tpl, "checkerboardOff", CheckerboardOff);

	Nan::SetPrototypeMethod(tpl, "CheckerboardOn", CheckerboardOn);
	Nan::SetPrototypeMethod(tpl, "checkerboardOn", CheckerboardOn);

	Nan::SetPrototypeMethod(tpl, "DeepCopy", DeepCopy);
	Nan::SetPrototypeMethod(tpl, "deepCopy", DeepCopy);

	Nan::SetPrototypeMethod(tpl, "GetAmbient", GetAmbient);
	Nan::SetPrototypeMethod(tpl, "getAmbient", GetAmbient);

	Nan::SetPrototypeMethod(tpl, "GetAmbientMaxValue", GetAmbientMaxValue);
	Nan::SetPrototypeMethod(tpl, "getAmbientMaxValue", GetAmbientMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetAmbientMinValue", GetAmbientMinValue);
	Nan::SetPrototypeMethod(tpl, "getAmbientMinValue", GetAmbientMinValue);

	Nan::SetPrototypeMethod(tpl, "GetBacking", GetBacking);
	Nan::SetPrototypeMethod(tpl, "getBacking", GetBacking);

	Nan::SetPrototypeMethod(tpl, "GetBackingColor", GetBackingColor);
	Nan::SetPrototypeMethod(tpl, "getBackingColor", GetBackingColor);

	Nan::SetPrototypeMethod(tpl, "GetCheckerboard", GetCheckerboard);
	Nan::SetPrototypeMethod(tpl, "getCheckerboard", GetCheckerboard);

	Nan::SetPrototypeMethod(tpl, "GetCheckerboardOffset", GetCheckerboardOffset);
	Nan::SetPrototypeMethod(tpl, "getCheckerboardOffset", GetCheckerboardOffset);

	Nan::SetPrototypeMethod(tpl, "GetCheckerboardSpacing", GetCheckerboardSpacing);
	Nan::SetPrototypeMethod(tpl, "getCheckerboardSpacing", GetCheckerboardSpacing);

	Nan::SetPrototypeMethod(tpl, "GetColorLevel", GetColorLevel);
	Nan::SetPrototypeMethod(tpl, "getColorLevel", GetColorLevel);

	Nan::SetPrototypeMethod(tpl, "GetColorWindow", GetColorWindow);
	Nan::SetPrototypeMethod(tpl, "getColorWindow", GetColorWindow);

	Nan::SetPrototypeMethod(tpl, "GetDiffuse", GetDiffuse);
	Nan::SetPrototypeMethod(tpl, "getDiffuse", GetDiffuse);

	Nan::SetPrototypeMethod(tpl, "GetDiffuseMaxValue", GetDiffuseMaxValue);
	Nan::SetPrototypeMethod(tpl, "getDiffuseMaxValue", GetDiffuseMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetDiffuseMinValue", GetDiffuseMinValue);
	Nan::SetPrototypeMethod(tpl, "getDiffuseMinValue", GetDiffuseMinValue);

	Nan::SetPrototypeMethod(tpl, "GetInterpolationType", GetInterpolationType);
	Nan::SetPrototypeMethod(tpl, "getInterpolationType", GetInterpolationType);

	Nan::SetPrototypeMethod(tpl, "GetInterpolationTypeAsString", GetInterpolationTypeAsString);
	Nan::SetPrototypeMethod(tpl, "getInterpolationTypeAsString", GetInterpolationTypeAsString);

	Nan::SetPrototypeMethod(tpl, "GetInterpolationTypeMaxValue", GetInterpolationTypeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getInterpolationTypeMaxValue", GetInterpolationTypeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetInterpolationTypeMinValue", GetInterpolationTypeMinValue);
	Nan::SetPrototypeMethod(tpl, "getInterpolationTypeMinValue", GetInterpolationTypeMinValue);

	Nan::SetPrototypeMethod(tpl, "GetLayerNumber", GetLayerNumber);
	Nan::SetPrototypeMethod(tpl, "getLayerNumber", GetLayerNumber);

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

	Nan::SetPrototypeMethod(tpl, "GetOpacity", GetOpacity);
	Nan::SetPrototypeMethod(tpl, "getOpacity", GetOpacity);

	Nan::SetPrototypeMethod(tpl, "GetOpacityMaxValue", GetOpacityMaxValue);
	Nan::SetPrototypeMethod(tpl, "getOpacityMaxValue", GetOpacityMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetOpacityMinValue", GetOpacityMinValue);
	Nan::SetPrototypeMethod(tpl, "getOpacityMinValue", GetOpacityMinValue);

	Nan::SetPrototypeMethod(tpl, "GetUseLookupTableScalarRange", GetUseLookupTableScalarRange);
	Nan::SetPrototypeMethod(tpl, "getUseLookupTableScalarRange", GetUseLookupTableScalarRange);

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

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

	Nan::SetPrototypeMethod(tpl, "SetAmbient", SetAmbient);
	Nan::SetPrototypeMethod(tpl, "setAmbient", SetAmbient);

	Nan::SetPrototypeMethod(tpl, "SetBacking", SetBacking);
	Nan::SetPrototypeMethod(tpl, "setBacking", SetBacking);

	Nan::SetPrototypeMethod(tpl, "SetBackingColor", SetBackingColor);
	Nan::SetPrototypeMethod(tpl, "setBackingColor", SetBackingColor);

	Nan::SetPrototypeMethod(tpl, "SetCheckerboard", SetCheckerboard);
	Nan::SetPrototypeMethod(tpl, "setCheckerboard", SetCheckerboard);

	Nan::SetPrototypeMethod(tpl, "SetCheckerboardOffset", SetCheckerboardOffset);
	Nan::SetPrototypeMethod(tpl, "setCheckerboardOffset", SetCheckerboardOffset);

	Nan::SetPrototypeMethod(tpl, "SetCheckerboardSpacing", SetCheckerboardSpacing);
	Nan::SetPrototypeMethod(tpl, "setCheckerboardSpacing", SetCheckerboardSpacing);

	Nan::SetPrototypeMethod(tpl, "SetColorLevel", SetColorLevel);
	Nan::SetPrototypeMethod(tpl, "setColorLevel", SetColorLevel);

	Nan::SetPrototypeMethod(tpl, "SetColorWindow", SetColorWindow);
	Nan::SetPrototypeMethod(tpl, "setColorWindow", SetColorWindow);

	Nan::SetPrototypeMethod(tpl, "SetDiffuse", SetDiffuse);
	Nan::SetPrototypeMethod(tpl, "setDiffuse", SetDiffuse);

	Nan::SetPrototypeMethod(tpl, "SetInterpolationType", SetInterpolationType);
	Nan::SetPrototypeMethod(tpl, "setInterpolationType", SetInterpolationType);

	Nan::SetPrototypeMethod(tpl, "SetInterpolationTypeToCubic", SetInterpolationTypeToCubic);
	Nan::SetPrototypeMethod(tpl, "setInterpolationTypeToCubic", SetInterpolationTypeToCubic);

	Nan::SetPrototypeMethod(tpl, "SetInterpolationTypeToLinear", SetInterpolationTypeToLinear);
	Nan::SetPrototypeMethod(tpl, "setInterpolationTypeToLinear", SetInterpolationTypeToLinear);

	Nan::SetPrototypeMethod(tpl, "SetInterpolationTypeToNearest", SetInterpolationTypeToNearest);
	Nan::SetPrototypeMethod(tpl, "setInterpolationTypeToNearest", SetInterpolationTypeToNearest);

	Nan::SetPrototypeMethod(tpl, "SetLayerNumber", SetLayerNumber);
	Nan::SetPrototypeMethod(tpl, "setLayerNumber", SetLayerNumber);

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

	Nan::SetPrototypeMethod(tpl, "SetOpacity", SetOpacity);
	Nan::SetPrototypeMethod(tpl, "setOpacity", SetOpacity);

	Nan::SetPrototypeMethod(tpl, "SetUseLookupTableScalarRange", SetUseLookupTableScalarRange);
	Nan::SetPrototypeMethod(tpl, "setUseLookupTableScalarRange", SetUseLookupTableScalarRange);

	Nan::SetPrototypeMethod(tpl, "UseLookupTableScalarRangeOff", UseLookupTableScalarRangeOff);
	Nan::SetPrototypeMethod(tpl, "useLookupTableScalarRangeOff", UseLookupTableScalarRangeOff);

	Nan::SetPrototypeMethod(tpl, "UseLookupTableScalarRangeOn", UseLookupTableScalarRangeOn);
	Nan::SetPrototypeMethod(tpl, "useLookupTableScalarRangeOn", UseLookupTableScalarRangeOn);

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

void VtkImagePropertyWrap::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<vtkImageProperty> native = vtkSmartPointer<vtkImageProperty>::New();
		VtkImagePropertyWrap* obj = new VtkImagePropertyWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

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

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

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

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

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

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

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

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

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

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

void VtkImagePropertyWrap::GetBackingColor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkImagePropertyWrap>(info.Holder());
	vtkImageProperty *native = (vtkImageProperty *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetBackingColor();
	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 VtkImagePropertyWrap::GetCheckerboard(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkImagePropertyWrap>(info.Holder());
	vtkImageProperty *native = (vtkImageProperty *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetCheckerboard();
	info.GetReturnValue().Set(Nan::New(r));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkImagePropertyWrap::SetBackingColor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkImagePropertyWrap>(info.Holder());
	vtkImageProperty *native = (vtkImageProperty *)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->SetBackingColor(
			(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->SetBackingColor(
			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->SetBackingColor(
					info[0]->NumberValue(),
					info[1]->NumberValue(),
					info[2]->NumberValue()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

void VtkImagePropertyWrap::SetCheckerboardOffset(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkImagePropertyWrap>(info.Holder());
	vtkImageProperty *native = (vtkImageProperty *)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->SetCheckerboardOffset(
			(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->SetCheckerboardOffset(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetCheckerboardOffset(
				info[0]->NumberValue(),
				info[1]->NumberValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImagePropertyWrap::SetCheckerboardSpacing(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImagePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkImagePropertyWrap>(info.Holder());
	vtkImageProperty *native = (vtkImageProperty *)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->SetCheckerboardSpacing(
			(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->SetCheckerboardSpacing(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetCheckerboardSpacing(
				info[0]->NumberValue(),
				info[1]->NumberValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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