/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>

#include "vtkObjectWrap.h"
#include "vtkNIFTIImageHeaderWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkNIFTIImageHeaderWrap::VtkNIFTIImageHeaderWrap()
{ }

VtkNIFTIImageHeaderWrap::VtkNIFTIImageHeaderWrap(vtkSmartPointer<vtkNIFTIImageHeader> _native)
{ native = _native; }

VtkNIFTIImageHeaderWrap::~VtkNIFTIImageHeaderWrap()
{ }

void VtkNIFTIImageHeaderWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkNIFTIImageHeader").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("NIFTIImageHeader").ToLocalChecked(), ConstructorGetter);
}

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

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

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

	Nan::SetPrototypeMethod(tpl, "GetAuxFile", GetAuxFile);
	Nan::SetPrototypeMethod(tpl, "getAuxFile", GetAuxFile);

	Nan::SetPrototypeMethod(tpl, "GetBitPix", GetBitPix);
	Nan::SetPrototypeMethod(tpl, "getBitPix", GetBitPix);

	Nan::SetPrototypeMethod(tpl, "GetCalMax", GetCalMax);
	Nan::SetPrototypeMethod(tpl, "getCalMax", GetCalMax);

	Nan::SetPrototypeMethod(tpl, "GetCalMin", GetCalMin);
	Nan::SetPrototypeMethod(tpl, "getCalMin", GetCalMin);

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

	Nan::SetPrototypeMethod(tpl, "GetDataType", GetDataType);
	Nan::SetPrototypeMethod(tpl, "getDataType", GetDataType);

	Nan::SetPrototypeMethod(tpl, "GetDescrip", GetDescrip);
	Nan::SetPrototypeMethod(tpl, "getDescrip", GetDescrip);

	Nan::SetPrototypeMethod(tpl, "GetDimInfo", GetDimInfo);
	Nan::SetPrototypeMethod(tpl, "getDimInfo", GetDimInfo);

	Nan::SetPrototypeMethod(tpl, "GetIntentCode", GetIntentCode);
	Nan::SetPrototypeMethod(tpl, "getIntentCode", GetIntentCode);

	Nan::SetPrototypeMethod(tpl, "GetIntentName", GetIntentName);
	Nan::SetPrototypeMethod(tpl, "getIntentName", GetIntentName);

	Nan::SetPrototypeMethod(tpl, "GetIntentP1", GetIntentP1);
	Nan::SetPrototypeMethod(tpl, "getIntentP1", GetIntentP1);

	Nan::SetPrototypeMethod(tpl, "GetIntentP2", GetIntentP2);
	Nan::SetPrototypeMethod(tpl, "getIntentP2", GetIntentP2);

	Nan::SetPrototypeMethod(tpl, "GetIntentP3", GetIntentP3);
	Nan::SetPrototypeMethod(tpl, "getIntentP3", GetIntentP3);

	Nan::SetPrototypeMethod(tpl, "GetMagic", GetMagic);
	Nan::SetPrototypeMethod(tpl, "getMagic", GetMagic);

	Nan::SetPrototypeMethod(tpl, "GetPixDim", GetPixDim);
	Nan::SetPrototypeMethod(tpl, "getPixDim", GetPixDim);

	Nan::SetPrototypeMethod(tpl, "GetQFormCode", GetQFormCode);
	Nan::SetPrototypeMethod(tpl, "getQFormCode", GetQFormCode);

	Nan::SetPrototypeMethod(tpl, "GetQOffsetX", GetQOffsetX);
	Nan::SetPrototypeMethod(tpl, "getQOffsetX", GetQOffsetX);

	Nan::SetPrototypeMethod(tpl, "GetQOffsetY", GetQOffsetY);
	Nan::SetPrototypeMethod(tpl, "getQOffsetY", GetQOffsetY);

	Nan::SetPrototypeMethod(tpl, "GetQOffsetZ", GetQOffsetZ);
	Nan::SetPrototypeMethod(tpl, "getQOffsetZ", GetQOffsetZ);

	Nan::SetPrototypeMethod(tpl, "GetQuaternB", GetQuaternB);
	Nan::SetPrototypeMethod(tpl, "getQuaternB", GetQuaternB);

	Nan::SetPrototypeMethod(tpl, "GetQuaternC", GetQuaternC);
	Nan::SetPrototypeMethod(tpl, "getQuaternC", GetQuaternC);

	Nan::SetPrototypeMethod(tpl, "GetQuaternD", GetQuaternD);
	Nan::SetPrototypeMethod(tpl, "getQuaternD", GetQuaternD);

	Nan::SetPrototypeMethod(tpl, "GetSFormCode", GetSFormCode);
	Nan::SetPrototypeMethod(tpl, "getSFormCode", GetSFormCode);

	Nan::SetPrototypeMethod(tpl, "GetSRowX", GetSRowX);
	Nan::SetPrototypeMethod(tpl, "getSRowX", GetSRowX);

	Nan::SetPrototypeMethod(tpl, "GetSRowY", GetSRowY);
	Nan::SetPrototypeMethod(tpl, "getSRowY", GetSRowY);

	Nan::SetPrototypeMethod(tpl, "GetSRowZ", GetSRowZ);
	Nan::SetPrototypeMethod(tpl, "getSRowZ", GetSRowZ);

	Nan::SetPrototypeMethod(tpl, "GetSclInter", GetSclInter);
	Nan::SetPrototypeMethod(tpl, "getSclInter", GetSclInter);

	Nan::SetPrototypeMethod(tpl, "GetSclSlope", GetSclSlope);
	Nan::SetPrototypeMethod(tpl, "getSclSlope", GetSclSlope);

	Nan::SetPrototypeMethod(tpl, "GetSliceCode", GetSliceCode);
	Nan::SetPrototypeMethod(tpl, "getSliceCode", GetSliceCode);

	Nan::SetPrototypeMethod(tpl, "GetSliceDuration", GetSliceDuration);
	Nan::SetPrototypeMethod(tpl, "getSliceDuration", GetSliceDuration);

	Nan::SetPrototypeMethod(tpl, "GetTOffset", GetTOffset);
	Nan::SetPrototypeMethod(tpl, "getTOffset", GetTOffset);

	Nan::SetPrototypeMethod(tpl, "GetXYZTUnits", GetXYZTUnits);
	Nan::SetPrototypeMethod(tpl, "getXYZTUnits", GetXYZTUnits);

	Nan::SetPrototypeMethod(tpl, "Initialize", Initialize);
	Nan::SetPrototypeMethod(tpl, "initialize", Initialize);

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

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

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

	Nan::SetPrototypeMethod(tpl, "SetAuxFile", SetAuxFile);
	Nan::SetPrototypeMethod(tpl, "setAuxFile", SetAuxFile);

	Nan::SetPrototypeMethod(tpl, "SetCalMax", SetCalMax);
	Nan::SetPrototypeMethod(tpl, "setCalMax", SetCalMax);

	Nan::SetPrototypeMethod(tpl, "SetCalMin", SetCalMin);
	Nan::SetPrototypeMethod(tpl, "setCalMin", SetCalMin);

	Nan::SetPrototypeMethod(tpl, "SetDescrip", SetDescrip);
	Nan::SetPrototypeMethod(tpl, "setDescrip", SetDescrip);

	Nan::SetPrototypeMethod(tpl, "SetDimInfo", SetDimInfo);
	Nan::SetPrototypeMethod(tpl, "setDimInfo", SetDimInfo);

	Nan::SetPrototypeMethod(tpl, "SetIntentCode", SetIntentCode);
	Nan::SetPrototypeMethod(tpl, "setIntentCode", SetIntentCode);

	Nan::SetPrototypeMethod(tpl, "SetIntentName", SetIntentName);
	Nan::SetPrototypeMethod(tpl, "setIntentName", SetIntentName);

	Nan::SetPrototypeMethod(tpl, "SetIntentP1", SetIntentP1);
	Nan::SetPrototypeMethod(tpl, "setIntentP1", SetIntentP1);

	Nan::SetPrototypeMethod(tpl, "SetIntentP2", SetIntentP2);
	Nan::SetPrototypeMethod(tpl, "setIntentP2", SetIntentP2);

	Nan::SetPrototypeMethod(tpl, "SetIntentP3", SetIntentP3);
	Nan::SetPrototypeMethod(tpl, "setIntentP3", SetIntentP3);

	Nan::SetPrototypeMethod(tpl, "SetQFormCode", SetQFormCode);
	Nan::SetPrototypeMethod(tpl, "setQFormCode", SetQFormCode);

	Nan::SetPrototypeMethod(tpl, "SetQOffsetX", SetQOffsetX);
	Nan::SetPrototypeMethod(tpl, "setQOffsetX", SetQOffsetX);

	Nan::SetPrototypeMethod(tpl, "SetQOffsetY", SetQOffsetY);
	Nan::SetPrototypeMethod(tpl, "setQOffsetY", SetQOffsetY);

	Nan::SetPrototypeMethod(tpl, "SetQOffsetZ", SetQOffsetZ);
	Nan::SetPrototypeMethod(tpl, "setQOffsetZ", SetQOffsetZ);

	Nan::SetPrototypeMethod(tpl, "SetQuaternB", SetQuaternB);
	Nan::SetPrototypeMethod(tpl, "setQuaternB", SetQuaternB);

	Nan::SetPrototypeMethod(tpl, "SetQuaternC", SetQuaternC);
	Nan::SetPrototypeMethod(tpl, "setQuaternC", SetQuaternC);

	Nan::SetPrototypeMethod(tpl, "SetQuaternD", SetQuaternD);
	Nan::SetPrototypeMethod(tpl, "setQuaternD", SetQuaternD);

	Nan::SetPrototypeMethod(tpl, "SetSFormCode", SetSFormCode);
	Nan::SetPrototypeMethod(tpl, "setSFormCode", SetSFormCode);

	Nan::SetPrototypeMethod(tpl, "SetSRowX", SetSRowX);
	Nan::SetPrototypeMethod(tpl, "setSRowX", SetSRowX);

	Nan::SetPrototypeMethod(tpl, "SetSRowY", SetSRowY);
	Nan::SetPrototypeMethod(tpl, "setSRowY", SetSRowY);

	Nan::SetPrototypeMethod(tpl, "SetSRowZ", SetSRowZ);
	Nan::SetPrototypeMethod(tpl, "setSRowZ", SetSRowZ);

	Nan::SetPrototypeMethod(tpl, "SetSclInter", SetSclInter);
	Nan::SetPrototypeMethod(tpl, "setSclInter", SetSclInter);

	Nan::SetPrototypeMethod(tpl, "SetSclSlope", SetSclSlope);
	Nan::SetPrototypeMethod(tpl, "setSclSlope", SetSclSlope);

	Nan::SetPrototypeMethod(tpl, "SetSliceCode", SetSliceCode);
	Nan::SetPrototypeMethod(tpl, "setSliceCode", SetSliceCode);

	Nan::SetPrototypeMethod(tpl, "SetSliceDuration", SetSliceDuration);
	Nan::SetPrototypeMethod(tpl, "setSliceDuration", SetSliceDuration);

	Nan::SetPrototypeMethod(tpl, "SetTOffset", SetTOffset);
	Nan::SetPrototypeMethod(tpl, "setTOffset", SetTOffset);

	Nan::SetPrototypeMethod(tpl, "SetXYZTUnits", SetXYZTUnits);
	Nan::SetPrototypeMethod(tpl, "setXYZTUnits", SetXYZTUnits);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkNIFTIImageHeaderWrap::SetSRowX(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkNIFTIImageHeaderWrap *wrapper = ObjectWrap::Unwrap<VtkNIFTIImageHeaderWrap>(info.Holder());
	vtkNIFTIImageHeader *native = (vtkNIFTIImageHeader *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 4 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSRowX(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[4];
		if( a0->Length() < 4 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 4; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSRowX(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				if(info.Length() > 3 && info[3]->IsNumber())
				{
										if(info.Length() != 4)
					{
						Nan::ThrowError("Too many parameters.");
						return;
					}
					native->SetSRowX(
						info[0]->NumberValue(),
						info[1]->NumberValue(),
						info[2]->NumberValue(),
						info[3]->NumberValue()
					);
					return;
				}
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkNIFTIImageHeaderWrap::SetSRowY(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkNIFTIImageHeaderWrap *wrapper = ObjectWrap::Unwrap<VtkNIFTIImageHeaderWrap>(info.Holder());
	vtkNIFTIImageHeader *native = (vtkNIFTIImageHeader *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 4 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSRowY(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[4];
		if( a0->Length() < 4 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 4; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSRowY(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				if(info.Length() > 3 && info[3]->IsNumber())
				{
										if(info.Length() != 4)
					{
						Nan::ThrowError("Too many parameters.");
						return;
					}
					native->SetSRowY(
						info[0]->NumberValue(),
						info[1]->NumberValue(),
						info[2]->NumberValue(),
						info[3]->NumberValue()
					);
					return;
				}
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkNIFTIImageHeaderWrap::SetSRowZ(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkNIFTIImageHeaderWrap *wrapper = ObjectWrap::Unwrap<VtkNIFTIImageHeaderWrap>(info.Holder());
	vtkNIFTIImageHeader *native = (vtkNIFTIImageHeader *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 4 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSRowZ(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[4];
		if( a0->Length() < 4 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 4; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSRowZ(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				if(info.Length() > 3 && info[3]->IsNumber())
				{
										if(info.Length() != 4)
					{
						Nan::ThrowError("Too many parameters.");
						return;
					}
					native->SetSRowZ(
						info[0]->NumberValue(),
						info[1]->NumberValue(),
						info[2]->NumberValue(),
						info[3]->NumberValue()
					);
					return;
				}
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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