/* 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 "vtkDataSetAlgorithmWrap.h"
#include "vtkMeshQualityWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkCellWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkMeshQualityWrap::VtkMeshQualityWrap()
{ }

VtkMeshQualityWrap::VtkMeshQualityWrap(vtkSmartPointer<vtkMeshQuality> _native)
{ native = _native; }

VtkMeshQualityWrap::~VtkMeshQualityWrap()
{ }

void VtkMeshQualityWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkMeshQuality").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("MeshQuality").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "CompatibilityModeOff", CompatibilityModeOff);
	Nan::SetPrototypeMethod(tpl, "compatibilityModeOff", CompatibilityModeOff);

	Nan::SetPrototypeMethod(tpl, "CompatibilityModeOn", CompatibilityModeOn);
	Nan::SetPrototypeMethod(tpl, "compatibilityModeOn", CompatibilityModeOn);

	Nan::SetPrototypeMethod(tpl, "GetCompatibilityMode", GetCompatibilityMode);
	Nan::SetPrototypeMethod(tpl, "getCompatibilityMode", GetCompatibilityMode);

	Nan::SetPrototypeMethod(tpl, "GetHexQualityMeasure", GetHexQualityMeasure);
	Nan::SetPrototypeMethod(tpl, "getHexQualityMeasure", GetHexQualityMeasure);

	Nan::SetPrototypeMethod(tpl, "GetQuadQualityMeasure", GetQuadQualityMeasure);
	Nan::SetPrototypeMethod(tpl, "getQuadQualityMeasure", GetQuadQualityMeasure);

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

	Nan::SetPrototypeMethod(tpl, "GetSaveCellQuality", GetSaveCellQuality);
	Nan::SetPrototypeMethod(tpl, "getSaveCellQuality", GetSaveCellQuality);

	Nan::SetPrototypeMethod(tpl, "GetTetQualityMeasure", GetTetQualityMeasure);
	Nan::SetPrototypeMethod(tpl, "getTetQualityMeasure", GetTetQualityMeasure);

	Nan::SetPrototypeMethod(tpl, "GetTriangleQualityMeasure", GetTriangleQualityMeasure);
	Nan::SetPrototypeMethod(tpl, "getTriangleQualityMeasure", GetTriangleQualityMeasure);

	Nan::SetPrototypeMethod(tpl, "GetVolume", GetVolume);
	Nan::SetPrototypeMethod(tpl, "getVolume", GetVolume);

	Nan::SetPrototypeMethod(tpl, "HexCondition", HexCondition);
	Nan::SetPrototypeMethod(tpl, "hexCondition", HexCondition);

	Nan::SetPrototypeMethod(tpl, "HexDiagonal", HexDiagonal);
	Nan::SetPrototypeMethod(tpl, "hexDiagonal", HexDiagonal);

	Nan::SetPrototypeMethod(tpl, "HexDimension", HexDimension);
	Nan::SetPrototypeMethod(tpl, "hexDimension", HexDimension);

	Nan::SetPrototypeMethod(tpl, "HexDistortion", HexDistortion);
	Nan::SetPrototypeMethod(tpl, "hexDistortion", HexDistortion);

	Nan::SetPrototypeMethod(tpl, "HexEdgeRatio", HexEdgeRatio);
	Nan::SetPrototypeMethod(tpl, "hexEdgeRatio", HexEdgeRatio);

	Nan::SetPrototypeMethod(tpl, "HexJacobian", HexJacobian);
	Nan::SetPrototypeMethod(tpl, "hexJacobian", HexJacobian);

	Nan::SetPrototypeMethod(tpl, "HexMaxAspectFrobenius", HexMaxAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "hexMaxAspectFrobenius", HexMaxAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "HexMaxEdgeRatio", HexMaxEdgeRatio);
	Nan::SetPrototypeMethod(tpl, "hexMaxEdgeRatio", HexMaxEdgeRatio);

	Nan::SetPrototypeMethod(tpl, "HexMedAspectFrobenius", HexMedAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "hexMedAspectFrobenius", HexMedAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "HexOddy", HexOddy);
	Nan::SetPrototypeMethod(tpl, "hexOddy", HexOddy);

	Nan::SetPrototypeMethod(tpl, "HexRelativeSizeSquared", HexRelativeSizeSquared);
	Nan::SetPrototypeMethod(tpl, "hexRelativeSizeSquared", HexRelativeSizeSquared);

	Nan::SetPrototypeMethod(tpl, "HexScaledJacobian", HexScaledJacobian);
	Nan::SetPrototypeMethod(tpl, "hexScaledJacobian", HexScaledJacobian);

	Nan::SetPrototypeMethod(tpl, "HexShape", HexShape);
	Nan::SetPrototypeMethod(tpl, "hexShape", HexShape);

	Nan::SetPrototypeMethod(tpl, "HexShapeAndSize", HexShapeAndSize);
	Nan::SetPrototypeMethod(tpl, "hexShapeAndSize", HexShapeAndSize);

	Nan::SetPrototypeMethod(tpl, "HexShear", HexShear);
	Nan::SetPrototypeMethod(tpl, "hexShear", HexShear);

	Nan::SetPrototypeMethod(tpl, "HexShearAndSize", HexShearAndSize);
	Nan::SetPrototypeMethod(tpl, "hexShearAndSize", HexShearAndSize);

	Nan::SetPrototypeMethod(tpl, "HexSkew", HexSkew);
	Nan::SetPrototypeMethod(tpl, "hexSkew", HexSkew);

	Nan::SetPrototypeMethod(tpl, "HexStretch", HexStretch);
	Nan::SetPrototypeMethod(tpl, "hexStretch", HexStretch);

	Nan::SetPrototypeMethod(tpl, "HexTaper", HexTaper);
	Nan::SetPrototypeMethod(tpl, "hexTaper", HexTaper);

	Nan::SetPrototypeMethod(tpl, "HexVolume", HexVolume);
	Nan::SetPrototypeMethod(tpl, "hexVolume", HexVolume);

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

	Nan::SetPrototypeMethod(tpl, "QuadArea", QuadArea);
	Nan::SetPrototypeMethod(tpl, "quadArea", QuadArea);

	Nan::SetPrototypeMethod(tpl, "QuadAspectRatio", QuadAspectRatio);
	Nan::SetPrototypeMethod(tpl, "quadAspectRatio", QuadAspectRatio);

	Nan::SetPrototypeMethod(tpl, "QuadCondition", QuadCondition);
	Nan::SetPrototypeMethod(tpl, "quadCondition", QuadCondition);

	Nan::SetPrototypeMethod(tpl, "QuadDistortion", QuadDistortion);
	Nan::SetPrototypeMethod(tpl, "quadDistortion", QuadDistortion);

	Nan::SetPrototypeMethod(tpl, "QuadEdgeRatio", QuadEdgeRatio);
	Nan::SetPrototypeMethod(tpl, "quadEdgeRatio", QuadEdgeRatio);

	Nan::SetPrototypeMethod(tpl, "QuadJacobian", QuadJacobian);
	Nan::SetPrototypeMethod(tpl, "quadJacobian", QuadJacobian);

	Nan::SetPrototypeMethod(tpl, "QuadMaxAngle", QuadMaxAngle);
	Nan::SetPrototypeMethod(tpl, "quadMaxAngle", QuadMaxAngle);

	Nan::SetPrototypeMethod(tpl, "QuadMaxAspectFrobenius", QuadMaxAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "quadMaxAspectFrobenius", QuadMaxAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "QuadMaxEdgeRatios", QuadMaxEdgeRatios);
	Nan::SetPrototypeMethod(tpl, "quadMaxEdgeRatios", QuadMaxEdgeRatios);

	Nan::SetPrototypeMethod(tpl, "QuadMedAspectFrobenius", QuadMedAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "quadMedAspectFrobenius", QuadMedAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "QuadMinAngle", QuadMinAngle);
	Nan::SetPrototypeMethod(tpl, "quadMinAngle", QuadMinAngle);

	Nan::SetPrototypeMethod(tpl, "QuadOddy", QuadOddy);
	Nan::SetPrototypeMethod(tpl, "quadOddy", QuadOddy);

	Nan::SetPrototypeMethod(tpl, "QuadRadiusRatio", QuadRadiusRatio);
	Nan::SetPrototypeMethod(tpl, "quadRadiusRatio", QuadRadiusRatio);

	Nan::SetPrototypeMethod(tpl, "QuadRelativeSizeSquared", QuadRelativeSizeSquared);
	Nan::SetPrototypeMethod(tpl, "quadRelativeSizeSquared", QuadRelativeSizeSquared);

	Nan::SetPrototypeMethod(tpl, "QuadScaledJacobian", QuadScaledJacobian);
	Nan::SetPrototypeMethod(tpl, "quadScaledJacobian", QuadScaledJacobian);

	Nan::SetPrototypeMethod(tpl, "QuadShape", QuadShape);
	Nan::SetPrototypeMethod(tpl, "quadShape", QuadShape);

	Nan::SetPrototypeMethod(tpl, "QuadShapeAndSize", QuadShapeAndSize);
	Nan::SetPrototypeMethod(tpl, "quadShapeAndSize", QuadShapeAndSize);

	Nan::SetPrototypeMethod(tpl, "QuadShear", QuadShear);
	Nan::SetPrototypeMethod(tpl, "quadShear", QuadShear);

	Nan::SetPrototypeMethod(tpl, "QuadShearAndSize", QuadShearAndSize);
	Nan::SetPrototypeMethod(tpl, "quadShearAndSize", QuadShearAndSize);

	Nan::SetPrototypeMethod(tpl, "QuadSkew", QuadSkew);
	Nan::SetPrototypeMethod(tpl, "quadSkew", QuadSkew);

	Nan::SetPrototypeMethod(tpl, "QuadStretch", QuadStretch);
	Nan::SetPrototypeMethod(tpl, "quadStretch", QuadStretch);

	Nan::SetPrototypeMethod(tpl, "QuadTaper", QuadTaper);
	Nan::SetPrototypeMethod(tpl, "quadTaper", QuadTaper);

	Nan::SetPrototypeMethod(tpl, "QuadWarpage", QuadWarpage);
	Nan::SetPrototypeMethod(tpl, "quadWarpage", QuadWarpage);

	Nan::SetPrototypeMethod(tpl, "RatioOff", RatioOff);
	Nan::SetPrototypeMethod(tpl, "ratioOff", RatioOff);

	Nan::SetPrototypeMethod(tpl, "RatioOn", RatioOn);
	Nan::SetPrototypeMethod(tpl, "ratioOn", RatioOn);

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

	Nan::SetPrototypeMethod(tpl, "SaveCellQualityOff", SaveCellQualityOff);
	Nan::SetPrototypeMethod(tpl, "saveCellQualityOff", SaveCellQualityOff);

	Nan::SetPrototypeMethod(tpl, "SaveCellQualityOn", SaveCellQualityOn);
	Nan::SetPrototypeMethod(tpl, "saveCellQualityOn", SaveCellQualityOn);

	Nan::SetPrototypeMethod(tpl, "SetCompatibilityMode", SetCompatibilityMode);
	Nan::SetPrototypeMethod(tpl, "setCompatibilityMode", SetCompatibilityMode);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasure", SetHexQualityMeasure);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasure", SetHexQualityMeasure);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToCondition", SetHexQualityMeasureToCondition);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToCondition", SetHexQualityMeasureToCondition);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToDiagonal", SetHexQualityMeasureToDiagonal);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToDiagonal", SetHexQualityMeasureToDiagonal);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToDimension", SetHexQualityMeasureToDimension);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToDimension", SetHexQualityMeasureToDimension);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToDistortion", SetHexQualityMeasureToDistortion);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToDistortion", SetHexQualityMeasureToDistortion);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToEdgeRatio", SetHexQualityMeasureToEdgeRatio);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToEdgeRatio", SetHexQualityMeasureToEdgeRatio);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToJacobian", SetHexQualityMeasureToJacobian);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToJacobian", SetHexQualityMeasureToJacobian);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToMaxAspectFrobenius", SetHexQualityMeasureToMaxAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToMaxAspectFrobenius", SetHexQualityMeasureToMaxAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToMaxEdgeRatios", SetHexQualityMeasureToMaxEdgeRatios);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToMaxEdgeRatios", SetHexQualityMeasureToMaxEdgeRatios);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToMedAspectFrobenius", SetHexQualityMeasureToMedAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToMedAspectFrobenius", SetHexQualityMeasureToMedAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToOddy", SetHexQualityMeasureToOddy);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToOddy", SetHexQualityMeasureToOddy);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToRelativeSizeSquared", SetHexQualityMeasureToRelativeSizeSquared);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToRelativeSizeSquared", SetHexQualityMeasureToRelativeSizeSquared);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToScaledJacobian", SetHexQualityMeasureToScaledJacobian);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToScaledJacobian", SetHexQualityMeasureToScaledJacobian);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToShape", SetHexQualityMeasureToShape);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToShape", SetHexQualityMeasureToShape);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToShapeAndSize", SetHexQualityMeasureToShapeAndSize);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToShapeAndSize", SetHexQualityMeasureToShapeAndSize);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToShear", SetHexQualityMeasureToShear);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToShear", SetHexQualityMeasureToShear);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToShearAndSize", SetHexQualityMeasureToShearAndSize);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToShearAndSize", SetHexQualityMeasureToShearAndSize);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToSkew", SetHexQualityMeasureToSkew);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToSkew", SetHexQualityMeasureToSkew);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToStretch", SetHexQualityMeasureToStretch);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToStretch", SetHexQualityMeasureToStretch);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToTaper", SetHexQualityMeasureToTaper);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToTaper", SetHexQualityMeasureToTaper);

	Nan::SetPrototypeMethod(tpl, "SetHexQualityMeasureToVolume", SetHexQualityMeasureToVolume);
	Nan::SetPrototypeMethod(tpl, "setHexQualityMeasureToVolume", SetHexQualityMeasureToVolume);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasure", SetQuadQualityMeasure);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasure", SetQuadQualityMeasure);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToArea", SetQuadQualityMeasureToArea);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToArea", SetQuadQualityMeasureToArea);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToAspectRatio", SetQuadQualityMeasureToAspectRatio);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToAspectRatio", SetQuadQualityMeasureToAspectRatio);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToCondition", SetQuadQualityMeasureToCondition);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToCondition", SetQuadQualityMeasureToCondition);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToDistortion", SetQuadQualityMeasureToDistortion);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToDistortion", SetQuadQualityMeasureToDistortion);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToEdgeRatio", SetQuadQualityMeasureToEdgeRatio);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToEdgeRatio", SetQuadQualityMeasureToEdgeRatio);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToJacobian", SetQuadQualityMeasureToJacobian);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToJacobian", SetQuadQualityMeasureToJacobian);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToMaxAngle", SetQuadQualityMeasureToMaxAngle);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToMaxAngle", SetQuadQualityMeasureToMaxAngle);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToMaxAspectFrobenius", SetQuadQualityMeasureToMaxAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToMaxAspectFrobenius", SetQuadQualityMeasureToMaxAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToMaxEdgeRatios", SetQuadQualityMeasureToMaxEdgeRatios);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToMaxEdgeRatios", SetQuadQualityMeasureToMaxEdgeRatios);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToMedAspectFrobenius", SetQuadQualityMeasureToMedAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToMedAspectFrobenius", SetQuadQualityMeasureToMedAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToMinAngle", SetQuadQualityMeasureToMinAngle);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToMinAngle", SetQuadQualityMeasureToMinAngle);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToOddy", SetQuadQualityMeasureToOddy);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToOddy", SetQuadQualityMeasureToOddy);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToRadiusRatio", SetQuadQualityMeasureToRadiusRatio);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToRadiusRatio", SetQuadQualityMeasureToRadiusRatio);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToRelativeSizeSquared", SetQuadQualityMeasureToRelativeSizeSquared);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToRelativeSizeSquared", SetQuadQualityMeasureToRelativeSizeSquared);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToScaledJacobian", SetQuadQualityMeasureToScaledJacobian);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToScaledJacobian", SetQuadQualityMeasureToScaledJacobian);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToShape", SetQuadQualityMeasureToShape);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToShape", SetQuadQualityMeasureToShape);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToShapeAndSize", SetQuadQualityMeasureToShapeAndSize);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToShapeAndSize", SetQuadQualityMeasureToShapeAndSize);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToShear", SetQuadQualityMeasureToShear);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToShear", SetQuadQualityMeasureToShear);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToShearAndSize", SetQuadQualityMeasureToShearAndSize);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToShearAndSize", SetQuadQualityMeasureToShearAndSize);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToSkew", SetQuadQualityMeasureToSkew);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToSkew", SetQuadQualityMeasureToSkew);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToStretch", SetQuadQualityMeasureToStretch);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToStretch", SetQuadQualityMeasureToStretch);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToTaper", SetQuadQualityMeasureToTaper);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToTaper", SetQuadQualityMeasureToTaper);

	Nan::SetPrototypeMethod(tpl, "SetQuadQualityMeasureToWarpage", SetQuadQualityMeasureToWarpage);
	Nan::SetPrototypeMethod(tpl, "setQuadQualityMeasureToWarpage", SetQuadQualityMeasureToWarpage);

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

	Nan::SetPrototypeMethod(tpl, "SetSaveCellQuality", SetSaveCellQuality);
	Nan::SetPrototypeMethod(tpl, "setSaveCellQuality", SetSaveCellQuality);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasure", SetTetQualityMeasure);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasure", SetTetQualityMeasure);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToAspectBeta", SetTetQualityMeasureToAspectBeta);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToAspectBeta", SetTetQualityMeasureToAspectBeta);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToAspectFrobenius", SetTetQualityMeasureToAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToAspectFrobenius", SetTetQualityMeasureToAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToAspectGamma", SetTetQualityMeasureToAspectGamma);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToAspectGamma", SetTetQualityMeasureToAspectGamma);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToAspectRatio", SetTetQualityMeasureToAspectRatio);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToAspectRatio", SetTetQualityMeasureToAspectRatio);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToCollapseRatio", SetTetQualityMeasureToCollapseRatio);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToCollapseRatio", SetTetQualityMeasureToCollapseRatio);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToCondition", SetTetQualityMeasureToCondition);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToCondition", SetTetQualityMeasureToCondition);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToDistortion", SetTetQualityMeasureToDistortion);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToDistortion", SetTetQualityMeasureToDistortion);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToEdgeRatio", SetTetQualityMeasureToEdgeRatio);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToEdgeRatio", SetTetQualityMeasureToEdgeRatio);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToJacobian", SetTetQualityMeasureToJacobian);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToJacobian", SetTetQualityMeasureToJacobian);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToMinAngle", SetTetQualityMeasureToMinAngle);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToMinAngle", SetTetQualityMeasureToMinAngle);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToRadiusRatio", SetTetQualityMeasureToRadiusRatio);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToRadiusRatio", SetTetQualityMeasureToRadiusRatio);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToRelativeSizeSquared", SetTetQualityMeasureToRelativeSizeSquared);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToRelativeSizeSquared", SetTetQualityMeasureToRelativeSizeSquared);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToScaledJacobian", SetTetQualityMeasureToScaledJacobian);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToScaledJacobian", SetTetQualityMeasureToScaledJacobian);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToShape", SetTetQualityMeasureToShape);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToShape", SetTetQualityMeasureToShape);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToShapeAndSize", SetTetQualityMeasureToShapeAndSize);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToShapeAndSize", SetTetQualityMeasureToShapeAndSize);

	Nan::SetPrototypeMethod(tpl, "SetTetQualityMeasureToVolume", SetTetQualityMeasureToVolume);
	Nan::SetPrototypeMethod(tpl, "setTetQualityMeasureToVolume", SetTetQualityMeasureToVolume);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasure", SetTriangleQualityMeasure);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasure", SetTriangleQualityMeasure);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToArea", SetTriangleQualityMeasureToArea);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToArea", SetTriangleQualityMeasureToArea);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToAspectFrobenius", SetTriangleQualityMeasureToAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToAspectFrobenius", SetTriangleQualityMeasureToAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToAspectRatio", SetTriangleQualityMeasureToAspectRatio);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToAspectRatio", SetTriangleQualityMeasureToAspectRatio);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToCondition", SetTriangleQualityMeasureToCondition);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToCondition", SetTriangleQualityMeasureToCondition);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToDistortion", SetTriangleQualityMeasureToDistortion);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToDistortion", SetTriangleQualityMeasureToDistortion);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToEdgeRatio", SetTriangleQualityMeasureToEdgeRatio);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToEdgeRatio", SetTriangleQualityMeasureToEdgeRatio);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToMaxAngle", SetTriangleQualityMeasureToMaxAngle);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToMaxAngle", SetTriangleQualityMeasureToMaxAngle);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToMinAngle", SetTriangleQualityMeasureToMinAngle);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToMinAngle", SetTriangleQualityMeasureToMinAngle);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToRadiusRatio", SetTriangleQualityMeasureToRadiusRatio);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToRadiusRatio", SetTriangleQualityMeasureToRadiusRatio);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToRelativeSizeSquared", SetTriangleQualityMeasureToRelativeSizeSquared);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToRelativeSizeSquared", SetTriangleQualityMeasureToRelativeSizeSquared);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToScaledJacobian", SetTriangleQualityMeasureToScaledJacobian);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToScaledJacobian", SetTriangleQualityMeasureToScaledJacobian);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToShape", SetTriangleQualityMeasureToShape);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToShape", SetTriangleQualityMeasureToShape);

	Nan::SetPrototypeMethod(tpl, "SetTriangleQualityMeasureToShapeAndSize", SetTriangleQualityMeasureToShapeAndSize);
	Nan::SetPrototypeMethod(tpl, "setTriangleQualityMeasureToShapeAndSize", SetTriangleQualityMeasureToShapeAndSize);

	Nan::SetPrototypeMethod(tpl, "SetVolume", SetVolume);
	Nan::SetPrototypeMethod(tpl, "setVolume", SetVolume);

	Nan::SetPrototypeMethod(tpl, "TetAspectBeta", TetAspectBeta);
	Nan::SetPrototypeMethod(tpl, "tetAspectBeta", TetAspectBeta);

	Nan::SetPrototypeMethod(tpl, "TetAspectFrobenius", TetAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "tetAspectFrobenius", TetAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "TetAspectGamma", TetAspectGamma);
	Nan::SetPrototypeMethod(tpl, "tetAspectGamma", TetAspectGamma);

	Nan::SetPrototypeMethod(tpl, "TetAspectRatio", TetAspectRatio);
	Nan::SetPrototypeMethod(tpl, "tetAspectRatio", TetAspectRatio);

	Nan::SetPrototypeMethod(tpl, "TetCollapseRatio", TetCollapseRatio);
	Nan::SetPrototypeMethod(tpl, "tetCollapseRatio", TetCollapseRatio);

	Nan::SetPrototypeMethod(tpl, "TetCondition", TetCondition);
	Nan::SetPrototypeMethod(tpl, "tetCondition", TetCondition);

	Nan::SetPrototypeMethod(tpl, "TetDistortion", TetDistortion);
	Nan::SetPrototypeMethod(tpl, "tetDistortion", TetDistortion);

	Nan::SetPrototypeMethod(tpl, "TetEdgeRatio", TetEdgeRatio);
	Nan::SetPrototypeMethod(tpl, "tetEdgeRatio", TetEdgeRatio);

	Nan::SetPrototypeMethod(tpl, "TetJacobian", TetJacobian);
	Nan::SetPrototypeMethod(tpl, "tetJacobian", TetJacobian);

	Nan::SetPrototypeMethod(tpl, "TetMinAngle", TetMinAngle);
	Nan::SetPrototypeMethod(tpl, "tetMinAngle", TetMinAngle);

	Nan::SetPrototypeMethod(tpl, "TetRadiusRatio", TetRadiusRatio);
	Nan::SetPrototypeMethod(tpl, "tetRadiusRatio", TetRadiusRatio);

	Nan::SetPrototypeMethod(tpl, "TetRelativeSizeSquared", TetRelativeSizeSquared);
	Nan::SetPrototypeMethod(tpl, "tetRelativeSizeSquared", TetRelativeSizeSquared);

	Nan::SetPrototypeMethod(tpl, "TetScaledJacobian", TetScaledJacobian);
	Nan::SetPrototypeMethod(tpl, "tetScaledJacobian", TetScaledJacobian);

	Nan::SetPrototypeMethod(tpl, "TetShape", TetShape);
	Nan::SetPrototypeMethod(tpl, "tetShape", TetShape);

	Nan::SetPrototypeMethod(tpl, "TetShapeandSize", TetShapeandSize);
	Nan::SetPrototypeMethod(tpl, "tetShapeandSize", TetShapeandSize);

	Nan::SetPrototypeMethod(tpl, "TetVolume", TetVolume);
	Nan::SetPrototypeMethod(tpl, "tetVolume", TetVolume);

	Nan::SetPrototypeMethod(tpl, "TriangleArea", TriangleArea);
	Nan::SetPrototypeMethod(tpl, "triangleArea", TriangleArea);

	Nan::SetPrototypeMethod(tpl, "TriangleAspectFrobenius", TriangleAspectFrobenius);
	Nan::SetPrototypeMethod(tpl, "triangleAspectFrobenius", TriangleAspectFrobenius);

	Nan::SetPrototypeMethod(tpl, "TriangleAspectRatio", TriangleAspectRatio);
	Nan::SetPrototypeMethod(tpl, "triangleAspectRatio", TriangleAspectRatio);

	Nan::SetPrototypeMethod(tpl, "TriangleCondition", TriangleCondition);
	Nan::SetPrototypeMethod(tpl, "triangleCondition", TriangleCondition);

	Nan::SetPrototypeMethod(tpl, "TriangleDistortion", TriangleDistortion);
	Nan::SetPrototypeMethod(tpl, "triangleDistortion", TriangleDistortion);

	Nan::SetPrototypeMethod(tpl, "TriangleEdgeRatio", TriangleEdgeRatio);
	Nan::SetPrototypeMethod(tpl, "triangleEdgeRatio", TriangleEdgeRatio);

	Nan::SetPrototypeMethod(tpl, "TriangleMaxAngle", TriangleMaxAngle);
	Nan::SetPrototypeMethod(tpl, "triangleMaxAngle", TriangleMaxAngle);

	Nan::SetPrototypeMethod(tpl, "TriangleMinAngle", TriangleMinAngle);
	Nan::SetPrototypeMethod(tpl, "triangleMinAngle", TriangleMinAngle);

	Nan::SetPrototypeMethod(tpl, "TriangleRadiusRatio", TriangleRadiusRatio);
	Nan::SetPrototypeMethod(tpl, "triangleRadiusRatio", TriangleRadiusRatio);

	Nan::SetPrototypeMethod(tpl, "TriangleRelativeSizeSquared", TriangleRelativeSizeSquared);
	Nan::SetPrototypeMethod(tpl, "triangleRelativeSizeSquared", TriangleRelativeSizeSquared);

	Nan::SetPrototypeMethod(tpl, "TriangleScaledJacobian", TriangleScaledJacobian);
	Nan::SetPrototypeMethod(tpl, "triangleScaledJacobian", TriangleScaledJacobian);

	Nan::SetPrototypeMethod(tpl, "TriangleShape", TriangleShape);
	Nan::SetPrototypeMethod(tpl, "triangleShape", TriangleShape);

	Nan::SetPrototypeMethod(tpl, "TriangleShapeAndSize", TriangleShapeAndSize);
	Nan::SetPrototypeMethod(tpl, "triangleShapeAndSize", TriangleShapeAndSize);

	Nan::SetPrototypeMethod(tpl, "VolumeOff", VolumeOff);
	Nan::SetPrototypeMethod(tpl, "volumeOff", VolumeOff);

	Nan::SetPrototypeMethod(tpl, "VolumeOn", VolumeOn);
	Nan::SetPrototypeMethod(tpl, "volumeOn", VolumeOn);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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