/* 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 "vtkVolumePropertyWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkPiecewiseFunctionWrap.h"
#include "vtkColorTransferFunctionWrap.h"
#include "vtkImageDataWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkVolumePropertyWrap::VtkVolumePropertyWrap()
{ }

VtkVolumePropertyWrap::VtkVolumePropertyWrap(vtkSmartPointer<vtkVolumeProperty> _native)
{ native = _native; }

VtkVolumePropertyWrap::~VtkVolumePropertyWrap()
{ }

void VtkVolumePropertyWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkVolumeProperty").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("VolumeProperty").ToLocalChecked(), ConstructorGetter);
}

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

void VtkVolumePropertyWrap::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("VtkVolumePropertyWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

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

	Nan::SetPrototypeMethod(tpl, "DisableGradientOpacityOff", DisableGradientOpacityOff);
	Nan::SetPrototypeMethod(tpl, "disableGradientOpacityOff", DisableGradientOpacityOff);

	Nan::SetPrototypeMethod(tpl, "DisableGradientOpacityOn", DisableGradientOpacityOn);
	Nan::SetPrototypeMethod(tpl, "disableGradientOpacityOn", DisableGradientOpacityOn);

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

	Nan::SetPrototypeMethod(tpl, "GetColorChannels", GetColorChannels);
	Nan::SetPrototypeMethod(tpl, "getColorChannels", GetColorChannels);

	Nan::SetPrototypeMethod(tpl, "GetComponentWeight", GetComponentWeight);
	Nan::SetPrototypeMethod(tpl, "getComponentWeight", GetComponentWeight);

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

	Nan::SetPrototypeMethod(tpl, "GetDisableGradientOpacity", GetDisableGradientOpacity);
	Nan::SetPrototypeMethod(tpl, "getDisableGradientOpacity", GetDisableGradientOpacity);

	Nan::SetPrototypeMethod(tpl, "GetGradientOpacity", GetGradientOpacity);
	Nan::SetPrototypeMethod(tpl, "getGradientOpacity", GetGradientOpacity);

	Nan::SetPrototypeMethod(tpl, "GetGrayTransferFunction", GetGrayTransferFunction);
	Nan::SetPrototypeMethod(tpl, "getGrayTransferFunction", GetGrayTransferFunction);

	Nan::SetPrototypeMethod(tpl, "GetIndependentComponents", GetIndependentComponents);
	Nan::SetPrototypeMethod(tpl, "getIndependentComponents", GetIndependentComponents);

	Nan::SetPrototypeMethod(tpl, "GetIndependentComponentsMaxValue", GetIndependentComponentsMaxValue);
	Nan::SetPrototypeMethod(tpl, "getIndependentComponentsMaxValue", GetIndependentComponentsMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetIndependentComponentsMinValue", GetIndependentComponentsMinValue);
	Nan::SetPrototypeMethod(tpl, "getIndependentComponentsMinValue", GetIndependentComponentsMinValue);

	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, "GetRGBTransferFunction", GetRGBTransferFunction);
	Nan::SetPrototypeMethod(tpl, "getRGBTransferFunction", GetRGBTransferFunction);

	Nan::SetPrototypeMethod(tpl, "GetScalarOpacity", GetScalarOpacity);
	Nan::SetPrototypeMethod(tpl, "getScalarOpacity", GetScalarOpacity);

	Nan::SetPrototypeMethod(tpl, "GetScalarOpacityUnitDistance", GetScalarOpacityUnitDistance);
	Nan::SetPrototypeMethod(tpl, "getScalarOpacityUnitDistance", GetScalarOpacityUnitDistance);

	Nan::SetPrototypeMethod(tpl, "GetShade", GetShade);
	Nan::SetPrototypeMethod(tpl, "getShade", GetShade);

	Nan::SetPrototypeMethod(tpl, "GetSpecular", GetSpecular);
	Nan::SetPrototypeMethod(tpl, "getSpecular", GetSpecular);

	Nan::SetPrototypeMethod(tpl, "GetSpecularPower", GetSpecularPower);
	Nan::SetPrototypeMethod(tpl, "getSpecularPower", GetSpecularPower);

	Nan::SetPrototypeMethod(tpl, "GetStoredGradientOpacity", GetStoredGradientOpacity);
	Nan::SetPrototypeMethod(tpl, "getStoredGradientOpacity", GetStoredGradientOpacity);

	Nan::SetPrototypeMethod(tpl, "GetTransferFunction2D", GetTransferFunction2D);
	Nan::SetPrototypeMethod(tpl, "getTransferFunction2D", GetTransferFunction2D);

	Nan::SetPrototypeMethod(tpl, "GetTransferFunctionMode", GetTransferFunctionMode);
	Nan::SetPrototypeMethod(tpl, "getTransferFunctionMode", GetTransferFunctionMode);

	Nan::SetPrototypeMethod(tpl, "GetTransferFunctionModeMaxValue", GetTransferFunctionModeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getTransferFunctionModeMaxValue", GetTransferFunctionModeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetTransferFunctionModeMinValue", GetTransferFunctionModeMinValue);
	Nan::SetPrototypeMethod(tpl, "getTransferFunctionModeMinValue", GetTransferFunctionModeMinValue);

	Nan::SetPrototypeMethod(tpl, "HasGradientOpacity", HasGradientOpacity);
	Nan::SetPrototypeMethod(tpl, "hasGradientOpacity", HasGradientOpacity);

	Nan::SetPrototypeMethod(tpl, "IndependentComponentsOff", IndependentComponentsOff);
	Nan::SetPrototypeMethod(tpl, "independentComponentsOff", IndependentComponentsOff);

	Nan::SetPrototypeMethod(tpl, "IndependentComponentsOn", IndependentComponentsOn);
	Nan::SetPrototypeMethod(tpl, "independentComponentsOn", IndependentComponentsOn);

	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, "SetColor", SetColor);
	Nan::SetPrototypeMethod(tpl, "setColor", SetColor);

	Nan::SetPrototypeMethod(tpl, "SetComponentWeight", SetComponentWeight);
	Nan::SetPrototypeMethod(tpl, "setComponentWeight", SetComponentWeight);

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

	Nan::SetPrototypeMethod(tpl, "SetDisableGradientOpacity", SetDisableGradientOpacity);
	Nan::SetPrototypeMethod(tpl, "setDisableGradientOpacity", SetDisableGradientOpacity);

	Nan::SetPrototypeMethod(tpl, "SetGradientOpacity", SetGradientOpacity);
	Nan::SetPrototypeMethod(tpl, "setGradientOpacity", SetGradientOpacity);

	Nan::SetPrototypeMethod(tpl, "SetIndependentComponents", SetIndependentComponents);
	Nan::SetPrototypeMethod(tpl, "setIndependentComponents", SetIndependentComponents);

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

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

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

	Nan::SetPrototypeMethod(tpl, "SetScalarOpacity", SetScalarOpacity);
	Nan::SetPrototypeMethod(tpl, "setScalarOpacity", SetScalarOpacity);

	Nan::SetPrototypeMethod(tpl, "SetScalarOpacityUnitDistance", SetScalarOpacityUnitDistance);
	Nan::SetPrototypeMethod(tpl, "setScalarOpacityUnitDistance", SetScalarOpacityUnitDistance);

	Nan::SetPrototypeMethod(tpl, "SetShade", SetShade);
	Nan::SetPrototypeMethod(tpl, "setShade", SetShade);

	Nan::SetPrototypeMethod(tpl, "SetSpecular", SetSpecular);
	Nan::SetPrototypeMethod(tpl, "setSpecular", SetSpecular);

	Nan::SetPrototypeMethod(tpl, "SetSpecularPower", SetSpecularPower);
	Nan::SetPrototypeMethod(tpl, "setSpecularPower", SetSpecularPower);

	Nan::SetPrototypeMethod(tpl, "SetTransferFunction2D", SetTransferFunction2D);
	Nan::SetPrototypeMethod(tpl, "setTransferFunction2D", SetTransferFunction2D);

	Nan::SetPrototypeMethod(tpl, "SetTransferFunctionMode", SetTransferFunctionMode);
	Nan::SetPrototypeMethod(tpl, "setTransferFunctionMode", SetTransferFunctionMode);

	Nan::SetPrototypeMethod(tpl, "ShadeOff", ShadeOff);
	Nan::SetPrototypeMethod(tpl, "shadeOff", ShadeOff);

	Nan::SetPrototypeMethod(tpl, "ShadeOn", ShadeOn);
	Nan::SetPrototypeMethod(tpl, "shadeOn", ShadeOn);

	Nan::SetPrototypeMethod(tpl, "UpdateMTimes", UpdateMTimes);
	Nan::SetPrototypeMethod(tpl, "updateMTimes", UpdateMTimes);

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

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

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

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

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

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

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

void VtkVolumePropertyWrap::GetColorChannels(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetColorChannels(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetColorChannels();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumePropertyWrap::GetComponentWeight(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		double r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetComponentWeight(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

void VtkVolumePropertyWrap::GetDisableGradientOpacity(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetDisableGradientOpacity(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetDisableGradientOpacity();
	info.GetReturnValue().Set(Nan::New(r));
}

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

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

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

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

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

void VtkVolumePropertyWrap::GetInterpolationType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)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 VtkVolumePropertyWrap::GetInterpolationTypeAsString(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)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 VtkVolumePropertyWrap::GetInterpolationTypeMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)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 VtkVolumePropertyWrap::GetInterpolationTypeMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)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 VtkVolumePropertyWrap::GetRGBTransferFunction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		vtkColorTransferFunction * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetRGBTransferFunction(
			info[0]->Int32Value()
		);
		VtkColorTransferFunctionWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkColorTransferFunctionWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkColorTransferFunctionWrap *w = new VtkColorTransferFunctionWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	vtkColorTransferFunction * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetRGBTransferFunction();
	VtkColorTransferFunctionWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkColorTransferFunctionWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkColorTransferFunctionWrap *w = new VtkColorTransferFunctionWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

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

void VtkVolumePropertyWrap::GetScalarOpacityUnitDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		double r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetScalarOpacityUnitDistance(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetScalarOpacityUnitDistance();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumePropertyWrap::GetShade(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetShade(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetShade();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumePropertyWrap::GetSpecular(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		double r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetSpecular(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSpecular();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumePropertyWrap::GetSpecularPower(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		double r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetSpecularPower(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSpecularPower();
	info.GetReturnValue().Set(Nan::New(r));
}

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

void VtkVolumePropertyWrap::GetTransferFunction2D(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		vtkImageData * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetTransferFunction2D(
			info[0]->Int32Value()
		);
		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);
		return;
	}
	vtkImageData * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTransferFunction2D();
	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 VtkVolumePropertyWrap::GetTransferFunctionMode(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTransferFunctionMode();
	info.GetReturnValue().Set(Nan::New(r));
}

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

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

void VtkVolumePropertyWrap::HasGradientOpacity(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		bool r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->HasGradientOpacity(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

void VtkVolumePropertyWrap::SetColor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkColorTransferFunctionWrap::ptpl))->HasInstance(info[0]))
	{
		VtkColorTransferFunctionWrap *a0 = ObjectWrap::Unwrap<VtkColorTransferFunctionWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetColor(
			(vtkColorTransferFunction *) a0->native.GetPointer()
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPiecewiseFunctionWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPiecewiseFunctionWrap *a0 = ObjectWrap::Unwrap<VtkPiecewiseFunctionWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetColor(
			(vtkPiecewiseFunction *) a0->native.GetPointer()
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkColorTransferFunctionWrap::ptpl))->HasInstance(info[1]))
		{
			VtkColorTransferFunctionWrap *a1 = ObjectWrap::Unwrap<VtkColorTransferFunctionWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetColor(
				info[0]->Int32Value(),
				(vtkColorTransferFunction *) a1->native.GetPointer()
			);
			return;
		}
		else if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkPiecewiseFunctionWrap::ptpl))->HasInstance(info[1]))
		{
			VtkPiecewiseFunctionWrap *a1 = ObjectWrap::Unwrap<VtkPiecewiseFunctionWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetColor(
				info[0]->Int32Value(),
				(vtkPiecewiseFunction *) a1->native.GetPointer()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

void VtkVolumePropertyWrap::SetGradientOpacity(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPiecewiseFunctionWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPiecewiseFunctionWrap *a0 = ObjectWrap::Unwrap<VtkPiecewiseFunctionWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGradientOpacity(
			(vtkPiecewiseFunction *) a0->native.GetPointer()
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkPiecewiseFunctionWrap::ptpl))->HasInstance(info[1]))
		{
			VtkPiecewiseFunctionWrap *a1 = ObjectWrap::Unwrap<VtkPiecewiseFunctionWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetGradientOpacity(
				info[0]->Int32Value(),
				(vtkPiecewiseFunction *) a1->native.GetPointer()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

void VtkVolumePropertyWrap::SetInterpolationType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)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 VtkVolumePropertyWrap::SetInterpolationTypeToLinear(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetInterpolationTypeToLinear();
}

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

void VtkVolumePropertyWrap::SetScalarOpacity(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPiecewiseFunctionWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPiecewiseFunctionWrap *a0 = ObjectWrap::Unwrap<VtkPiecewiseFunctionWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetScalarOpacity(
			(vtkPiecewiseFunction *) a0->native.GetPointer()
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkPiecewiseFunctionWrap::ptpl))->HasInstance(info[1]))
		{
			VtkPiecewiseFunctionWrap *a1 = ObjectWrap::Unwrap<VtkPiecewiseFunctionWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetScalarOpacity(
				info[0]->Int32Value(),
				(vtkPiecewiseFunction *) a1->native.GetPointer()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

void VtkVolumePropertyWrap::SetTransferFunction2D(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumePropertyWrap *wrapper = ObjectWrap::Unwrap<VtkVolumePropertyWrap>(info.Holder());
	vtkVolumeProperty *native = (vtkVolumeProperty *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkImageDataWrap::ptpl))->HasInstance(info[0]))
	{
		VtkImageDataWrap *a0 = ObjectWrap::Unwrap<VtkImageDataWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetTransferFunction2D(
			(vtkImageData *) a0->native.GetPointer()
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkImageDataWrap::ptpl))->HasInstance(info[1]))
		{
			VtkImageDataWrap *a1 = ObjectWrap::Unwrap<VtkImageDataWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetTransferFunction2D(
				info[0]->Int32Value(),
				(vtkImageData *) a1->native.GetPointer()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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