/* 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 "vtkActorWrap.h"
#include "vtkPolarAxesActorWrap.h"
#include "vtkObjectWrap.h"
#include "vtkViewportWrap.h"
#include "vtkCameraWrap.h"
#include "vtkWindowWrap.h"
#include "vtkTextPropertyWrap.h"
#include "vtkPropertyWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkPolarAxesActorWrap::VtkPolarAxesActorWrap()
{ }

VtkPolarAxesActorWrap::VtkPolarAxesActorWrap(vtkSmartPointer<vtkPolarAxesActor> _native)
{ native = _native; }

VtkPolarAxesActorWrap::~VtkPolarAxesActorWrap()
{ }

void VtkPolarAxesActorWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkPolarAxesActor").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("PolarAxesActor").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "AutoSubdividePolarAxisOff", AutoSubdividePolarAxisOff);
	Nan::SetPrototypeMethod(tpl, "autoSubdividePolarAxisOff", AutoSubdividePolarAxisOff);

	Nan::SetPrototypeMethod(tpl, "AutoSubdividePolarAxisOn", AutoSubdividePolarAxisOn);
	Nan::SetPrototypeMethod(tpl, "autoSubdividePolarAxisOn", AutoSubdividePolarAxisOn);

	Nan::SetPrototypeMethod(tpl, "GetAutoScaleRadius", GetAutoScaleRadius);
	Nan::SetPrototypeMethod(tpl, "getAutoScaleRadius", GetAutoScaleRadius);

	Nan::SetPrototypeMethod(tpl, "GetAutoSubdividePolarAxis", GetAutoSubdividePolarAxis);
	Nan::SetPrototypeMethod(tpl, "getAutoSubdividePolarAxis", GetAutoSubdividePolarAxis);

	Nan::SetPrototypeMethod(tpl, "GetBounds", GetBounds);
	Nan::SetPrototypeMethod(tpl, "getBounds", GetBounds);

	Nan::SetPrototypeMethod(tpl, "GetCamera", GetCamera);
	Nan::SetPrototypeMethod(tpl, "getCamera", GetCamera);

	Nan::SetPrototypeMethod(tpl, "GetClassName", GetClassName);
	Nan::SetPrototypeMethod(tpl, "getClassName", GetClassName);

	Nan::SetPrototypeMethod(tpl, "GetDistanceLODThreshold", GetDistanceLODThreshold);
	Nan::SetPrototypeMethod(tpl, "getDistanceLODThreshold", GetDistanceLODThreshold);

	Nan::SetPrototypeMethod(tpl, "GetDistanceLODThresholdMaxValue", GetDistanceLODThresholdMaxValue);
	Nan::SetPrototypeMethod(tpl, "getDistanceLODThresholdMaxValue", GetDistanceLODThresholdMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetDistanceLODThresholdMinValue", GetDistanceLODThresholdMinValue);
	Nan::SetPrototypeMethod(tpl, "getDistanceLODThresholdMinValue", GetDistanceLODThresholdMinValue);

	Nan::SetPrototypeMethod(tpl, "GetEnableDistanceLOD", GetEnableDistanceLOD);
	Nan::SetPrototypeMethod(tpl, "getEnableDistanceLOD", GetEnableDistanceLOD);

	Nan::SetPrototypeMethod(tpl, "GetEnableViewAngleLOD", GetEnableViewAngleLOD);
	Nan::SetPrototypeMethod(tpl, "getEnableViewAngleLOD", GetEnableViewAngleLOD);

	Nan::SetPrototypeMethod(tpl, "GetMaximumAngle", GetMaximumAngle);
	Nan::SetPrototypeMethod(tpl, "getMaximumAngle", GetMaximumAngle);

	Nan::SetPrototypeMethod(tpl, "GetMaximumRadius", GetMaximumRadius);
	Nan::SetPrototypeMethod(tpl, "getMaximumRadius", GetMaximumRadius);

	Nan::SetPrototypeMethod(tpl, "GetMinimumAngle", GetMinimumAngle);
	Nan::SetPrototypeMethod(tpl, "getMinimumAngle", GetMinimumAngle);

	Nan::SetPrototypeMethod(tpl, "GetPolarArcsProperty", GetPolarArcsProperty);
	Nan::SetPrototypeMethod(tpl, "getPolarArcsProperty", GetPolarArcsProperty);

	Nan::SetPrototypeMethod(tpl, "GetPolarArcsVisibility", GetPolarArcsVisibility);
	Nan::SetPrototypeMethod(tpl, "getPolarArcsVisibility", GetPolarArcsVisibility);

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisLabelTextProperty", GetPolarAxisLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisLabelTextProperty", GetPolarAxisLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisProperty", GetPolarAxisProperty);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisProperty", GetPolarAxisProperty);

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisTitle", GetPolarAxisTitle);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisTitle", GetPolarAxisTitle);

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisTitleTextProperty", GetPolarAxisTitleTextProperty);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisTitleTextProperty", GetPolarAxisTitleTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisVisibility", GetPolarAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisVisibility", GetPolarAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "GetPolarLabelFormat", GetPolarLabelFormat);
	Nan::SetPrototypeMethod(tpl, "getPolarLabelFormat", GetPolarLabelFormat);

	Nan::SetPrototypeMethod(tpl, "GetPolarLabelVisibility", GetPolarLabelVisibility);
	Nan::SetPrototypeMethod(tpl, "getPolarLabelVisibility", GetPolarLabelVisibility);

	Nan::SetPrototypeMethod(tpl, "GetPolarTickVisibility", GetPolarTickVisibility);
	Nan::SetPrototypeMethod(tpl, "getPolarTickVisibility", GetPolarTickVisibility);

	Nan::SetPrototypeMethod(tpl, "GetPolarTitleVisibility", GetPolarTitleVisibility);
	Nan::SetPrototypeMethod(tpl, "getPolarTitleVisibility", GetPolarTitleVisibility);

	Nan::SetPrototypeMethod(tpl, "GetPole", GetPole);
	Nan::SetPrototypeMethod(tpl, "getPole", GetPole);

	Nan::SetPrototypeMethod(tpl, "GetRadialAxesProperty", GetRadialAxesProperty);
	Nan::SetPrototypeMethod(tpl, "getRadialAxesProperty", GetRadialAxesProperty);

	Nan::SetPrototypeMethod(tpl, "GetRadialAxesVisibility", GetRadialAxesVisibility);
	Nan::SetPrototypeMethod(tpl, "getRadialAxesVisibility", GetRadialAxesVisibility);

	Nan::SetPrototypeMethod(tpl, "GetRadialTitleVisibility", GetRadialTitleVisibility);
	Nan::SetPrototypeMethod(tpl, "getRadialTitleVisibility", GetRadialTitleVisibility);

	Nan::SetPrototypeMethod(tpl, "GetRadialUnits", GetRadialUnits);
	Nan::SetPrototypeMethod(tpl, "getRadialUnits", GetRadialUnits);

	Nan::SetPrototypeMethod(tpl, "GetScreenSize", GetScreenSize);
	Nan::SetPrototypeMethod(tpl, "getScreenSize", GetScreenSize);

	Nan::SetPrototypeMethod(tpl, "GetSmallestVisiblePolarAngle", GetSmallestVisiblePolarAngle);
	Nan::SetPrototypeMethod(tpl, "getSmallestVisiblePolarAngle", GetSmallestVisiblePolarAngle);

	Nan::SetPrototypeMethod(tpl, "GetSmallestVisiblePolarAngleMaxValue", GetSmallestVisiblePolarAngleMaxValue);
	Nan::SetPrototypeMethod(tpl, "getSmallestVisiblePolarAngleMaxValue", GetSmallestVisiblePolarAngleMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetSmallestVisiblePolarAngleMinValue", GetSmallestVisiblePolarAngleMinValue);
	Nan::SetPrototypeMethod(tpl, "getSmallestVisiblePolarAngleMinValue", GetSmallestVisiblePolarAngleMinValue);

	Nan::SetPrototypeMethod(tpl, "GetViewAngleLODThreshold", GetViewAngleLODThreshold);
	Nan::SetPrototypeMethod(tpl, "getViewAngleLODThreshold", GetViewAngleLODThreshold);

	Nan::SetPrototypeMethod(tpl, "GetViewAngleLODThresholdMaxValue", GetViewAngleLODThresholdMaxValue);
	Nan::SetPrototypeMethod(tpl, "getViewAngleLODThresholdMaxValue", GetViewAngleLODThresholdMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetViewAngleLODThresholdMinValue", GetViewAngleLODThresholdMinValue);
	Nan::SetPrototypeMethod(tpl, "getViewAngleLODThresholdMinValue", GetViewAngleLODThresholdMinValue);

	Nan::SetPrototypeMethod(tpl, "IsA", IsA);
	Nan::SetPrototypeMethod(tpl, "isA", IsA);

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

	Nan::SetPrototypeMethod(tpl, "PolarArcsVisibilityOff", PolarArcsVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "polarArcsVisibilityOff", PolarArcsVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "PolarArcsVisibilityOn", PolarArcsVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "polarArcsVisibilityOn", PolarArcsVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "PolarAxisVisibilityOff", PolarAxisVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "polarAxisVisibilityOff", PolarAxisVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "PolarAxisVisibilityOn", PolarAxisVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "polarAxisVisibilityOn", PolarAxisVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "PolarLabelVisibilityOff", PolarLabelVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "polarLabelVisibilityOff", PolarLabelVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "PolarLabelVisibilityOn", PolarLabelVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "polarLabelVisibilityOn", PolarLabelVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "PolarTickVisibilityOff", PolarTickVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "polarTickVisibilityOff", PolarTickVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "PolarTickVisibilityOn", PolarTickVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "polarTickVisibilityOn", PolarTickVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "PolarTitleVisibilityOff", PolarTitleVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "polarTitleVisibilityOff", PolarTitleVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "PolarTitleVisibilityOn", PolarTitleVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "polarTitleVisibilityOn", PolarTitleVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "RadialAxesVisibilityOff", RadialAxesVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "radialAxesVisibilityOff", RadialAxesVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "RadialAxesVisibilityOn", RadialAxesVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "radialAxesVisibilityOn", RadialAxesVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "RadialTitleVisibilityOff", RadialTitleVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "radialTitleVisibilityOff", RadialTitleVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "RadialTitleVisibilityOn", RadialTitleVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "radialTitleVisibilityOn", RadialTitleVisibilityOn);

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

	Nan::SetPrototypeMethod(tpl, "SetAutoSubdividePolarAxis", SetAutoSubdividePolarAxis);
	Nan::SetPrototypeMethod(tpl, "setAutoSubdividePolarAxis", SetAutoSubdividePolarAxis);

	Nan::SetPrototypeMethod(tpl, "SetBounds", SetBounds);
	Nan::SetPrototypeMethod(tpl, "setBounds", SetBounds);

	Nan::SetPrototypeMethod(tpl, "SetCamera", SetCamera);
	Nan::SetPrototypeMethod(tpl, "setCamera", SetCamera);

	Nan::SetPrototypeMethod(tpl, "SetDistanceLODThreshold", SetDistanceLODThreshold);
	Nan::SetPrototypeMethod(tpl, "setDistanceLODThreshold", SetDistanceLODThreshold);

	Nan::SetPrototypeMethod(tpl, "SetEnableDistanceLOD", SetEnableDistanceLOD);
	Nan::SetPrototypeMethod(tpl, "setEnableDistanceLOD", SetEnableDistanceLOD);

	Nan::SetPrototypeMethod(tpl, "SetEnableViewAngleLOD", SetEnableViewAngleLOD);
	Nan::SetPrototypeMethod(tpl, "setEnableViewAngleLOD", SetEnableViewAngleLOD);

	Nan::SetPrototypeMethod(tpl, "SetMaximumAngle", SetMaximumAngle);
	Nan::SetPrototypeMethod(tpl, "setMaximumAngle", SetMaximumAngle);

	Nan::SetPrototypeMethod(tpl, "SetMaximumRadius", SetMaximumRadius);
	Nan::SetPrototypeMethod(tpl, "setMaximumRadius", SetMaximumRadius);

	Nan::SetPrototypeMethod(tpl, "SetMinimumAngle", SetMinimumAngle);
	Nan::SetPrototypeMethod(tpl, "setMinimumAngle", SetMinimumAngle);

	Nan::SetPrototypeMethod(tpl, "SetPolarArcsProperty", SetPolarArcsProperty);
	Nan::SetPrototypeMethod(tpl, "setPolarArcsProperty", SetPolarArcsProperty);

	Nan::SetPrototypeMethod(tpl, "SetPolarArcsVisibility", SetPolarArcsVisibility);
	Nan::SetPrototypeMethod(tpl, "setPolarArcsVisibility", SetPolarArcsVisibility);

	Nan::SetPrototypeMethod(tpl, "SetPolarAxisLabelTextProperty", SetPolarAxisLabelTextProperty);
	Nan::SetPrototypeMethod(tpl, "setPolarAxisLabelTextProperty", SetPolarAxisLabelTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetPolarAxisProperty", SetPolarAxisProperty);
	Nan::SetPrototypeMethod(tpl, "setPolarAxisProperty", SetPolarAxisProperty);

	Nan::SetPrototypeMethod(tpl, "SetPolarAxisTitle", SetPolarAxisTitle);
	Nan::SetPrototypeMethod(tpl, "setPolarAxisTitle", SetPolarAxisTitle);

	Nan::SetPrototypeMethod(tpl, "SetPolarAxisTitleTextProperty", SetPolarAxisTitleTextProperty);
	Nan::SetPrototypeMethod(tpl, "setPolarAxisTitleTextProperty", SetPolarAxisTitleTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetPolarAxisVisibility", SetPolarAxisVisibility);
	Nan::SetPrototypeMethod(tpl, "setPolarAxisVisibility", SetPolarAxisVisibility);

	Nan::SetPrototypeMethod(tpl, "SetPolarLabelFormat", SetPolarLabelFormat);
	Nan::SetPrototypeMethod(tpl, "setPolarLabelFormat", SetPolarLabelFormat);

	Nan::SetPrototypeMethod(tpl, "SetPolarLabelVisibility", SetPolarLabelVisibility);
	Nan::SetPrototypeMethod(tpl, "setPolarLabelVisibility", SetPolarLabelVisibility);

	Nan::SetPrototypeMethod(tpl, "SetPolarTickVisibility", SetPolarTickVisibility);
	Nan::SetPrototypeMethod(tpl, "setPolarTickVisibility", SetPolarTickVisibility);

	Nan::SetPrototypeMethod(tpl, "SetPolarTitleVisibility", SetPolarTitleVisibility);
	Nan::SetPrototypeMethod(tpl, "setPolarTitleVisibility", SetPolarTitleVisibility);

	Nan::SetPrototypeMethod(tpl, "SetPole", SetPole);
	Nan::SetPrototypeMethod(tpl, "setPole", SetPole);

	Nan::SetPrototypeMethod(tpl, "SetRadialAxesProperty", SetRadialAxesProperty);
	Nan::SetPrototypeMethod(tpl, "setRadialAxesProperty", SetRadialAxesProperty);

	Nan::SetPrototypeMethod(tpl, "SetRadialAxesVisibility", SetRadialAxesVisibility);
	Nan::SetPrototypeMethod(tpl, "setRadialAxesVisibility", SetRadialAxesVisibility);

	Nan::SetPrototypeMethod(tpl, "SetRadialTitleVisibility", SetRadialTitleVisibility);
	Nan::SetPrototypeMethod(tpl, "setRadialTitleVisibility", SetRadialTitleVisibility);

	Nan::SetPrototypeMethod(tpl, "SetRadialUnits", SetRadialUnits);
	Nan::SetPrototypeMethod(tpl, "setRadialUnits", SetRadialUnits);

	Nan::SetPrototypeMethod(tpl, "SetScreenSize", SetScreenSize);
	Nan::SetPrototypeMethod(tpl, "setScreenSize", SetScreenSize);

	Nan::SetPrototypeMethod(tpl, "SetSmallestVisiblePolarAngle", SetSmallestVisiblePolarAngle);
	Nan::SetPrototypeMethod(tpl, "setSmallestVisiblePolarAngle", SetSmallestVisiblePolarAngle);

	Nan::SetPrototypeMethod(tpl, "SetViewAngleLODThreshold", SetViewAngleLODThreshold);
	Nan::SetPrototypeMethod(tpl, "setViewAngleLODThreshold", SetViewAngleLODThreshold);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkPolarAxesActorWrap::IsA(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkPolarAxesActorWrap *wrapper = ObjectWrap::Unwrap<VtkPolarAxesActorWrap>(info.Holder());
	vtkPolarAxesActor *native = (vtkPolarAxesActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->IsA(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkPolarAxesActorWrap::SetPolarAxisTitle(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkPolarAxesActorWrap *wrapper = ObjectWrap::Unwrap<VtkPolarAxesActorWrap>(info.Holder());
	vtkPolarAxesActor *native = (vtkPolarAxesActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPolarAxisTitle(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

void VtkPolarAxesActorWrap::SetPolarLabelFormat(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkPolarAxesActorWrap *wrapper = ObjectWrap::Unwrap<VtkPolarAxesActorWrap>(info.Holder());
	vtkPolarAxesActor *native = (vtkPolarAxesActor *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetPolarLabelFormat(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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