/* 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 "vtkMedicalImagePropertiesWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkMedicalImagePropertiesWrap::VtkMedicalImagePropertiesWrap()
{ }

VtkMedicalImagePropertiesWrap::VtkMedicalImagePropertiesWrap(vtkSmartPointer<vtkMedicalImageProperties> _native)
{ native = _native; }

VtkMedicalImagePropertiesWrap::~VtkMedicalImagePropertiesWrap()
{ }

void VtkMedicalImagePropertiesWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkMedicalImageProperties").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("MedicalImageProperties").ToLocalChecked(), ConstructorGetter);
}

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

void VtkMedicalImagePropertiesWrap::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("VtkMedicalImagePropertiesWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "AddUserDefinedValue", AddUserDefinedValue);
	Nan::SetPrototypeMethod(tpl, "addUserDefinedValue", AddUserDefinedValue);

	Nan::SetPrototypeMethod(tpl, "AddWindowLevelPreset", AddWindowLevelPreset);
	Nan::SetPrototypeMethod(tpl, "addWindowLevelPreset", AddWindowLevelPreset);

	Nan::SetPrototypeMethod(tpl, "Clear", Clear);
	Nan::SetPrototypeMethod(tpl, "clear", Clear);

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

	Nan::SetPrototypeMethod(tpl, "GetAcquisitionDate", GetAcquisitionDate);
	Nan::SetPrototypeMethod(tpl, "getAcquisitionDate", GetAcquisitionDate);

	Nan::SetPrototypeMethod(tpl, "GetAcquisitionDateDay", GetAcquisitionDateDay);
	Nan::SetPrototypeMethod(tpl, "getAcquisitionDateDay", GetAcquisitionDateDay);

	Nan::SetPrototypeMethod(tpl, "GetAcquisitionDateMonth", GetAcquisitionDateMonth);
	Nan::SetPrototypeMethod(tpl, "getAcquisitionDateMonth", GetAcquisitionDateMonth);

	Nan::SetPrototypeMethod(tpl, "GetAcquisitionDateYear", GetAcquisitionDateYear);
	Nan::SetPrototypeMethod(tpl, "getAcquisitionDateYear", GetAcquisitionDateYear);

	Nan::SetPrototypeMethod(tpl, "GetAcquisitionTime", GetAcquisitionTime);
	Nan::SetPrototypeMethod(tpl, "getAcquisitionTime", GetAcquisitionTime);

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

	Nan::SetPrototypeMethod(tpl, "GetConvolutionKernel", GetConvolutionKernel);
	Nan::SetPrototypeMethod(tpl, "getConvolutionKernel", GetConvolutionKernel);

	Nan::SetPrototypeMethod(tpl, "GetDateAsLocale", GetDateAsLocale);
	Nan::SetPrototypeMethod(tpl, "getDateAsLocale", GetDateAsLocale);

	Nan::SetPrototypeMethod(tpl, "GetDirectionCosine", GetDirectionCosine);
	Nan::SetPrototypeMethod(tpl, "getDirectionCosine", GetDirectionCosine);

	Nan::SetPrototypeMethod(tpl, "GetEchoTime", GetEchoTime);
	Nan::SetPrototypeMethod(tpl, "getEchoTime", GetEchoTime);

	Nan::SetPrototypeMethod(tpl, "GetEchoTrainLength", GetEchoTrainLength);
	Nan::SetPrototypeMethod(tpl, "getEchoTrainLength", GetEchoTrainLength);

	Nan::SetPrototypeMethod(tpl, "GetExposure", GetExposure);
	Nan::SetPrototypeMethod(tpl, "getExposure", GetExposure);

	Nan::SetPrototypeMethod(tpl, "GetExposureTime", GetExposureTime);
	Nan::SetPrototypeMethod(tpl, "getExposureTime", GetExposureTime);

	Nan::SetPrototypeMethod(tpl, "GetGantryTilt", GetGantryTilt);
	Nan::SetPrototypeMethod(tpl, "getGantryTilt", GetGantryTilt);

	Nan::SetPrototypeMethod(tpl, "GetGantryTiltAsDouble", GetGantryTiltAsDouble);
	Nan::SetPrototypeMethod(tpl, "getGantryTiltAsDouble", GetGantryTiltAsDouble);

	Nan::SetPrototypeMethod(tpl, "GetImageDate", GetImageDate);
	Nan::SetPrototypeMethod(tpl, "getImageDate", GetImageDate);

	Nan::SetPrototypeMethod(tpl, "GetImageDateDay", GetImageDateDay);
	Nan::SetPrototypeMethod(tpl, "getImageDateDay", GetImageDateDay);

	Nan::SetPrototypeMethod(tpl, "GetImageDateMonth", GetImageDateMonth);
	Nan::SetPrototypeMethod(tpl, "getImageDateMonth", GetImageDateMonth);

	Nan::SetPrototypeMethod(tpl, "GetImageDateYear", GetImageDateYear);
	Nan::SetPrototypeMethod(tpl, "getImageDateYear", GetImageDateYear);

	Nan::SetPrototypeMethod(tpl, "GetImageNumber", GetImageNumber);
	Nan::SetPrototypeMethod(tpl, "getImageNumber", GetImageNumber);

	Nan::SetPrototypeMethod(tpl, "GetImageTime", GetImageTime);
	Nan::SetPrototypeMethod(tpl, "getImageTime", GetImageTime);

	Nan::SetPrototypeMethod(tpl, "GetInstanceUIDFromSliceID", GetInstanceUIDFromSliceID);
	Nan::SetPrototypeMethod(tpl, "getInstanceUIDFromSliceID", GetInstanceUIDFromSliceID);

	Nan::SetPrototypeMethod(tpl, "GetInstitutionName", GetInstitutionName);
	Nan::SetPrototypeMethod(tpl, "getInstitutionName", GetInstitutionName);

	Nan::SetPrototypeMethod(tpl, "GetKVP", GetKVP);
	Nan::SetPrototypeMethod(tpl, "getKVP", GetKVP);

	Nan::SetPrototypeMethod(tpl, "GetManufacturer", GetManufacturer);
	Nan::SetPrototypeMethod(tpl, "getManufacturer", GetManufacturer);

	Nan::SetPrototypeMethod(tpl, "GetManufacturerModelName", GetManufacturerModelName);
	Nan::SetPrototypeMethod(tpl, "getManufacturerModelName", GetManufacturerModelName);

	Nan::SetPrototypeMethod(tpl, "GetModality", GetModality);
	Nan::SetPrototypeMethod(tpl, "getModality", GetModality);

	Nan::SetPrototypeMethod(tpl, "GetNthWindowLevelPreset", GetNthWindowLevelPreset);
	Nan::SetPrototypeMethod(tpl, "getNthWindowLevelPreset", GetNthWindowLevelPreset);

	Nan::SetPrototypeMethod(tpl, "GetNthWindowLevelPresetComment", GetNthWindowLevelPresetComment);
	Nan::SetPrototypeMethod(tpl, "getNthWindowLevelPresetComment", GetNthWindowLevelPresetComment);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfUserDefinedValues", GetNumberOfUserDefinedValues);
	Nan::SetPrototypeMethod(tpl, "getNumberOfUserDefinedValues", GetNumberOfUserDefinedValues);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfWindowLevelPresets", GetNumberOfWindowLevelPresets);
	Nan::SetPrototypeMethod(tpl, "getNumberOfWindowLevelPresets", GetNumberOfWindowLevelPresets);

	Nan::SetPrototypeMethod(tpl, "GetOrientationType", GetOrientationType);
	Nan::SetPrototypeMethod(tpl, "getOrientationType", GetOrientationType);

	Nan::SetPrototypeMethod(tpl, "GetPatientAge", GetPatientAge);
	Nan::SetPrototypeMethod(tpl, "getPatientAge", GetPatientAge);

	Nan::SetPrototypeMethod(tpl, "GetPatientAgeDay", GetPatientAgeDay);
	Nan::SetPrototypeMethod(tpl, "getPatientAgeDay", GetPatientAgeDay);

	Nan::SetPrototypeMethod(tpl, "GetPatientAgeMonth", GetPatientAgeMonth);
	Nan::SetPrototypeMethod(tpl, "getPatientAgeMonth", GetPatientAgeMonth);

	Nan::SetPrototypeMethod(tpl, "GetPatientAgeWeek", GetPatientAgeWeek);
	Nan::SetPrototypeMethod(tpl, "getPatientAgeWeek", GetPatientAgeWeek);

	Nan::SetPrototypeMethod(tpl, "GetPatientAgeYear", GetPatientAgeYear);
	Nan::SetPrototypeMethod(tpl, "getPatientAgeYear", GetPatientAgeYear);

	Nan::SetPrototypeMethod(tpl, "GetPatientBirthDate", GetPatientBirthDate);
	Nan::SetPrototypeMethod(tpl, "getPatientBirthDate", GetPatientBirthDate);

	Nan::SetPrototypeMethod(tpl, "GetPatientBirthDateDay", GetPatientBirthDateDay);
	Nan::SetPrototypeMethod(tpl, "getPatientBirthDateDay", GetPatientBirthDateDay);

	Nan::SetPrototypeMethod(tpl, "GetPatientBirthDateMonth", GetPatientBirthDateMonth);
	Nan::SetPrototypeMethod(tpl, "getPatientBirthDateMonth", GetPatientBirthDateMonth);

	Nan::SetPrototypeMethod(tpl, "GetPatientBirthDateYear", GetPatientBirthDateYear);
	Nan::SetPrototypeMethod(tpl, "getPatientBirthDateYear", GetPatientBirthDateYear);

	Nan::SetPrototypeMethod(tpl, "GetPatientID", GetPatientID);
	Nan::SetPrototypeMethod(tpl, "getPatientID", GetPatientID);

	Nan::SetPrototypeMethod(tpl, "GetPatientName", GetPatientName);
	Nan::SetPrototypeMethod(tpl, "getPatientName", GetPatientName);

	Nan::SetPrototypeMethod(tpl, "GetPatientSex", GetPatientSex);
	Nan::SetPrototypeMethod(tpl, "getPatientSex", GetPatientSex);

	Nan::SetPrototypeMethod(tpl, "GetRepetitionTime", GetRepetitionTime);
	Nan::SetPrototypeMethod(tpl, "getRepetitionTime", GetRepetitionTime);

	Nan::SetPrototypeMethod(tpl, "GetSeriesDescription", GetSeriesDescription);
	Nan::SetPrototypeMethod(tpl, "getSeriesDescription", GetSeriesDescription);

	Nan::SetPrototypeMethod(tpl, "GetSeriesNumber", GetSeriesNumber);
	Nan::SetPrototypeMethod(tpl, "getSeriesNumber", GetSeriesNumber);

	Nan::SetPrototypeMethod(tpl, "GetSliceThickness", GetSliceThickness);
	Nan::SetPrototypeMethod(tpl, "getSliceThickness", GetSliceThickness);

	Nan::SetPrototypeMethod(tpl, "GetSliceThicknessAsDouble", GetSliceThicknessAsDouble);
	Nan::SetPrototypeMethod(tpl, "getSliceThicknessAsDouble", GetSliceThicknessAsDouble);

	Nan::SetPrototypeMethod(tpl, "GetStationName", GetStationName);
	Nan::SetPrototypeMethod(tpl, "getStationName", GetStationName);

	Nan::SetPrototypeMethod(tpl, "GetStringFromOrientationType", GetStringFromOrientationType);
	Nan::SetPrototypeMethod(tpl, "getStringFromOrientationType", GetStringFromOrientationType);

	Nan::SetPrototypeMethod(tpl, "GetStudyDate", GetStudyDate);
	Nan::SetPrototypeMethod(tpl, "getStudyDate", GetStudyDate);

	Nan::SetPrototypeMethod(tpl, "GetStudyDescription", GetStudyDescription);
	Nan::SetPrototypeMethod(tpl, "getStudyDescription", GetStudyDescription);

	Nan::SetPrototypeMethod(tpl, "GetStudyID", GetStudyID);
	Nan::SetPrototypeMethod(tpl, "getStudyID", GetStudyID);

	Nan::SetPrototypeMethod(tpl, "GetStudyTime", GetStudyTime);
	Nan::SetPrototypeMethod(tpl, "getStudyTime", GetStudyTime);

	Nan::SetPrototypeMethod(tpl, "GetUserDefinedNameByIndex", GetUserDefinedNameByIndex);
	Nan::SetPrototypeMethod(tpl, "getUserDefinedNameByIndex", GetUserDefinedNameByIndex);

	Nan::SetPrototypeMethod(tpl, "GetUserDefinedValue", GetUserDefinedValue);
	Nan::SetPrototypeMethod(tpl, "getUserDefinedValue", GetUserDefinedValue);

	Nan::SetPrototypeMethod(tpl, "GetUserDefinedValueByIndex", GetUserDefinedValueByIndex);
	Nan::SetPrototypeMethod(tpl, "getUserDefinedValueByIndex", GetUserDefinedValueByIndex);

	Nan::SetPrototypeMethod(tpl, "GetWindowLevelPresetIndex", GetWindowLevelPresetIndex);
	Nan::SetPrototypeMethod(tpl, "getWindowLevelPresetIndex", GetWindowLevelPresetIndex);

	Nan::SetPrototypeMethod(tpl, "GetXRayTubeCurrent", GetXRayTubeCurrent);
	Nan::SetPrototypeMethod(tpl, "getXRayTubeCurrent", GetXRayTubeCurrent);

	Nan::SetPrototypeMethod(tpl, "HasWindowLevelPreset", HasWindowLevelPreset);
	Nan::SetPrototypeMethod(tpl, "hasWindowLevelPreset", HasWindowLevelPreset);

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

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

	Nan::SetPrototypeMethod(tpl, "RemoveAllUserDefinedValues", RemoveAllUserDefinedValues);
	Nan::SetPrototypeMethod(tpl, "removeAllUserDefinedValues", RemoveAllUserDefinedValues);

	Nan::SetPrototypeMethod(tpl, "RemoveAllWindowLevelPresets", RemoveAllWindowLevelPresets);
	Nan::SetPrototypeMethod(tpl, "removeAllWindowLevelPresets", RemoveAllWindowLevelPresets);

	Nan::SetPrototypeMethod(tpl, "RemoveWindowLevelPreset", RemoveWindowLevelPreset);
	Nan::SetPrototypeMethod(tpl, "removeWindowLevelPreset", RemoveWindowLevelPreset);

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

	Nan::SetPrototypeMethod(tpl, "SetAcquisitionDate", SetAcquisitionDate);
	Nan::SetPrototypeMethod(tpl, "setAcquisitionDate", SetAcquisitionDate);

	Nan::SetPrototypeMethod(tpl, "SetAcquisitionTime", SetAcquisitionTime);
	Nan::SetPrototypeMethod(tpl, "setAcquisitionTime", SetAcquisitionTime);

	Nan::SetPrototypeMethod(tpl, "SetConvolutionKernel", SetConvolutionKernel);
	Nan::SetPrototypeMethod(tpl, "setConvolutionKernel", SetConvolutionKernel);

	Nan::SetPrototypeMethod(tpl, "SetDirectionCosine", SetDirectionCosine);
	Nan::SetPrototypeMethod(tpl, "setDirectionCosine", SetDirectionCosine);

	Nan::SetPrototypeMethod(tpl, "SetEchoTime", SetEchoTime);
	Nan::SetPrototypeMethod(tpl, "setEchoTime", SetEchoTime);

	Nan::SetPrototypeMethod(tpl, "SetEchoTrainLength", SetEchoTrainLength);
	Nan::SetPrototypeMethod(tpl, "setEchoTrainLength", SetEchoTrainLength);

	Nan::SetPrototypeMethod(tpl, "SetExposure", SetExposure);
	Nan::SetPrototypeMethod(tpl, "setExposure", SetExposure);

	Nan::SetPrototypeMethod(tpl, "SetExposureTime", SetExposureTime);
	Nan::SetPrototypeMethod(tpl, "setExposureTime", SetExposureTime);

	Nan::SetPrototypeMethod(tpl, "SetGantryTilt", SetGantryTilt);
	Nan::SetPrototypeMethod(tpl, "setGantryTilt", SetGantryTilt);

	Nan::SetPrototypeMethod(tpl, "SetImageDate", SetImageDate);
	Nan::SetPrototypeMethod(tpl, "setImageDate", SetImageDate);

	Nan::SetPrototypeMethod(tpl, "SetImageNumber", SetImageNumber);
	Nan::SetPrototypeMethod(tpl, "setImageNumber", SetImageNumber);

	Nan::SetPrototypeMethod(tpl, "SetImageTime", SetImageTime);
	Nan::SetPrototypeMethod(tpl, "setImageTime", SetImageTime);

	Nan::SetPrototypeMethod(tpl, "SetInstanceUIDFromSliceID", SetInstanceUIDFromSliceID);
	Nan::SetPrototypeMethod(tpl, "setInstanceUIDFromSliceID", SetInstanceUIDFromSliceID);

	Nan::SetPrototypeMethod(tpl, "SetInstitutionName", SetInstitutionName);
	Nan::SetPrototypeMethod(tpl, "setInstitutionName", SetInstitutionName);

	Nan::SetPrototypeMethod(tpl, "SetKVP", SetKVP);
	Nan::SetPrototypeMethod(tpl, "setKVP", SetKVP);

	Nan::SetPrototypeMethod(tpl, "SetManufacturer", SetManufacturer);
	Nan::SetPrototypeMethod(tpl, "setManufacturer", SetManufacturer);

	Nan::SetPrototypeMethod(tpl, "SetManufacturerModelName", SetManufacturerModelName);
	Nan::SetPrototypeMethod(tpl, "setManufacturerModelName", SetManufacturerModelName);

	Nan::SetPrototypeMethod(tpl, "SetModality", SetModality);
	Nan::SetPrototypeMethod(tpl, "setModality", SetModality);

	Nan::SetPrototypeMethod(tpl, "SetNthWindowLevelPresetComment", SetNthWindowLevelPresetComment);
	Nan::SetPrototypeMethod(tpl, "setNthWindowLevelPresetComment", SetNthWindowLevelPresetComment);

	Nan::SetPrototypeMethod(tpl, "SetOrientationType", SetOrientationType);
	Nan::SetPrototypeMethod(tpl, "setOrientationType", SetOrientationType);

	Nan::SetPrototypeMethod(tpl, "SetPatientAge", SetPatientAge);
	Nan::SetPrototypeMethod(tpl, "setPatientAge", SetPatientAge);

	Nan::SetPrototypeMethod(tpl, "SetPatientBirthDate", SetPatientBirthDate);
	Nan::SetPrototypeMethod(tpl, "setPatientBirthDate", SetPatientBirthDate);

	Nan::SetPrototypeMethod(tpl, "SetPatientID", SetPatientID);
	Nan::SetPrototypeMethod(tpl, "setPatientID", SetPatientID);

	Nan::SetPrototypeMethod(tpl, "SetPatientName", SetPatientName);
	Nan::SetPrototypeMethod(tpl, "setPatientName", SetPatientName);

	Nan::SetPrototypeMethod(tpl, "SetPatientSex", SetPatientSex);
	Nan::SetPrototypeMethod(tpl, "setPatientSex", SetPatientSex);

	Nan::SetPrototypeMethod(tpl, "SetRepetitionTime", SetRepetitionTime);
	Nan::SetPrototypeMethod(tpl, "setRepetitionTime", SetRepetitionTime);

	Nan::SetPrototypeMethod(tpl, "SetSeriesDescription", SetSeriesDescription);
	Nan::SetPrototypeMethod(tpl, "setSeriesDescription", SetSeriesDescription);

	Nan::SetPrototypeMethod(tpl, "SetSeriesNumber", SetSeriesNumber);
	Nan::SetPrototypeMethod(tpl, "setSeriesNumber", SetSeriesNumber);

	Nan::SetPrototypeMethod(tpl, "SetSliceThickness", SetSliceThickness);
	Nan::SetPrototypeMethod(tpl, "setSliceThickness", SetSliceThickness);

	Nan::SetPrototypeMethod(tpl, "SetStationName", SetStationName);
	Nan::SetPrototypeMethod(tpl, "setStationName", SetStationName);

	Nan::SetPrototypeMethod(tpl, "SetStudyDate", SetStudyDate);
	Nan::SetPrototypeMethod(tpl, "setStudyDate", SetStudyDate);

	Nan::SetPrototypeMethod(tpl, "SetStudyDescription", SetStudyDescription);
	Nan::SetPrototypeMethod(tpl, "setStudyDescription", SetStudyDescription);

	Nan::SetPrototypeMethod(tpl, "SetStudyID", SetStudyID);
	Nan::SetPrototypeMethod(tpl, "setStudyID", SetStudyID);

	Nan::SetPrototypeMethod(tpl, "SetStudyTime", SetStudyTime);
	Nan::SetPrototypeMethod(tpl, "setStudyTime", SetStudyTime);

	Nan::SetPrototypeMethod(tpl, "SetXRayTubeCurrent", SetXRayTubeCurrent);
	Nan::SetPrototypeMethod(tpl, "setXRayTubeCurrent", SetXRayTubeCurrent);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkMedicalImagePropertiesWrap::GetNthWindowLevelPreset(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkMedicalImagePropertiesWrap *wrapper = ObjectWrap::Unwrap<VtkMedicalImagePropertiesWrap>(info.Holder());
	vtkMedicalImageProperties *native = (vtkMedicalImageProperties *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		double const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetNthWindowLevelPreset(
			info[0]->Int32Value()
		);
		Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 2 * sizeof(double));
		Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 2);
		memcpy(ab->GetContents().Data(), r, 2 * sizeof(double));
		info.GetReturnValue().Set(at);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkMedicalImagePropertiesWrap::GetStringFromOrientationType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkMedicalImagePropertiesWrap *wrapper = ObjectWrap::Unwrap<VtkMedicalImagePropertiesWrap>(info.Holder());
	vtkMedicalImageProperties *native = (vtkMedicalImageProperties *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsUint32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetStringFromOrientationType(
			info[0]->Uint32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

void VtkMedicalImagePropertiesWrap::GetUserDefinedNameByIndex(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkMedicalImagePropertiesWrap *wrapper = ObjectWrap::Unwrap<VtkMedicalImagePropertiesWrap>(info.Holder());
	vtkMedicalImageProperties *native = (vtkMedicalImageProperties *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsUint32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetUserDefinedNameByIndex(
			info[0]->Uint32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

void VtkMedicalImagePropertiesWrap::GetUserDefinedValueByIndex(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkMedicalImagePropertiesWrap *wrapper = ObjectWrap::Unwrap<VtkMedicalImagePropertiesWrap>(info.Holder());
	vtkMedicalImageProperties *native = (vtkMedicalImageProperties *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsUint32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetUserDefinedValueByIndex(
			info[0]->Uint32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkMedicalImagePropertiesWrap::SetInstanceUIDFromSliceID(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkMedicalImagePropertiesWrap *wrapper = ObjectWrap::Unwrap<VtkMedicalImagePropertiesWrap>(info.Holder());
	vtkMedicalImageProperties *native = (vtkMedicalImageProperties *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			if(info.Length() > 2 && info[2]->IsString())
			{
				Nan::Utf8String a2(info[2]);
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetInstanceUIDFromSliceID(
					info[0]->Int32Value(),
					info[1]->Int32Value(),
					*a2
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

void VtkMedicalImagePropertiesWrap::SetNthWindowLevelPresetComment(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkMedicalImagePropertiesWrap *wrapper = ObjectWrap::Unwrap<VtkMedicalImagePropertiesWrap>(info.Holder());
	vtkMedicalImageProperties *native = (vtkMedicalImageProperties *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsString())
		{
			Nan::Utf8String a1(info[1]);
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetNthWindowLevelPresetComment(
				info[0]->Int32Value(),
				*a1
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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