/* 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 "vtkObjectBaseWrap.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, "ArcMinorTickVisibilityOff", ArcMinorTickVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "arcMinorTickVisibilityOff", ArcMinorTickVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "ArcMinorTickVisibilityOn", ArcMinorTickVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "arcMinorTickVisibilityOn", ArcMinorTickVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "ArcTickVisibilityOff", ArcTickVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "arcTickVisibilityOff", ArcTickVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "ArcTickVisibilityOn", ArcTickVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "arcTickVisibilityOn", ArcTickVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "ArcTicksOriginToPolarAxisOff", ArcTicksOriginToPolarAxisOff);
	Nan::SetPrototypeMethod(tpl, "arcTicksOriginToPolarAxisOff", ArcTicksOriginToPolarAxisOff);

	Nan::SetPrototypeMethod(tpl, "ArcTicksOriginToPolarAxisOn", ArcTicksOriginToPolarAxisOn);
	Nan::SetPrototypeMethod(tpl, "arcTicksOriginToPolarAxisOn", ArcTicksOriginToPolarAxisOn);

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

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

	Nan::SetPrototypeMethod(tpl, "AxisMinorTickVisibilityOff", AxisMinorTickVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "axisMinorTickVisibilityOff", AxisMinorTickVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "AxisMinorTickVisibilityOn", AxisMinorTickVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "axisMinorTickVisibilityOn", AxisMinorTickVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "AxisTickVisibilityOff", AxisTickVisibilityOff);
	Nan::SetPrototypeMethod(tpl, "axisTickVisibilityOff", AxisTickVisibilityOff);

	Nan::SetPrototypeMethod(tpl, "AxisTickVisibilityOn", AxisTickVisibilityOn);
	Nan::SetPrototypeMethod(tpl, "axisTickVisibilityOn", AxisTickVisibilityOn);

	Nan::SetPrototypeMethod(tpl, "DrawPolarArcsGridlinesOff", DrawPolarArcsGridlinesOff);
	Nan::SetPrototypeMethod(tpl, "drawPolarArcsGridlinesOff", DrawPolarArcsGridlinesOff);

	Nan::SetPrototypeMethod(tpl, "DrawPolarArcsGridlinesOn", DrawPolarArcsGridlinesOn);
	Nan::SetPrototypeMethod(tpl, "drawPolarArcsGridlinesOn", DrawPolarArcsGridlinesOn);

	Nan::SetPrototypeMethod(tpl, "DrawRadialGridlinesOff", DrawRadialGridlinesOff);
	Nan::SetPrototypeMethod(tpl, "drawRadialGridlinesOff", DrawRadialGridlinesOff);

	Nan::SetPrototypeMethod(tpl, "DrawRadialGridlinesOn", DrawRadialGridlinesOn);
	Nan::SetPrototypeMethod(tpl, "drawRadialGridlinesOn", DrawRadialGridlinesOn);

	Nan::SetPrototypeMethod(tpl, "GetArcMajorTickSize", GetArcMajorTickSize);
	Nan::SetPrototypeMethod(tpl, "getArcMajorTickSize", GetArcMajorTickSize);

	Nan::SetPrototypeMethod(tpl, "GetArcMajorTickThickness", GetArcMajorTickThickness);
	Nan::SetPrototypeMethod(tpl, "getArcMajorTickThickness", GetArcMajorTickThickness);

	Nan::SetPrototypeMethod(tpl, "GetArcMinorTickVisibility", GetArcMinorTickVisibility);
	Nan::SetPrototypeMethod(tpl, "getArcMinorTickVisibility", GetArcMinorTickVisibility);

	Nan::SetPrototypeMethod(tpl, "GetArcTickRatioSize", GetArcTickRatioSize);
	Nan::SetPrototypeMethod(tpl, "getArcTickRatioSize", GetArcTickRatioSize);

	Nan::SetPrototypeMethod(tpl, "GetArcTickRatioThickness", GetArcTickRatioThickness);
	Nan::SetPrototypeMethod(tpl, "getArcTickRatioThickness", GetArcTickRatioThickness);

	Nan::SetPrototypeMethod(tpl, "GetArcTickVisibility", GetArcTickVisibility);
	Nan::SetPrototypeMethod(tpl, "getArcTickVisibility", GetArcTickVisibility);

	Nan::SetPrototypeMethod(tpl, "GetArcTicksOriginToPolarAxis", GetArcTicksOriginToPolarAxis);
	Nan::SetPrototypeMethod(tpl, "getArcTicksOriginToPolarAxis", GetArcTicksOriginToPolarAxis);

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

	Nan::SetPrototypeMethod(tpl, "GetAxisMinorTickVisibility", GetAxisMinorTickVisibility);
	Nan::SetPrototypeMethod(tpl, "getAxisMinorTickVisibility", GetAxisMinorTickVisibility);

	Nan::SetPrototypeMethod(tpl, "GetAxisTickVisibility", GetAxisTickVisibility);
	Nan::SetPrototypeMethod(tpl, "getAxisTickVisibility", GetAxisTickVisibility);

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

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

	Nan::SetPrototypeMethod(tpl, "GetDeltaAngleMajor", GetDeltaAngleMajor);
	Nan::SetPrototypeMethod(tpl, "getDeltaAngleMajor", GetDeltaAngleMajor);

	Nan::SetPrototypeMethod(tpl, "GetDeltaAngleMinor", GetDeltaAngleMinor);
	Nan::SetPrototypeMethod(tpl, "getDeltaAngleMinor", GetDeltaAngleMinor);

	Nan::SetPrototypeMethod(tpl, "GetDeltaAngleRadialAxes", GetDeltaAngleRadialAxes);
	Nan::SetPrototypeMethod(tpl, "getDeltaAngleRadialAxes", GetDeltaAngleRadialAxes);

	Nan::SetPrototypeMethod(tpl, "GetDeltaRangeMajor", GetDeltaRangeMajor);
	Nan::SetPrototypeMethod(tpl, "getDeltaRangeMajor", GetDeltaRangeMajor);

	Nan::SetPrototypeMethod(tpl, "GetDeltaRangeMinor", GetDeltaRangeMinor);
	Nan::SetPrototypeMethod(tpl, "getDeltaRangeMinor", GetDeltaRangeMinor);

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

	Nan::SetPrototypeMethod(tpl, "GetDrawRadialGridlines", GetDrawRadialGridlines);
	Nan::SetPrototypeMethod(tpl, "getDrawRadialGridlines", GetDrawRadialGridlines);

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

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

	Nan::SetPrototypeMethod(tpl, "GetExponentLocation", GetExponentLocation);
	Nan::SetPrototypeMethod(tpl, "getExponentLocation", GetExponentLocation);

	Nan::SetPrototypeMethod(tpl, "GetExponentLocationMaxValue", GetExponentLocationMaxValue);
	Nan::SetPrototypeMethod(tpl, "getExponentLocationMaxValue", GetExponentLocationMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetExponentLocationMinValue", GetExponentLocationMinValue);
	Nan::SetPrototypeMethod(tpl, "getExponentLocationMinValue", GetExponentLocationMinValue);

	Nan::SetPrototypeMethod(tpl, "GetLastAxisTickRatioSize", GetLastAxisTickRatioSize);
	Nan::SetPrototypeMethod(tpl, "getLastAxisTickRatioSize", GetLastAxisTickRatioSize);

	Nan::SetPrototypeMethod(tpl, "GetLastAxisTickRatioThickness", GetLastAxisTickRatioThickness);
	Nan::SetPrototypeMethod(tpl, "getLastAxisTickRatioThickness", GetLastAxisTickRatioThickness);

	Nan::SetPrototypeMethod(tpl, "GetLastRadialAxisMajorTickSize", GetLastRadialAxisMajorTickSize);
	Nan::SetPrototypeMethod(tpl, "getLastRadialAxisMajorTickSize", GetLastRadialAxisMajorTickSize);

	Nan::SetPrototypeMethod(tpl, "GetLastRadialAxisMajorTickThickness", GetLastRadialAxisMajorTickThickness);
	Nan::SetPrototypeMethod(tpl, "getLastRadialAxisMajorTickThickness", GetLastRadialAxisMajorTickThickness);

	Nan::SetPrototypeMethod(tpl, "GetLastRadialAxisProperty", GetLastRadialAxisProperty);
	Nan::SetPrototypeMethod(tpl, "getLastRadialAxisProperty", GetLastRadialAxisProperty);

	Nan::SetPrototypeMethod(tpl, "GetLastRadialAxisTextProperty", GetLastRadialAxisTextProperty);
	Nan::SetPrototypeMethod(tpl, "getLastRadialAxisTextProperty", GetLastRadialAxisTextProperty);

	Nan::SetPrototypeMethod(tpl, "GetLog", GetLog);
	Nan::SetPrototypeMethod(tpl, "getLog", GetLog);

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

	Nan::SetPrototypeMethod(tpl, "GetNumberOfPolarAxisTicks", GetNumberOfPolarAxisTicks);
	Nan::SetPrototypeMethod(tpl, "getNumberOfPolarAxisTicks", GetNumberOfPolarAxisTicks);

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

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisMajorTickThickness", GetPolarAxisMajorTickThickness);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisMajorTickThickness", GetPolarAxisMajorTickThickness);

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

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisTickRatioSize", GetPolarAxisTickRatioSize);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisTickRatioSize", GetPolarAxisTickRatioSize);

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisTickRatioThickness", GetPolarAxisTickRatioThickness);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisTickRatioThickness", GetPolarAxisTickRatioThickness);

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

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisTitleLocation", GetPolarAxisTitleLocation);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisTitleLocation", GetPolarAxisTitleLocation);

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisTitleLocationMaxValue", GetPolarAxisTitleLocationMaxValue);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisTitleLocationMaxValue", GetPolarAxisTitleLocationMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetPolarAxisTitleLocationMinValue", GetPolarAxisTitleLocationMinValue);
	Nan::SetPrototypeMethod(tpl, "getPolarAxisTitleLocationMinValue", GetPolarAxisTitleLocationMinValue);

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

	Nan::SetPrototypeMethod(tpl, "GetRadialAxesOriginToPolarAxis", GetRadialAxesOriginToPolarAxis);
	Nan::SetPrototypeMethod(tpl, "getRadialAxesOriginToPolarAxis", GetRadialAxesOriginToPolarAxis);

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

	Nan::SetPrototypeMethod(tpl, "GetRadialAxisTitleLocation", GetRadialAxisTitleLocation);
	Nan::SetPrototypeMethod(tpl, "getRadialAxisTitleLocation", GetRadialAxisTitleLocation);

	Nan::SetPrototypeMethod(tpl, "GetRadialAxisTitleLocationMaxValue", GetRadialAxisTitleLocationMaxValue);
	Nan::SetPrototypeMethod(tpl, "getRadialAxisTitleLocationMaxValue", GetRadialAxisTitleLocationMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetRadialAxisTitleLocationMinValue", GetRadialAxisTitleLocationMinValue);
	Nan::SetPrototypeMethod(tpl, "getRadialAxisTitleLocationMinValue", GetRadialAxisTitleLocationMinValue);

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

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

	Nan::SetPrototypeMethod(tpl, "GetRange", GetRange);
	Nan::SetPrototypeMethod(tpl, "getRange", GetRange);

	Nan::SetPrototypeMethod(tpl, "GetRatio", GetRatio);
	Nan::SetPrototypeMethod(tpl, "getRatio", GetRatio);

	Nan::SetPrototypeMethod(tpl, "GetRatioMaxValue", GetRatioMaxValue);
	Nan::SetPrototypeMethod(tpl, "getRatioMaxValue", GetRatioMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetRatioMinValue", GetRatioMinValue);
	Nan::SetPrototypeMethod(tpl, "getRatioMinValue", GetRatioMinValue);

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

	Nan::SetPrototypeMethod(tpl, "GetSecondaryPolarArcsProperty", GetSecondaryPolarArcsProperty);
	Nan::SetPrototypeMethod(tpl, "getSecondaryPolarArcsProperty", GetSecondaryPolarArcsProperty);

	Nan::SetPrototypeMethod(tpl, "GetSecondaryRadialAxesProperty", GetSecondaryRadialAxesProperty);
	Nan::SetPrototypeMethod(tpl, "getSecondaryRadialAxesProperty", GetSecondaryRadialAxesProperty);

	Nan::SetPrototypeMethod(tpl, "GetSecondaryRadialAxesTextProperty", GetSecondaryRadialAxesTextProperty);
	Nan::SetPrototypeMethod(tpl, "getSecondaryRadialAxesTextProperty", GetSecondaryRadialAxesTextProperty);

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

	Nan::SetPrototypeMethod(tpl, "GetTickLocationMaxValue", GetTickLocationMaxValue);
	Nan::SetPrototypeMethod(tpl, "getTickLocationMaxValue", GetTickLocationMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetTickLocationMinValue", GetTickLocationMinValue);
	Nan::SetPrototypeMethod(tpl, "getTickLocationMinValue", GetTickLocationMinValue);

	Nan::SetPrototypeMethod(tpl, "GetUse2DMode", GetUse2DMode);
	Nan::SetPrototypeMethod(tpl, "getUse2DMode", GetUse2DMode);

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

	Nan::SetPrototypeMethod(tpl, "LogOn", LogOn);
	Nan::SetPrototypeMethod(tpl, "logOn", LogOn);

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

	Nan::SetPrototypeMethod(tpl, "RadialAxesOriginToPolarAxisOn", RadialAxesOriginToPolarAxisOn);
	Nan::SetPrototypeMethod(tpl, "radialAxesOriginToPolarAxisOn", RadialAxesOriginToPolarAxisOn);

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

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

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

	Nan::SetPrototypeMethod(tpl, "SetArcMajorTickSize", SetArcMajorTickSize);
	Nan::SetPrototypeMethod(tpl, "setArcMajorTickSize", SetArcMajorTickSize);

	Nan::SetPrototypeMethod(tpl, "SetArcMajorTickThickness", SetArcMajorTickThickness);
	Nan::SetPrototypeMethod(tpl, "setArcMajorTickThickness", SetArcMajorTickThickness);

	Nan::SetPrototypeMethod(tpl, "SetArcMinorTickVisibility", SetArcMinorTickVisibility);
	Nan::SetPrototypeMethod(tpl, "setArcMinorTickVisibility", SetArcMinorTickVisibility);

	Nan::SetPrototypeMethod(tpl, "SetArcTickRatioSize", SetArcTickRatioSize);
	Nan::SetPrototypeMethod(tpl, "setArcTickRatioSize", SetArcTickRatioSize);

	Nan::SetPrototypeMethod(tpl, "SetArcTickRatioThickness", SetArcTickRatioThickness);
	Nan::SetPrototypeMethod(tpl, "setArcTickRatioThickness", SetArcTickRatioThickness);

	Nan::SetPrototypeMethod(tpl, "SetArcTickVisibility", SetArcTickVisibility);
	Nan::SetPrototypeMethod(tpl, "setArcTickVisibility", SetArcTickVisibility);

	Nan::SetPrototypeMethod(tpl, "SetArcTicksOriginToPolarAxis", SetArcTicksOriginToPolarAxis);
	Nan::SetPrototypeMethod(tpl, "setArcTicksOriginToPolarAxis", SetArcTicksOriginToPolarAxis);

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

	Nan::SetPrototypeMethod(tpl, "SetAxisMinorTickVisibility", SetAxisMinorTickVisibility);
	Nan::SetPrototypeMethod(tpl, "setAxisMinorTickVisibility", SetAxisMinorTickVisibility);

	Nan::SetPrototypeMethod(tpl, "SetAxisTickVisibility", SetAxisTickVisibility);
	Nan::SetPrototypeMethod(tpl, "setAxisTickVisibility", SetAxisTickVisibility);

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

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

	Nan::SetPrototypeMethod(tpl, "SetDeltaAngleMajor", SetDeltaAngleMajor);
	Nan::SetPrototypeMethod(tpl, "setDeltaAngleMajor", SetDeltaAngleMajor);

	Nan::SetPrototypeMethod(tpl, "SetDeltaAngleMinor", SetDeltaAngleMinor);
	Nan::SetPrototypeMethod(tpl, "setDeltaAngleMinor", SetDeltaAngleMinor);

	Nan::SetPrototypeMethod(tpl, "SetDeltaAngleRadialAxes", SetDeltaAngleRadialAxes);
	Nan::SetPrototypeMethod(tpl, "setDeltaAngleRadialAxes", SetDeltaAngleRadialAxes);

	Nan::SetPrototypeMethod(tpl, "SetDeltaRangeMajor", SetDeltaRangeMajor);
	Nan::SetPrototypeMethod(tpl, "setDeltaRangeMajor", SetDeltaRangeMajor);

	Nan::SetPrototypeMethod(tpl, "SetDeltaRangeMinor", SetDeltaRangeMinor);
	Nan::SetPrototypeMethod(tpl, "setDeltaRangeMinor", SetDeltaRangeMinor);

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

	Nan::SetPrototypeMethod(tpl, "SetDrawPolarArcsGridlines", SetDrawPolarArcsGridlines);
	Nan::SetPrototypeMethod(tpl, "setDrawPolarArcsGridlines", SetDrawPolarArcsGridlines);

	Nan::SetPrototypeMethod(tpl, "SetDrawRadialGridlines", SetDrawRadialGridlines);
	Nan::SetPrototypeMethod(tpl, "setDrawRadialGridlines", SetDrawRadialGridlines);

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

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

	Nan::SetPrototypeMethod(tpl, "SetExponentLocation", SetExponentLocation);
	Nan::SetPrototypeMethod(tpl, "setExponentLocation", SetExponentLocation);

	Nan::SetPrototypeMethod(tpl, "SetLastAxisTickRatioSize", SetLastAxisTickRatioSize);
	Nan::SetPrototypeMethod(tpl, "setLastAxisTickRatioSize", SetLastAxisTickRatioSize);

	Nan::SetPrototypeMethod(tpl, "SetLastAxisTickRatioThickness", SetLastAxisTickRatioThickness);
	Nan::SetPrototypeMethod(tpl, "setLastAxisTickRatioThickness", SetLastAxisTickRatioThickness);

	Nan::SetPrototypeMethod(tpl, "SetLastRadialAxisMajorTickSize", SetLastRadialAxisMajorTickSize);
	Nan::SetPrototypeMethod(tpl, "setLastRadialAxisMajorTickSize", SetLastRadialAxisMajorTickSize);

	Nan::SetPrototypeMethod(tpl, "SetLastRadialAxisMajorTickThickness", SetLastRadialAxisMajorTickThickness);
	Nan::SetPrototypeMethod(tpl, "setLastRadialAxisMajorTickThickness", SetLastRadialAxisMajorTickThickness);

	Nan::SetPrototypeMethod(tpl, "SetLastRadialAxisProperty", SetLastRadialAxisProperty);
	Nan::SetPrototypeMethod(tpl, "setLastRadialAxisProperty", SetLastRadialAxisProperty);

	Nan::SetPrototypeMethod(tpl, "SetLastRadialAxisTextProperty", SetLastRadialAxisTextProperty);
	Nan::SetPrototypeMethod(tpl, "setLastRadialAxisTextProperty", SetLastRadialAxisTextProperty);

	Nan::SetPrototypeMethod(tpl, "SetLog", SetLog);
	Nan::SetPrototypeMethod(tpl, "setLog", SetLog);

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

	Nan::SetPrototypeMethod(tpl, "SetNumberOfPolarAxisTicks", SetNumberOfPolarAxisTicks);
	Nan::SetPrototypeMethod(tpl, "setNumberOfPolarAxisTicks", SetNumberOfPolarAxisTicks);

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

	Nan::SetPrototypeMethod(tpl, "SetPolarAxisMajorTickThickness", SetPolarAxisMajorTickThickness);
	Nan::SetPrototypeMethod(tpl, "setPolarAxisMajorTickThickness", SetPolarAxisMajorTickThickness);

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

	Nan::SetPrototypeMethod(tpl, "SetPolarAxisTickRatioSize", SetPolarAxisTickRatioSize);
	Nan::SetPrototypeMethod(tpl, "setPolarAxisTickRatioSize", SetPolarAxisTickRatioSize);

	Nan::SetPrototypeMethod(tpl, "SetPolarAxisTickRatioThickness", SetPolarAxisTickRatioThickness);
	Nan::SetPrototypeMethod(tpl, "setPolarAxisTickRatioThickness", SetPolarAxisTickRatioThickness);

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

	Nan::SetPrototypeMethod(tpl, "SetPolarAxisTitleLocation", SetPolarAxisTitleLocation);
	Nan::SetPrototypeMethod(tpl, "setPolarAxisTitleLocation", SetPolarAxisTitleLocation);

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

	Nan::SetPrototypeMethod(tpl, "SetRadialAxesOriginToPolarAxis", SetRadialAxesOriginToPolarAxis);
	Nan::SetPrototypeMethod(tpl, "setRadialAxesOriginToPolarAxis", SetRadialAxesOriginToPolarAxis);

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

	Nan::SetPrototypeMethod(tpl, "SetRadialAxisTitleLocation", SetRadialAxisTitleLocation);
	Nan::SetPrototypeMethod(tpl, "setRadialAxisTitleLocation", SetRadialAxisTitleLocation);

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

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

	Nan::SetPrototypeMethod(tpl, "SetRange", SetRange);
	Nan::SetPrototypeMethod(tpl, "setRange", SetRange);

	Nan::SetPrototypeMethod(tpl, "SetRatio", SetRatio);
	Nan::SetPrototypeMethod(tpl, "setRatio", SetRatio);

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

	Nan::SetPrototypeMethod(tpl, "SetSecondaryPolarArcsProperty", SetSecondaryPolarArcsProperty);
	Nan::SetPrototypeMethod(tpl, "setSecondaryPolarArcsProperty", SetSecondaryPolarArcsProperty);

	Nan::SetPrototypeMethod(tpl, "SetSecondaryRadialAxesProperty", SetSecondaryRadialAxesProperty);
	Nan::SetPrototypeMethod(tpl, "setSecondaryRadialAxesProperty", SetSecondaryRadialAxesProperty);

	Nan::SetPrototypeMethod(tpl, "SetSecondaryRadialAxesTextProperty", SetSecondaryRadialAxesTextProperty);
	Nan::SetPrototypeMethod(tpl, "setSecondaryRadialAxesTextProperty", SetSecondaryRadialAxesTextProperty);

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

	Nan::SetPrototypeMethod(tpl, "SetTickLocation", SetTickLocation);
	Nan::SetPrototypeMethod(tpl, "setTickLocation", SetTickLocation);

	Nan::SetPrototypeMethod(tpl, "SetUse2DMode", SetUse2DMode);
	Nan::SetPrototypeMethod(tpl, "setUse2DMode", SetUse2DMode);

	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::ArcMinorTickVisibilityOff(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->ArcMinorTickVisibilityOff();
}

void VtkPolarAxesActorWrap::ArcMinorTickVisibilityOn(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->ArcMinorTickVisibilityOn();
}

void VtkPolarAxesActorWrap::ArcTickVisibilityOff(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->ArcTickVisibilityOff();
}

void VtkPolarAxesActorWrap::ArcTickVisibilityOn(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->ArcTickVisibilityOn();
}

void VtkPolarAxesActorWrap::ArcTicksOriginToPolarAxisOff(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->ArcTicksOriginToPolarAxisOff();
}

void VtkPolarAxesActorWrap::ArcTicksOriginToPolarAxisOn(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->ArcTicksOriginToPolarAxisOn();
}

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::AxisMinorTickVisibilityOff(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->AxisMinorTickVisibilityOff();
}

void VtkPolarAxesActorWrap::AxisMinorTickVisibilityOn(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->AxisMinorTickVisibilityOn();
}

void VtkPolarAxesActorWrap::AxisTickVisibilityOff(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->AxisTickVisibilityOff();
}

void VtkPolarAxesActorWrap::AxisTickVisibilityOn(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->AxisTickVisibilityOn();
}

void VtkPolarAxesActorWrap::DrawPolarArcsGridlinesOff(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->DrawPolarArcsGridlinesOff();
}

void VtkPolarAxesActorWrap::DrawPolarArcsGridlinesOn(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->DrawPolarArcsGridlinesOn();
}

void VtkPolarAxesActorWrap::DrawRadialGridlinesOff(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->DrawRadialGridlinesOff();
}

void VtkPolarAxesActorWrap::DrawRadialGridlinesOn(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->DrawRadialGridlinesOn();
}

void VtkPolarAxesActorWrap::GetArcMajorTickSize(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->GetArcMajorTickSize();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetArcMajorTickThickness(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->GetArcMajorTickThickness();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetArcMinorTickVisibility(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->GetArcMinorTickVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetArcTickRatioSize(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->GetArcTickRatioSize();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetArcTickRatioThickness(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->GetArcTickRatioThickness();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetArcTickVisibility(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->GetArcTickVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetArcTicksOriginToPolarAxis(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->GetArcTicksOriginToPolarAxis();
	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::GetAxisMinorTickVisibility(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->GetAxisMinorTickVisibility();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetAxisTickVisibility(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->GetAxisTickVisibility();
	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::GetDeltaAngleMajor(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->GetDeltaAngleMajor();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetDeltaAngleMinor(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->GetDeltaAngleMinor();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetDeltaAngleRadialAxes(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->GetDeltaAngleRadialAxes();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetDeltaRangeMajor(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->GetDeltaRangeMajor();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetDeltaRangeMinor(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->GetDeltaRangeMinor();
	info.GetReturnValue().Set(Nan::New(r));
}

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::GetDrawPolarArcsGridlines(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->GetDrawPolarArcsGridlines();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetDrawRadialGridlines(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->GetDrawRadialGridlines();
	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::GetExponentLocation(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->GetExponentLocation();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetExponentLocationMaxValue(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->GetExponentLocationMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetExponentLocationMinValue(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->GetExponentLocationMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetLastAxisTickRatioSize(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->GetLastAxisTickRatioSize();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetLastAxisTickRatioThickness(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->GetLastAxisTickRatioThickness();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetLastRadialAxisMajorTickSize(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->GetLastRadialAxisMajorTickSize();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetLastRadialAxisMajorTickThickness(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->GetLastRadialAxisMajorTickThickness();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetLastRadialAxisProperty(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->GetLastRadialAxisProperty();
	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::GetLastRadialAxisTextProperty(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->GetLastRadialAxisTextProperty();
	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::GetLog(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->GetLog();
	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::GetMinimumRadius(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->GetMinimumRadius();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetNumberOfPolarAxisTicks(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->GetNumberOfPolarAxisTicks();
	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::GetPolarAxisMajorTickSize(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->GetPolarAxisMajorTickSize();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetPolarAxisMajorTickThickness(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->GetPolarAxisMajorTickThickness();
	info.GetReturnValue().Set(Nan::New(r));
}

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::GetPolarAxisTickRatioSize(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->GetPolarAxisTickRatioSize();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetPolarAxisTickRatioThickness(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->GetPolarAxisTickRatioThickness();
	info.GetReturnValue().Set(Nan::New(r));
}

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::GetPolarAxisTitleLocation(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->GetPolarAxisTitleLocation();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetPolarAxisTitleLocationMaxValue(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->GetPolarAxisTitleLocationMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetPolarAxisTitleLocationMinValue(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->GetPolarAxisTitleLocationMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

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::GetRadialAngleFormat(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->GetRadialAngleFormat();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkPolarAxesActorWrap::GetRadialAxesOriginToPolarAxis(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->GetRadialAxesOriginToPolarAxis();
	info.GetReturnValue().Set(Nan::New(r));
}

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::GetRadialAxisTitleLocation(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->GetRadialAxisTitleLocation();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetRadialAxisTitleLocationMaxValue(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->GetRadialAxisTitleLocationMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetRadialAxisTitleLocationMinValue(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->GetRadialAxisTitleLocationMinValue();
	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::GetRange(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->GetRange();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 2 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 2);
	memcpy(ab->GetContents().Data(), r, 2 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkPolarAxesActorWrap::GetRatio(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->GetRatio();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetRatioMaxValue(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->GetRatioMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetRatioMinValue(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->GetRatioMinValue();
	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::GetSecondaryPolarArcsProperty(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->GetSecondaryPolarArcsProperty();
	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::GetSecondaryRadialAxesProperty(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->GetSecondaryRadialAxesProperty();
	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::GetSecondaryRadialAxesTextProperty(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->GetSecondaryRadialAxesTextProperty();
	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::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::GetTickLocation(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->GetTickLocation();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetTickLocationMaxValue(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->GetTickLocationMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetTickLocationMinValue(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->GetTickLocationMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkPolarAxesActorWrap::GetUse2DMode(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->GetUse2DMode();
	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::LogOff(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->LogOff();
}

void VtkPolarAxesActorWrap::LogOn(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->LogOn();
}

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::RadialAxesOriginToPolarAxisOff(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->RadialAxesOriginToPolarAxisOff();
}

void VtkPolarAxesActorWrap::RadialAxesOriginToPolarAxisOn(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->RadialAxesOriginToPolarAxisOn();
}

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::RenderOverlay(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->RenderOverlay(
			(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(VtkObjectBaseWrap::ptpl))->HasInstance(info[0]))
	{
		VtkObjectBaseWrap *a0 = ObjectWrap::Unwrap<VtkObjectBaseWrap>(info[0]->ToObject());
		vtkPolarAxesActor * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->SafeDownCast(
			(vtkObjectBase *) 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::SetArcMajorTickSize(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->SetArcMajorTickSize(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetArcMajorTickThickness(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->SetArcMajorTickThickness(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetArcMinorTickVisibility(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->SetArcMinorTickVisibility(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetArcTickRatioSize(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->SetArcTickRatioSize(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetArcTickRatioThickness(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->SetArcTickRatioThickness(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetArcTickVisibility(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->SetArcTickVisibility(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetArcTicksOriginToPolarAxis(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->SetArcTicksOriginToPolarAxis(
			info[0]->Int32Value()
		);
		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::SetAxisMinorTickVisibility(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->SetAxisMinorTickVisibility(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetAxisTickVisibility(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->SetAxisTickVisibility(
			info[0]->Int32Value()
		);
		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::SetDeltaAngleMajor(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->SetDeltaAngleMajor(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetDeltaAngleMinor(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->SetDeltaAngleMinor(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetDeltaAngleRadialAxes(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->SetDeltaAngleRadialAxes(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetDeltaRangeMajor(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->SetDeltaRangeMajor(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetDeltaRangeMinor(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->SetDeltaRangeMinor(
			info[0]->NumberValue()
		);
		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::SetDrawPolarArcsGridlines(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->SetDrawPolarArcsGridlines(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetDrawRadialGridlines(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->SetDrawRadialGridlines(
			info[0]->Int32Value()
		);
		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::SetExponentLocation(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->SetExponentLocation(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetLastAxisTickRatioSize(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->SetLastAxisTickRatioSize(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetLastAxisTickRatioThickness(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->SetLastAxisTickRatioThickness(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetLastRadialAxisMajorTickSize(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->SetLastRadialAxisMajorTickSize(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetLastRadialAxisMajorTickThickness(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->SetLastRadialAxisMajorTickThickness(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetLastRadialAxisProperty(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->SetLastRadialAxisProperty(
			(vtkProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetLastRadialAxisTextProperty(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->SetLastRadialAxisTextProperty(
			(vtkTextProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetLog(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->SetLog(
			info[0]->BooleanValue()
		);
		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::SetMinimumRadius(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->SetMinimumRadius(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetNumberOfPolarAxisTicks(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->SetNumberOfPolarAxisTicks(
			info[0]->Int32Value()
		);
		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::SetPolarAxisMajorTickSize(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->SetPolarAxisMajorTickSize(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetPolarAxisMajorTickThickness(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->SetPolarAxisMajorTickThickness(
			info[0]->NumberValue()
		);
		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::SetPolarAxisTickRatioSize(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->SetPolarAxisTickRatioSize(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetPolarAxisTickRatioThickness(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->SetPolarAxisTickRatioThickness(
			info[0]->NumberValue()
		);
		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::SetPolarAxisTitleLocation(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->SetPolarAxisTitleLocation(
			info[0]->Int32Value()
		);
		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::SetRadialAngleFormat(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->SetRadialAngleFormat(
			*a0
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetRadialAxesOriginToPolarAxis(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->SetRadialAxesOriginToPolarAxis(
			info[0]->Int32Value()
		);
		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::SetRadialAxisTitleLocation(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->SetRadialAxisTitleLocation(
			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::SetRange(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() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetRange(
			(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->SetRange(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetRange(
				info[0]->NumberValue(),
				info[1]->NumberValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetRatio(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->SetRatio(
			info[0]->NumberValue()
		);
		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::SetSecondaryPolarArcsProperty(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->SetSecondaryPolarArcsProperty(
			(vtkProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetSecondaryRadialAxesProperty(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->SetSecondaryRadialAxesProperty(
			(vtkProperty *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetSecondaryRadialAxesTextProperty(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->SetSecondaryRadialAxesTextProperty(
			(vtkTextProperty *) a0->native.GetPointer()
		);
		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::SetTickLocation(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->SetTickLocation(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkPolarAxesActorWrap::SetUse2DMode(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->SetUse2DMode(
			info[0]->Int32Value()
		);
		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");
}