/* 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 "vtkWidgetRepresentationWrap.h"
#include "vtkImplicitCylinderRepresentationWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkCylinderWrap.h"
#include "vtkPolyDataWrap.h"
#include "vtkPropertyWrap.h"
#include "vtkLookupTableWrap.h"
#include "vtkPropCollectionWrap.h"
#include "vtkWindowWrap.h"
#include "vtkViewportWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkImplicitCylinderRepresentationWrap::VtkImplicitCylinderRepresentationWrap()
{ }

VtkImplicitCylinderRepresentationWrap::VtkImplicitCylinderRepresentationWrap(vtkSmartPointer<vtkImplicitCylinderRepresentation> _native)
{ native = _native; }

VtkImplicitCylinderRepresentationWrap::~VtkImplicitCylinderRepresentationWrap()
{ }

void VtkImplicitCylinderRepresentationWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkImplicitCylinderRepresentation").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("ImplicitCylinderRepresentation").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "AlongXAxisOff", AlongXAxisOff);
	Nan::SetPrototypeMethod(tpl, "alongXAxisOff", AlongXAxisOff);

	Nan::SetPrototypeMethod(tpl, "AlongXAxisOn", AlongXAxisOn);
	Nan::SetPrototypeMethod(tpl, "alongXAxisOn", AlongXAxisOn);

	Nan::SetPrototypeMethod(tpl, "AlongYAxisOff", AlongYAxisOff);
	Nan::SetPrototypeMethod(tpl, "alongYAxisOff", AlongYAxisOff);

	Nan::SetPrototypeMethod(tpl, "AlongYAxisOn", AlongYAxisOn);
	Nan::SetPrototypeMethod(tpl, "alongYAxisOn", AlongYAxisOn);

	Nan::SetPrototypeMethod(tpl, "AlongZAxisOff", AlongZAxisOff);
	Nan::SetPrototypeMethod(tpl, "alongZAxisOff", AlongZAxisOff);

	Nan::SetPrototypeMethod(tpl, "AlongZAxisOn", AlongZAxisOn);
	Nan::SetPrototypeMethod(tpl, "alongZAxisOn", AlongZAxisOn);

	Nan::SetPrototypeMethod(tpl, "BuildRepresentation", BuildRepresentation);
	Nan::SetPrototypeMethod(tpl, "buildRepresentation", BuildRepresentation);

	Nan::SetPrototypeMethod(tpl, "BumpCylinder", BumpCylinder);
	Nan::SetPrototypeMethod(tpl, "bumpCylinder", BumpCylinder);

	Nan::SetPrototypeMethod(tpl, "ComputeInteractionState", ComputeInteractionState);
	Nan::SetPrototypeMethod(tpl, "computeInteractionState", ComputeInteractionState);

	Nan::SetPrototypeMethod(tpl, "ConstrainToWidgetBoundsOff", ConstrainToWidgetBoundsOff);
	Nan::SetPrototypeMethod(tpl, "constrainToWidgetBoundsOff", ConstrainToWidgetBoundsOff);

	Nan::SetPrototypeMethod(tpl, "ConstrainToWidgetBoundsOn", ConstrainToWidgetBoundsOn);
	Nan::SetPrototypeMethod(tpl, "constrainToWidgetBoundsOn", ConstrainToWidgetBoundsOn);

	Nan::SetPrototypeMethod(tpl, "DrawCylinderOff", DrawCylinderOff);
	Nan::SetPrototypeMethod(tpl, "drawCylinderOff", DrawCylinderOff);

	Nan::SetPrototypeMethod(tpl, "DrawCylinderOn", DrawCylinderOn);
	Nan::SetPrototypeMethod(tpl, "drawCylinderOn", DrawCylinderOn);

	Nan::SetPrototypeMethod(tpl, "EndWidgetInteraction", EndWidgetInteraction);
	Nan::SetPrototypeMethod(tpl, "endWidgetInteraction", EndWidgetInteraction);

	Nan::SetPrototypeMethod(tpl, "GetActors", GetActors);
	Nan::SetPrototypeMethod(tpl, "getActors", GetActors);

	Nan::SetPrototypeMethod(tpl, "GetAlongXAxis", GetAlongXAxis);
	Nan::SetPrototypeMethod(tpl, "getAlongXAxis", GetAlongXAxis);

	Nan::SetPrototypeMethod(tpl, "GetAlongYAxis", GetAlongYAxis);
	Nan::SetPrototypeMethod(tpl, "getAlongYAxis", GetAlongYAxis);

	Nan::SetPrototypeMethod(tpl, "GetAlongZAxis", GetAlongZAxis);
	Nan::SetPrototypeMethod(tpl, "getAlongZAxis", GetAlongZAxis);

	Nan::SetPrototypeMethod(tpl, "GetAxis", GetAxis);
	Nan::SetPrototypeMethod(tpl, "getAxis", GetAxis);

	Nan::SetPrototypeMethod(tpl, "GetAxisProperty", GetAxisProperty);
	Nan::SetPrototypeMethod(tpl, "getAxisProperty", GetAxisProperty);

	Nan::SetPrototypeMethod(tpl, "GetBumpDistance", GetBumpDistance);
	Nan::SetPrototypeMethod(tpl, "getBumpDistance", GetBumpDistance);

	Nan::SetPrototypeMethod(tpl, "GetBumpDistanceMaxValue", GetBumpDistanceMaxValue);
	Nan::SetPrototypeMethod(tpl, "getBumpDistanceMaxValue", GetBumpDistanceMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetBumpDistanceMinValue", GetBumpDistanceMinValue);
	Nan::SetPrototypeMethod(tpl, "getBumpDistanceMinValue", GetBumpDistanceMinValue);

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

	Nan::SetPrototypeMethod(tpl, "GetConstrainToWidgetBounds", GetConstrainToWidgetBounds);
	Nan::SetPrototypeMethod(tpl, "getConstrainToWidgetBounds", GetConstrainToWidgetBounds);

	Nan::SetPrototypeMethod(tpl, "GetCylinder", GetCylinder);
	Nan::SetPrototypeMethod(tpl, "getCylinder", GetCylinder);

	Nan::SetPrototypeMethod(tpl, "GetCylinderProperty", GetCylinderProperty);
	Nan::SetPrototypeMethod(tpl, "getCylinderProperty", GetCylinderProperty);

	Nan::SetPrototypeMethod(tpl, "GetDrawCylinder", GetDrawCylinder);
	Nan::SetPrototypeMethod(tpl, "getDrawCylinder", GetDrawCylinder);

	Nan::SetPrototypeMethod(tpl, "GetEdgesProperty", GetEdgesProperty);
	Nan::SetPrototypeMethod(tpl, "getEdgesProperty", GetEdgesProperty);

	Nan::SetPrototypeMethod(tpl, "GetInteractionStateMaxValue", GetInteractionStateMaxValue);
	Nan::SetPrototypeMethod(tpl, "getInteractionStateMaxValue", GetInteractionStateMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetInteractionStateMinValue", GetInteractionStateMinValue);
	Nan::SetPrototypeMethod(tpl, "getInteractionStateMinValue", GetInteractionStateMinValue);

	Nan::SetPrototypeMethod(tpl, "GetMaxRadius", GetMaxRadius);
	Nan::SetPrototypeMethod(tpl, "getMaxRadius", GetMaxRadius);

	Nan::SetPrototypeMethod(tpl, "GetMaxRadiusMaxValue", GetMaxRadiusMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMaxRadiusMaxValue", GetMaxRadiusMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMaxRadiusMinValue", GetMaxRadiusMinValue);
	Nan::SetPrototypeMethod(tpl, "getMaxRadiusMinValue", GetMaxRadiusMinValue);

	Nan::SetPrototypeMethod(tpl, "GetMinRadius", GetMinRadius);
	Nan::SetPrototypeMethod(tpl, "getMinRadius", GetMinRadius);

	Nan::SetPrototypeMethod(tpl, "GetMinRadiusMaxValue", GetMinRadiusMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMinRadiusMaxValue", GetMinRadiusMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMinRadiusMinValue", GetMinRadiusMinValue);
	Nan::SetPrototypeMethod(tpl, "getMinRadiusMinValue", GetMinRadiusMinValue);

	Nan::SetPrototypeMethod(tpl, "GetOutlineProperty", GetOutlineProperty);
	Nan::SetPrototypeMethod(tpl, "getOutlineProperty", GetOutlineProperty);

	Nan::SetPrototypeMethod(tpl, "GetOutlineTranslation", GetOutlineTranslation);
	Nan::SetPrototypeMethod(tpl, "getOutlineTranslation", GetOutlineTranslation);

	Nan::SetPrototypeMethod(tpl, "GetOutsideBounds", GetOutsideBounds);
	Nan::SetPrototypeMethod(tpl, "getOutsideBounds", GetOutsideBounds);

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

	Nan::SetPrototypeMethod(tpl, "GetRadius", GetRadius);
	Nan::SetPrototypeMethod(tpl, "getRadius", GetRadius);

	Nan::SetPrototypeMethod(tpl, "GetRepresentationState", GetRepresentationState);
	Nan::SetPrototypeMethod(tpl, "getRepresentationState", GetRepresentationState);

	Nan::SetPrototypeMethod(tpl, "GetResolution", GetResolution);
	Nan::SetPrototypeMethod(tpl, "getResolution", GetResolution);

	Nan::SetPrototypeMethod(tpl, "GetResolutionMaxValue", GetResolutionMaxValue);
	Nan::SetPrototypeMethod(tpl, "getResolutionMaxValue", GetResolutionMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetResolutionMinValue", GetResolutionMinValue);
	Nan::SetPrototypeMethod(tpl, "getResolutionMinValue", GetResolutionMinValue);

	Nan::SetPrototypeMethod(tpl, "GetScaleEnabled", GetScaleEnabled);
	Nan::SetPrototypeMethod(tpl, "getScaleEnabled", GetScaleEnabled);

	Nan::SetPrototypeMethod(tpl, "GetSelectedAxisProperty", GetSelectedAxisProperty);
	Nan::SetPrototypeMethod(tpl, "getSelectedAxisProperty", GetSelectedAxisProperty);

	Nan::SetPrototypeMethod(tpl, "GetSelectedCylinderProperty", GetSelectedCylinderProperty);
	Nan::SetPrototypeMethod(tpl, "getSelectedCylinderProperty", GetSelectedCylinderProperty);

	Nan::SetPrototypeMethod(tpl, "GetSelectedOutlineProperty", GetSelectedOutlineProperty);
	Nan::SetPrototypeMethod(tpl, "getSelectedOutlineProperty", GetSelectedOutlineProperty);

	Nan::SetPrototypeMethod(tpl, "GetTubing", GetTubing);
	Nan::SetPrototypeMethod(tpl, "getTubing", GetTubing);

	Nan::SetPrototypeMethod(tpl, "GetWidgetBounds", GetWidgetBounds);
	Nan::SetPrototypeMethod(tpl, "getWidgetBounds", GetWidgetBounds);

	Nan::SetPrototypeMethod(tpl, "HasTranslucentPolygonalGeometry", HasTranslucentPolygonalGeometry);
	Nan::SetPrototypeMethod(tpl, "hasTranslucentPolygonalGeometry", HasTranslucentPolygonalGeometry);

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

	Nan::SetPrototypeMethod(tpl, "OutlineTranslationOff", OutlineTranslationOff);
	Nan::SetPrototypeMethod(tpl, "outlineTranslationOff", OutlineTranslationOff);

	Nan::SetPrototypeMethod(tpl, "OutlineTranslationOn", OutlineTranslationOn);
	Nan::SetPrototypeMethod(tpl, "outlineTranslationOn", OutlineTranslationOn);

	Nan::SetPrototypeMethod(tpl, "OutsideBoundsOff", OutsideBoundsOff);
	Nan::SetPrototypeMethod(tpl, "outsideBoundsOff", OutsideBoundsOff);

	Nan::SetPrototypeMethod(tpl, "OutsideBoundsOn", OutsideBoundsOn);
	Nan::SetPrototypeMethod(tpl, "outsideBoundsOn", OutsideBoundsOn);

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

	Nan::SetPrototypeMethod(tpl, "PushCylinder", PushCylinder);
	Nan::SetPrototypeMethod(tpl, "pushCylinder", PushCylinder);

	Nan::SetPrototypeMethod(tpl, "ReleaseGraphicsResources", ReleaseGraphicsResources);
	Nan::SetPrototypeMethod(tpl, "releaseGraphicsResources", ReleaseGraphicsResources);

	Nan::SetPrototypeMethod(tpl, "RenderOpaqueGeometry", RenderOpaqueGeometry);
	Nan::SetPrototypeMethod(tpl, "renderOpaqueGeometry", RenderOpaqueGeometry);

	Nan::SetPrototypeMethod(tpl, "RenderTranslucentPolygonalGeometry", RenderTranslucentPolygonalGeometry);
	Nan::SetPrototypeMethod(tpl, "renderTranslucentPolygonalGeometry", RenderTranslucentPolygonalGeometry);

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

	Nan::SetPrototypeMethod(tpl, "ScaleEnabledOff", ScaleEnabledOff);
	Nan::SetPrototypeMethod(tpl, "scaleEnabledOff", ScaleEnabledOff);

	Nan::SetPrototypeMethod(tpl, "ScaleEnabledOn", ScaleEnabledOn);
	Nan::SetPrototypeMethod(tpl, "scaleEnabledOn", ScaleEnabledOn);

	Nan::SetPrototypeMethod(tpl, "SetAlongXAxis", SetAlongXAxis);
	Nan::SetPrototypeMethod(tpl, "setAlongXAxis", SetAlongXAxis);

	Nan::SetPrototypeMethod(tpl, "SetAlongYAxis", SetAlongYAxis);
	Nan::SetPrototypeMethod(tpl, "setAlongYAxis", SetAlongYAxis);

	Nan::SetPrototypeMethod(tpl, "SetAlongZAxis", SetAlongZAxis);
	Nan::SetPrototypeMethod(tpl, "setAlongZAxis", SetAlongZAxis);

	Nan::SetPrototypeMethod(tpl, "SetAxis", SetAxis);
	Nan::SetPrototypeMethod(tpl, "setAxis", SetAxis);

	Nan::SetPrototypeMethod(tpl, "SetBumpDistance", SetBumpDistance);
	Nan::SetPrototypeMethod(tpl, "setBumpDistance", SetBumpDistance);

	Nan::SetPrototypeMethod(tpl, "SetCenter", SetCenter);
	Nan::SetPrototypeMethod(tpl, "setCenter", SetCenter);

	Nan::SetPrototypeMethod(tpl, "SetConstrainToWidgetBounds", SetConstrainToWidgetBounds);
	Nan::SetPrototypeMethod(tpl, "setConstrainToWidgetBounds", SetConstrainToWidgetBounds);

	Nan::SetPrototypeMethod(tpl, "SetDrawCylinder", SetDrawCylinder);
	Nan::SetPrototypeMethod(tpl, "setDrawCylinder", SetDrawCylinder);

	Nan::SetPrototypeMethod(tpl, "SetEdgeColor", SetEdgeColor);
	Nan::SetPrototypeMethod(tpl, "setEdgeColor", SetEdgeColor);

	Nan::SetPrototypeMethod(tpl, "SetInteractionState", SetInteractionState);
	Nan::SetPrototypeMethod(tpl, "setInteractionState", SetInteractionState);

	Nan::SetPrototypeMethod(tpl, "SetMaxRadius", SetMaxRadius);
	Nan::SetPrototypeMethod(tpl, "setMaxRadius", SetMaxRadius);

	Nan::SetPrototypeMethod(tpl, "SetMinRadius", SetMinRadius);
	Nan::SetPrototypeMethod(tpl, "setMinRadius", SetMinRadius);

	Nan::SetPrototypeMethod(tpl, "SetOutlineTranslation", SetOutlineTranslation);
	Nan::SetPrototypeMethod(tpl, "setOutlineTranslation", SetOutlineTranslation);

	Nan::SetPrototypeMethod(tpl, "SetOutsideBounds", SetOutsideBounds);
	Nan::SetPrototypeMethod(tpl, "setOutsideBounds", SetOutsideBounds);

	Nan::SetPrototypeMethod(tpl, "SetRadius", SetRadius);
	Nan::SetPrototypeMethod(tpl, "setRadius", SetRadius);

	Nan::SetPrototypeMethod(tpl, "SetRepresentationState", SetRepresentationState);
	Nan::SetPrototypeMethod(tpl, "setRepresentationState", SetRepresentationState);

	Nan::SetPrototypeMethod(tpl, "SetResolution", SetResolution);
	Nan::SetPrototypeMethod(tpl, "setResolution", SetResolution);

	Nan::SetPrototypeMethod(tpl, "SetScaleEnabled", SetScaleEnabled);
	Nan::SetPrototypeMethod(tpl, "setScaleEnabled", SetScaleEnabled);

	Nan::SetPrototypeMethod(tpl, "SetTubing", SetTubing);
	Nan::SetPrototypeMethod(tpl, "setTubing", SetTubing);

	Nan::SetPrototypeMethod(tpl, "SetWidgetBounds", SetWidgetBounds);
	Nan::SetPrototypeMethod(tpl, "setWidgetBounds", SetWidgetBounds);

	Nan::SetPrototypeMethod(tpl, "StartWidgetInteraction", StartWidgetInteraction);
	Nan::SetPrototypeMethod(tpl, "startWidgetInteraction", StartWidgetInteraction);

	Nan::SetPrototypeMethod(tpl, "TubingOff", TubingOff);
	Nan::SetPrototypeMethod(tpl, "tubingOff", TubingOff);

	Nan::SetPrototypeMethod(tpl, "TubingOn", TubingOn);
	Nan::SetPrototypeMethod(tpl, "tubingOn", TubingOn);

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

	Nan::SetPrototypeMethod(tpl, "WidgetInteraction", WidgetInteraction);
	Nan::SetPrototypeMethod(tpl, "widgetInteraction", WidgetInteraction);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkImplicitCylinderRepresentationWrap::EndWidgetInteraction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)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->EndWidgetInteraction(
			(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->EndWidgetInteraction(
			b0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

void VtkImplicitCylinderRepresentationWrap::GetAxis(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)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->GetAxis(
			(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->GetAxis(
			b0
		);
		return;
	}
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetAxis();
	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 VtkImplicitCylinderRepresentationWrap::GetAxisProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)wrapper->native.GetPointer();
	vtkProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetAxisProperty();
	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 VtkImplicitCylinderRepresentationWrap::GetBumpDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetBumpDistance();
	info.GetReturnValue().Set(Nan::New(r));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkImplicitCylinderRepresentationWrap::GetSelectedAxisProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)wrapper->native.GetPointer();
	vtkProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSelectedAxisProperty();
	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 VtkImplicitCylinderRepresentationWrap::GetSelectedCylinderProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)wrapper->native.GetPointer();
	vtkProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSelectedCylinderProperty();
	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 VtkImplicitCylinderRepresentationWrap::GetSelectedOutlineProperty(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)wrapper->native.GetPointer();
	vtkProperty * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSelectedOutlineProperty();
	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 VtkImplicitCylinderRepresentationWrap::GetTubing(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTubing();
	info.GetReturnValue().Set(Nan::New(r));
}

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

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

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

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

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

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

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

void VtkImplicitCylinderRepresentationWrap::PlaceWidget(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)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;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

void VtkImplicitCylinderRepresentationWrap::RenderOpaqueGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkViewportWrap::ptpl))->HasInstance(info[0]))
	{
		VtkViewportWrap *a0 = ObjectWrap::Unwrap<VtkViewportWrap>(info[0]->ToObject());
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->RenderOpaqueGeometry(
			(vtkViewport *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkImplicitCylinderRepresentationWrap::RenderTranslucentPolygonalGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkViewportWrap::ptpl))->HasInstance(info[0]))
	{
		VtkViewportWrap *a0 = ObjectWrap::Unwrap<VtkViewportWrap>(info[0]->ToObject());
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->RenderTranslucentPolygonalGeometry(
			(vtkViewport *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

void VtkImplicitCylinderRepresentationWrap::SetEdgeColor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)wrapper->native.GetPointer();
	size_t i;
	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->SetEdgeColor(
			(vtkLookupTable *) a0->native.GetPointer()
		);
		return;
	}
	else 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->SetEdgeColor(
			(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->SetEdgeColor(
			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->SetEdgeColor(
					info[0]->NumberValue(),
					info[1]->NumberValue(),
					info[2]->NumberValue()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

void VtkImplicitCylinderRepresentationWrap::StartWidgetInteraction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)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->StartWidgetInteraction(
			(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->StartWidgetInteraction(
			b0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

void VtkImplicitCylinderRepresentationWrap::WidgetInteraction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkImplicitCylinderRepresentationWrap *wrapper = ObjectWrap::Unwrap<VtkImplicitCylinderRepresentationWrap>(info.Holder());
	vtkImplicitCylinderRepresentation *native = (vtkImplicitCylinderRepresentation *)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->WidgetInteraction(
			(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->WidgetInteraction(
			b0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}