php5-vtkgdcm 2.4.4-3+deb8u1 / usr / share / php / vtkgdcm.php

<?php

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 2.0.12
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */

// Try to load our extension if it's not already loaded.
if (!extension_loaded('vtkgdcm')) {
  if (strtolower(substr(PHP_OS, 0, 3)) === 'win') {
    if (!dl('php_vtkgdcm.dll')) return;
  } else {
    // PHP_SHLIB_SUFFIX gives 'dylib' on MacOS X but modules are 'so'.
    if (PHP_SHLIB_SUFFIX === 'dylib') {
      if (!dl('vtkgdcm.so')) return;
    } else {
      if (!dl('vtkgdcm.'.PHP_SHLIB_SUFFIX)) return;
    }
  }
}



abstract class vtkgdcm {
	const VTK_LUMINANCE = VTK_LUMINANCE;

	const VTK_LUMINANCE_ALPHA = VTK_LUMINANCE_ALPHA;

	const VTK_RGB = VTK_RGB;

	const VTK_RGBA = VTK_RGBA;

	const VTK_PIECES_EXTENT = VTK_PIECES_EXTENT;

	const VTK_3D_EXTENT = VTK_3D_EXTENT;

	const VTK_TIME_EXTENT = VTK_TIME_EXTENT;

	const VTK_FILE_BYTE_ORDER_BIG_ENDIAN = VTK_FILE_BYTE_ORDER_BIG_ENDIAN;

	const VTK_FILE_BYTE_ORDER_LITTLE_ENDIAN = VTK_FILE_BYTE_ORDER_LITTLE_ENDIAN;

	const VTK_INVERSE_LUMINANCE = VTK_INVERSE_LUMINANCE;

	const VTK_LOOKUP_TABLE = VTK_LOOKUP_TABLE;

	const VTK_YBR = VTK_YBR;

	const VTK_CMYK = VTK_CMYK;

	const VTK_ZBUFFER = VTK_ZBUFFER;
}

/* PHP Proxy Classes */
class vtkObjectBase {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	function GetClassName() {
		return vtkObjectBase_GetClassName($this->_cPtr);
	}

	static function IsTypeOf($name) {
		return vtkObjectBase_IsTypeOf($name);
	}

	function IsA($name) {
		return vtkObjectBase_IsA($this->_cPtr,$name);
	}

	function Delete() {
		vtkObjectBase_Delete($this->_cPtr);
	}

	static function c_New() {
		$r=vtkObjectBase_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkObjectBase($r);
		}
		return $r;
	}

	function Register($o) {
		vtkObjectBase_Register($this->_cPtr,$o);
	}

	function UnRegister($o) {
		vtkObjectBase_UnRegister($this->_cPtr,$o);
	}

	function GetReferenceCount() {
		return vtkObjectBase_GetReferenceCount($this->_cPtr);
	}

	function SetReferenceCount($arg1) {
		vtkObjectBase_SetReferenceCount($this->_cPtr,$arg1);
	}

	function ToString() {
		return vtkObjectBase_ToString($this->_cPtr);
	}
}

class vtkObject extends vtkObjectBase {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkObjectBase::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkObjectBase::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkObjectBase::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkObject_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkObject($r);
		}
		return $r;
	}

	function DebugOn() {
		vtkObject_DebugOn($this->_cPtr);
	}

	function DebugOff() {
		vtkObject_DebugOff($this->_cPtr);
	}

	function GetDebug() {
		return vtkObject_GetDebug($this->_cPtr);
	}

	function SetDebug($debugFlag) {
		vtkObject_SetDebug($this->_cPtr,$debugFlag);
	}

	static function BreakOnError() {
		vtkObject_BreakOnError();
	}

	function Modified() {
		vtkObject_Modified($this->_cPtr);
	}

	function GetMTime() {
		return vtkObject_GetMTime($this->_cPtr);
	}

	static function SetGlobalWarningDisplay($val) {
		vtkObject_SetGlobalWarningDisplay($val);
	}

	static function GlobalWarningDisplayOn() {
		vtkObject_GlobalWarningDisplayOn();
	}

	static function GlobalWarningDisplayOff() {
		vtkObject_GlobalWarningDisplayOff();
	}

	static function GetGlobalWarningDisplay() {
		return vtkObject_GetGlobalWarningDisplay();
	}

	function AddObserver($event,$arg2,$priority=0.0) {
		$r=vtkObject_AddObserver($this->_cPtr,$event,$arg2,$priority);
		return $r;
	}

	function GetCommand($tag) {
		return vtkObject_GetCommand($this->_cPtr,$tag);
	}

	function RemoveObserver($tag) {
		vtkObject_RemoveObserver($this->_cPtr,$tag);
	}

	function RemoveObservers($event,$arg2=null) {
		switch (func_num_args()) {
		case 1: vtkObject_RemoveObservers($this->_cPtr,$event); break;
		default: vtkObject_RemoveObservers($this->_cPtr,$event,$arg2);
		}
	}

	function RemoveAllObservers() {
		vtkObject_RemoveAllObservers($this->_cPtr);
	}

	function HasObserver($event,$arg2=null) {
		switch (func_num_args()) {
		case 1: $r=vtkObject_HasObserver($this->_cPtr,$event); break;
		default: $r=vtkObject_HasObserver($this->_cPtr,$event,$arg2);
		}
		return $r;
	}

	function InvokeEvent($event,$callData=null) {
		switch (func_num_args()) {
		case 1: $r=vtkObject_InvokeEvent($this->_cPtr,$event); break;
		default: $r=vtkObject_InvokeEvent($this->_cPtr,$event,$callData);
		}
		return $r;
	}
}

class vtkGDCMTesting extends vtkObject {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkObject::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkObject::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkObject::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkGDCMTesting_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkGDCMTesting($r);
		}
		return $r;
	}

	static function GetVTKDataRoot() {
		return vtkGDCMTesting_GetVTKDataRoot();
	}

	static function GetGDCMDataRoot() {
		return vtkGDCMTesting_GetGDCMDataRoot();
	}

	static function GetMD5MetaImage($file) {
		return vtkGDCMTesting_GetMD5MetaImage($file);
	}

	static function GetNumberOfMD5MetaImages() {
		return vtkGDCMTesting_GetNumberOfMD5MetaImages();
	}

	static function GetMHDMD5FromFile($filepath) {
		return vtkGDCMTesting_GetMHDMD5FromFile($filepath);
	}

	static function GetRAWMD5FromFile($filepath) {
		return vtkGDCMTesting_GetRAWMD5FromFile($filepath);
	}
}

class vtkStringArray {
	public $_cPtr=null;
	protected $_pData=array();

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		$this->_pData[$var] = $value;
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return array_key_exists($var, $this->_pData);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return $this->_pData[$var];
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkStringArray_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkStringArray($r);
		}
		return $r;
	}

	function PrintSelf($os,$indent) {
		vtkStringArray_PrintSelf($this->_cPtr,$os,$indent);
	}

	function GetDataType() {
		return vtkStringArray_GetDataType($this->_cPtr);
	}

	function IsNumeric() {
		return vtkStringArray_IsNumeric($this->_cPtr);
	}

	function Initialize() {
		vtkStringArray_Initialize($this->_cPtr);
	}

	function GetDataTypeSize() {
		return vtkStringArray_GetDataTypeSize($this->_cPtr);
	}

	function Squeeze() {
		vtkStringArray_Squeeze($this->_cPtr);
	}

	function Resize($numTuples) {
		return vtkStringArray_Resize($this->_cPtr,$numTuples);
	}

	function SetTuple($i,$j,$source) {
		vtkStringArray_SetTuple($this->_cPtr,$i,$j,$source);
	}

	function InsertTuple($i,$j,$source) {
		vtkStringArray_InsertTuple($this->_cPtr,$i,$j,$source);
	}

	function InsertNextTuple($j,$source) {
		return vtkStringArray_InsertNextTuple($this->_cPtr,$j,$source);
	}

	function InterpolateTuple($i,$ptIndices_or_id1,$source_or_source1,$weights_or_id2,$source2=null,$t=null) {
		switch (func_num_args()) {
		case 4: vtkStringArray_InterpolateTuple($this->_cPtr,$i,$ptIndices_or_id1,$source_or_source1,$weights_or_id2); break;
		case 5: vtkStringArray_InterpolateTuple($this->_cPtr,$i,$ptIndices_or_id1,$source_or_source1,$weights_or_id2,$source2); break;
		default: vtkStringArray_InterpolateTuple($this->_cPtr,$i,$ptIndices_or_id1,$source_or_source1,$weights_or_id2,$source2,$t);
		}
	}

	function GetTuples($ptIds_or_p1,$output_or_p2,$output=null) {
		switch (func_num_args()) {
		case 2: vtkStringArray_GetTuples($this->_cPtr,$ptIds_or_p1,$output_or_p2); break;
		default: vtkStringArray_GetTuples($this->_cPtr,$ptIds_or_p1,$output_or_p2,$output);
		}
	}

	function Allocate($sz,$ext=null) {
		switch (func_num_args()) {
		case 1: $r=vtkStringArray_Allocate($this->_cPtr,$sz); break;
		default: $r=vtkStringArray_Allocate($this->_cPtr,$sz,$ext);
		}
		return $r;
	}

	function GetValue($id) {
		return vtkStringArray_GetValue($this->_cPtr,$id);
	}

	function SetValue($id,$value) {
		vtkStringArray_SetValue($this->_cPtr,$id,$value);
	}

	function SetNumberOfTuples($number) {
		vtkStringArray_SetNumberOfTuples($this->_cPtr,$number);
	}

	function SetNumberOfValues($number) {
		vtkStringArray_SetNumberOfValues($this->_cPtr,$number);
	}

	function GetNumberOfValues() {
		return vtkStringArray_GetNumberOfValues($this->_cPtr);
	}

	function GetNumberOfElementComponents() {
		return vtkStringArray_GetNumberOfElementComponents($this->_cPtr);
	}

	function GetElementComponentSize() {
		return vtkStringArray_GetElementComponentSize($this->_cPtr);
	}

	function InsertValue($id,$f_or_val) {
		vtkStringArray_InsertValue($this->_cPtr,$id,$f_or_val);
	}

	function SetVariantValue($idx,$value) {
		vtkStringArray_SetVariantValue($this->_cPtr,$idx,$value);
	}

	function InsertNextValue($f) {
		return vtkStringArray_InsertNextValue($this->_cPtr,$f);
	}

	function WritePointer($id,$number) {
		return vtkStringArray_WritePointer($this->_cPtr,$id,$number);
	}

	function GetPointer($id) {
		return vtkStringArray_GetPointer($this->_cPtr,$id);
	}

	function GetVoidPointer($id) {
		return vtkStringArray_GetVoidPointer($this->_cPtr,$id);
	}

	function DeepCopy($aa) {
		vtkStringArray_DeepCopy($this->_cPtr,$aa);
	}

	function SetArray($array,$size,$save) {
		vtkStringArray_SetArray($this->_cPtr,$array,$size,$save);
	}

	function SetVoidArray($array,$size,$save) {
		vtkStringArray_SetVoidArray($this->_cPtr,$array,$size,$save);
	}

	function GetActualMemorySize() {
		return vtkStringArray_GetActualMemorySize($this->_cPtr);
	}

	function NewIterator() {
		return vtkStringArray_NewIterator($this->_cPtr);
	}

	function GetDataSize() {
		return vtkStringArray_GetDataSize($this->_cPtr);
	}

	function LookupValue($value,$ids=null) {
		switch (func_num_args()) {
		case 1: $r=vtkStringArray_LookupValue($this->_cPtr,$value); break;
		default: $r=vtkStringArray_LookupValue($this->_cPtr,$value,$ids);
		}
		return $r;
	}

	function DataChanged() {
		vtkStringArray_DataChanged($this->_cPtr);
	}

	function DataElementChanged($id) {
		vtkStringArray_DataElementChanged($this->_cPtr,$id);
	}

	function ClearLookup() {
		vtkStringArray_ClearLookup($this->_cPtr);
	}
}

class vtkMatrix4x4 extends vtkObject {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'Element') return vtkMatrix4x4_Element_set($this->_cPtr,$value);
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkObject::__set($var,$value);
	}

	function __isset($var) {
		if (function_exists('vtkMatrix4x4_'.$var.'_set')) return true;
		if ($var === 'thisown') return true;
		return vtkObject::__isset($var);
	}

	function __get($var) {
		if ($var === 'Element') return vtkMatrix4x4_Element_get($this->_cPtr);
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkObject::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkMatrix4x4_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkMatrix4x4($r);
		}
		return $r;
	}

	function DeepCopy($source_or_newElements_or_Elements) {
		vtkMatrix4x4_DeepCopy($this->_cPtr,$source_or_newElements_or_Elements);
	}

	static function Zero($self_or_Elements) {
		vtkMatrix4x4_Zero($self_or_Elements);
	}

	static function Identity($self_or_Elements) {
		vtkMatrix4x4_Identity($self_or_Elements);
	}

	function MultiplyPoint($in,$out=null) {
		switch (func_num_args()) {
		case 1: $r=vtkMatrix4x4_MultiplyPoint($this->_cPtr,$in); break;
		default: $r=vtkMatrix4x4_MultiplyPoint($this->_cPtr,$in,$out);
		}
		return $r;
	}

	function MultiplyFloatPoint($in) {
		return vtkMatrix4x4_MultiplyFloatPoint($this->_cPtr,$in);
	}

	function MultiplyDoublePoint($in) {
		return vtkMatrix4x4_MultiplyDoublePoint($this->_cPtr,$in);
	}

	static function Multiply4x4($a,$b,$c_) {
		vtkMatrix4x4_Multiply4x4($a,$b,$c_);
	}

	function SetElement($i,$j,$value) {
		vtkMatrix4x4_SetElement($this->_cPtr,$i,$j,$value);
	}

	function GetElement($i,$j) {
		return vtkMatrix4x4_GetElement($this->_cPtr,$i,$j);
	}

	function Adjoint($in_or_outElements,$out=null) {
		switch (func_num_args()) {
		case 1: vtkMatrix4x4_Adjoint($this->_cPtr,$in_or_outElements); break;
		default: vtkMatrix4x4_Adjoint($this->_cPtr,$in_or_outElements,$out);
		}
	}

	function Determinant($in=null) {
		switch (func_num_args()) {
		case 0: $r=vtkMatrix4x4_Determinant($this->_cPtr); break;
		default: $r=vtkMatrix4x4_Determinant($this->_cPtr,$in);
		}
		return $r;
	}

	function Invert($outElements_or_in=null,$out=null) {
		switch (func_num_args()) {
		case 0: vtkMatrix4x4_Invert($this->_cPtr); break;
		case 1: vtkMatrix4x4_Invert($this->_cPtr,$outElements_or_in); break;
		default: vtkMatrix4x4_Invert($this->_cPtr,$outElements_or_in,$out);
		}
	}

	function Transpose($outElements_or_in=null,$out=null) {
		switch (func_num_args()) {
		case 0: vtkMatrix4x4_Transpose($this->_cPtr); break;
		case 1: vtkMatrix4x4_Transpose($this->_cPtr,$outElements_or_in); break;
		default: vtkMatrix4x4_Transpose($this->_cPtr,$outElements_or_in,$out);
		}
	}

	static function PointMultiply($Elements,$in,$out) {
		vtkMatrix4x4_PointMultiply($Elements,$in,$out);
	}
}

class vtkMedicalImageProperties extends vtkObject {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkObject::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkObject::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkObject::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkMedicalImageProperties_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkMedicalImageProperties($r);
		}
		return $r;
	}

	function Clear() {
		vtkMedicalImageProperties_Clear($this->_cPtr);
	}

	function SetPatientName($_arg) {
		vtkMedicalImageProperties_SetPatientName($this->_cPtr,$_arg);
	}

	function GetPatientName() {
		return vtkMedicalImageProperties_GetPatientName($this->_cPtr);
	}

	function SetPatientID($_arg) {
		vtkMedicalImageProperties_SetPatientID($this->_cPtr,$_arg);
	}

	function GetPatientID() {
		return vtkMedicalImageProperties_GetPatientID($this->_cPtr);
	}

	function SetPatientAge($_arg) {
		vtkMedicalImageProperties_SetPatientAge($this->_cPtr,$_arg);
	}

	function GetPatientAge() {
		return vtkMedicalImageProperties_GetPatientAge($this->_cPtr);
	}

	static function GetAgeAsFields($age,$year,$month,$week,$day) {
		return vtkMedicalImageProperties_GetAgeAsFields($age,$year,$month,$week,$day);
	}

	function GetPatientAgeYear() {
		return vtkMedicalImageProperties_GetPatientAgeYear($this->_cPtr);
	}

	function GetPatientAgeMonth() {
		return vtkMedicalImageProperties_GetPatientAgeMonth($this->_cPtr);
	}

	function GetPatientAgeWeek() {
		return vtkMedicalImageProperties_GetPatientAgeWeek($this->_cPtr);
	}

	function GetPatientAgeDay() {
		return vtkMedicalImageProperties_GetPatientAgeDay($this->_cPtr);
	}

	function SetPatientSex($_arg) {
		vtkMedicalImageProperties_SetPatientSex($this->_cPtr,$_arg);
	}

	function GetPatientSex() {
		return vtkMedicalImageProperties_GetPatientSex($this->_cPtr);
	}

	function SetPatientBirthDate($_arg) {
		vtkMedicalImageProperties_SetPatientBirthDate($this->_cPtr,$_arg);
	}

	function GetPatientBirthDate() {
		return vtkMedicalImageProperties_GetPatientBirthDate($this->_cPtr);
	}

	function GetPatientBirthDateYear() {
		return vtkMedicalImageProperties_GetPatientBirthDateYear($this->_cPtr);
	}

	function GetPatientBirthDateMonth() {
		return vtkMedicalImageProperties_GetPatientBirthDateMonth($this->_cPtr);
	}

	function GetPatientBirthDateDay() {
		return vtkMedicalImageProperties_GetPatientBirthDateDay($this->_cPtr);
	}

	function SetStudyDate($_arg) {
		vtkMedicalImageProperties_SetStudyDate($this->_cPtr,$_arg);
	}

	function GetStudyDate() {
		return vtkMedicalImageProperties_GetStudyDate($this->_cPtr);
	}

	function SetAcquisitionDate($_arg) {
		vtkMedicalImageProperties_SetAcquisitionDate($this->_cPtr,$_arg);
	}

	function GetAcquisitionDate() {
		return vtkMedicalImageProperties_GetAcquisitionDate($this->_cPtr);
	}

	function GetAcquisitionDateYear() {
		return vtkMedicalImageProperties_GetAcquisitionDateYear($this->_cPtr);
	}

	function GetAcquisitionDateMonth() {
		return vtkMedicalImageProperties_GetAcquisitionDateMonth($this->_cPtr);
	}

	function GetAcquisitionDateDay() {
		return vtkMedicalImageProperties_GetAcquisitionDateDay($this->_cPtr);
	}

	function SetStudyTime($_arg) {
		vtkMedicalImageProperties_SetStudyTime($this->_cPtr,$_arg);
	}

	function GetStudyTime() {
		return vtkMedicalImageProperties_GetStudyTime($this->_cPtr);
	}

	function SetAcquisitionTime($_arg) {
		vtkMedicalImageProperties_SetAcquisitionTime($this->_cPtr,$_arg);
	}

	function GetAcquisitionTime() {
		return vtkMedicalImageProperties_GetAcquisitionTime($this->_cPtr);
	}

	function SetImageDate($_arg) {
		vtkMedicalImageProperties_SetImageDate($this->_cPtr,$_arg);
	}

	function GetImageDate() {
		return vtkMedicalImageProperties_GetImageDate($this->_cPtr);
	}

	function GetImageDateYear() {
		return vtkMedicalImageProperties_GetImageDateYear($this->_cPtr);
	}

	function GetImageDateMonth() {
		return vtkMedicalImageProperties_GetImageDateMonth($this->_cPtr);
	}

	function GetImageDateDay() {
		return vtkMedicalImageProperties_GetImageDateDay($this->_cPtr);
	}

	static function GetDateAsFields($date,$year,$month,$day) {
		return vtkMedicalImageProperties_GetDateAsFields($date,$year,$month,$day);
	}

	static function GetTimeAsFields($time,$hour,$minute,$second) {
		return vtkMedicalImageProperties_GetTimeAsFields($time,$hour,$minute,$second);
	}

	static function GetDateAsLocale($date,$locale) {
		return vtkMedicalImageProperties_GetDateAsLocale($date,$locale);
	}

	function SetImageTime($_arg) {
		vtkMedicalImageProperties_SetImageTime($this->_cPtr,$_arg);
	}

	function GetImageTime() {
		return vtkMedicalImageProperties_GetImageTime($this->_cPtr);
	}

	function SetImageNumber($_arg) {
		vtkMedicalImageProperties_SetImageNumber($this->_cPtr,$_arg);
	}

	function GetImageNumber() {
		return vtkMedicalImageProperties_GetImageNumber($this->_cPtr);
	}

	function SetSeriesNumber($_arg) {
		vtkMedicalImageProperties_SetSeriesNumber($this->_cPtr,$_arg);
	}

	function GetSeriesNumber() {
		return vtkMedicalImageProperties_GetSeriesNumber($this->_cPtr);
	}

	function SetSeriesDescription($_arg) {
		vtkMedicalImageProperties_SetSeriesDescription($this->_cPtr,$_arg);
	}

	function GetSeriesDescription() {
		return vtkMedicalImageProperties_GetSeriesDescription($this->_cPtr);
	}

	function SetStudyID($_arg) {
		vtkMedicalImageProperties_SetStudyID($this->_cPtr,$_arg);
	}

	function GetStudyID() {
		return vtkMedicalImageProperties_GetStudyID($this->_cPtr);
	}

	function SetStudyDescription($_arg) {
		vtkMedicalImageProperties_SetStudyDescription($this->_cPtr,$_arg);
	}

	function GetStudyDescription() {
		return vtkMedicalImageProperties_GetStudyDescription($this->_cPtr);
	}

	function SetModality($_arg) {
		vtkMedicalImageProperties_SetModality($this->_cPtr,$_arg);
	}

	function GetModality() {
		return vtkMedicalImageProperties_GetModality($this->_cPtr);
	}

	function SetManufacturer($_arg) {
		vtkMedicalImageProperties_SetManufacturer($this->_cPtr,$_arg);
	}

	function GetManufacturer() {
		return vtkMedicalImageProperties_GetManufacturer($this->_cPtr);
	}

	function SetManufacturerModelName($_arg) {
		vtkMedicalImageProperties_SetManufacturerModelName($this->_cPtr,$_arg);
	}

	function GetManufacturerModelName() {
		return vtkMedicalImageProperties_GetManufacturerModelName($this->_cPtr);
	}

	function SetStationName($_arg) {
		vtkMedicalImageProperties_SetStationName($this->_cPtr,$_arg);
	}

	function GetStationName() {
		return vtkMedicalImageProperties_GetStationName($this->_cPtr);
	}

	function SetInstitutionName($_arg) {
		vtkMedicalImageProperties_SetInstitutionName($this->_cPtr,$_arg);
	}

	function GetInstitutionName() {
		return vtkMedicalImageProperties_GetInstitutionName($this->_cPtr);
	}

	function SetConvolutionKernel($_arg) {
		vtkMedicalImageProperties_SetConvolutionKernel($this->_cPtr,$_arg);
	}

	function GetConvolutionKernel() {
		return vtkMedicalImageProperties_GetConvolutionKernel($this->_cPtr);
	}

	function SetSliceThickness($_arg) {
		vtkMedicalImageProperties_SetSliceThickness($this->_cPtr,$_arg);
	}

	function GetSliceThickness() {
		return vtkMedicalImageProperties_GetSliceThickness($this->_cPtr);
	}

	function GetSliceThicknessAsDouble() {
		return vtkMedicalImageProperties_GetSliceThicknessAsDouble($this->_cPtr);
	}

	function SetKVP($_arg) {
		vtkMedicalImageProperties_SetKVP($this->_cPtr,$_arg);
	}

	function GetKVP() {
		return vtkMedicalImageProperties_GetKVP($this->_cPtr);
	}

	function SetGantryTilt($_arg) {
		vtkMedicalImageProperties_SetGantryTilt($this->_cPtr,$_arg);
	}

	function GetGantryTilt() {
		return vtkMedicalImageProperties_GetGantryTilt($this->_cPtr);
	}

	function GetGantryTiltAsDouble() {
		return vtkMedicalImageProperties_GetGantryTiltAsDouble($this->_cPtr);
	}

	function SetEchoTime($_arg) {
		vtkMedicalImageProperties_SetEchoTime($this->_cPtr,$_arg);
	}

	function GetEchoTime() {
		return vtkMedicalImageProperties_GetEchoTime($this->_cPtr);
	}

	function SetEchoTrainLength($_arg) {
		vtkMedicalImageProperties_SetEchoTrainLength($this->_cPtr,$_arg);
	}

	function GetEchoTrainLength() {
		return vtkMedicalImageProperties_GetEchoTrainLength($this->_cPtr);
	}

	function SetRepetitionTime($_arg) {
		vtkMedicalImageProperties_SetRepetitionTime($this->_cPtr,$_arg);
	}

	function GetRepetitionTime() {
		return vtkMedicalImageProperties_GetRepetitionTime($this->_cPtr);
	}

	function SetExposureTime($_arg) {
		vtkMedicalImageProperties_SetExposureTime($this->_cPtr,$_arg);
	}

	function GetExposureTime() {
		return vtkMedicalImageProperties_GetExposureTime($this->_cPtr);
	}

	function SetXRayTubeCurrent($_arg) {
		vtkMedicalImageProperties_SetXRayTubeCurrent($this->_cPtr,$_arg);
	}

	function GetXRayTubeCurrent() {
		return vtkMedicalImageProperties_GetXRayTubeCurrent($this->_cPtr);
	}

	function SetExposure($_arg) {
		vtkMedicalImageProperties_SetExposure($this->_cPtr,$_arg);
	}

	function GetExposure() {
		return vtkMedicalImageProperties_GetExposure($this->_cPtr);
	}

	function GetDirectionCosine() {
		return vtkMedicalImageProperties_GetDirectionCosine($this->_cPtr);
	}

	function AddUserDefinedValue($name,$value) {
		vtkMedicalImageProperties_AddUserDefinedValue($this->_cPtr,$name,$value);
	}

	function GetUserDefinedValue($name) {
		return vtkMedicalImageProperties_GetUserDefinedValue($this->_cPtr,$name);
	}

	function GetNumberOfUserDefinedValues() {
		return vtkMedicalImageProperties_GetNumberOfUserDefinedValues($this->_cPtr);
	}

	function GetUserDefinedNameByIndex($idx) {
		return vtkMedicalImageProperties_GetUserDefinedNameByIndex($this->_cPtr,$idx);
	}

	function GetUserDefinedValueByIndex($idx) {
		return vtkMedicalImageProperties_GetUserDefinedValueByIndex($this->_cPtr,$idx);
	}

	function RemoveAllUserDefinedValues() {
		vtkMedicalImageProperties_RemoveAllUserDefinedValues($this->_cPtr);
	}

	function AddWindowLevelPreset($w,$l) {
		return vtkMedicalImageProperties_AddWindowLevelPreset($this->_cPtr,$w,$l);
	}

	function RemoveWindowLevelPreset($w,$l) {
		vtkMedicalImageProperties_RemoveWindowLevelPreset($this->_cPtr,$w,$l);
	}

	function RemoveAllWindowLevelPresets() {
		vtkMedicalImageProperties_RemoveAllWindowLevelPresets($this->_cPtr);
	}

	function GetNumberOfWindowLevelPresets() {
		return vtkMedicalImageProperties_GetNumberOfWindowLevelPresets($this->_cPtr);
	}

	function HasWindowLevelPreset($w,$l) {
		return vtkMedicalImageProperties_HasWindowLevelPreset($this->_cPtr,$w,$l);
	}

	function GetWindowLevelPresetIndex($w,$l) {
		return vtkMedicalImageProperties_GetWindowLevelPresetIndex($this->_cPtr,$w,$l);
	}

	function GetNthWindowLevelPreset($idx,$w=null,$l=null) {
		switch (func_num_args()) {
		case 1: $r=vtkMedicalImageProperties_GetNthWindowLevelPreset($this->_cPtr,$idx); break;
		case 2: $r=vtkMedicalImageProperties_GetNthWindowLevelPreset($this->_cPtr,$idx,$w); break;
		default: $r=vtkMedicalImageProperties_GetNthWindowLevelPreset($this->_cPtr,$idx,$w,$l);
		}
		return $r;
	}

	function SetNthWindowLevelPresetComment($idx,$comment) {
		vtkMedicalImageProperties_SetNthWindowLevelPresetComment($this->_cPtr,$idx,$comment);
	}

	function GetNthWindowLevelPresetComment($idx) {
		return vtkMedicalImageProperties_GetNthWindowLevelPresetComment($this->_cPtr,$idx);
	}

	function GetInstanceUIDFromSliceID($volumeidx,$sliceid) {
		return vtkMedicalImageProperties_GetInstanceUIDFromSliceID($this->_cPtr,$volumeidx,$sliceid);
	}

	function SetInstanceUIDFromSliceID($volumeidx,$sliceid,$uid) {
		vtkMedicalImageProperties_SetInstanceUIDFromSliceID($this->_cPtr,$volumeidx,$sliceid,$uid);
	}

	function GetSliceIDFromInstanceUID($volumeidx,$uid) {
		return vtkMedicalImageProperties_GetSliceIDFromInstanceUID($this->_cPtr,$volumeidx,$uid);
	}

	const AXIAL = 0;

	const CORONAL = vtkMedicalImageProperties_CORONAL;

	const SAGITTAL = vtkMedicalImageProperties_SAGITTAL;

	function GetOrientationType($volumeidx) {
		return vtkMedicalImageProperties_GetOrientationType($this->_cPtr,$volumeidx);
	}

	function SetOrientationType($volumeidx,$orientation) {
		vtkMedicalImageProperties_SetOrientationType($this->_cPtr,$volumeidx,$orientation);
	}

	static function GetStringFromOrientationType($type) {
		return vtkMedicalImageProperties_GetStringFromOrientationType($type);
	}

	function DeepCopy($p) {
		vtkMedicalImageProperties_DeepCopy($this->_cPtr,$p);
	}
}

class vtkDataObject extends vtkObject {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkObject::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkObject::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkObject::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkDataObject_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkDataObject($r);
		}
		return $r;
	}

	function GetSource() {
		return vtkDataObject_GetSource($this->_cPtr);
	}

	function SetSource($s) {
		vtkDataObject_SetSource($this->_cPtr,$s);
	}

	function GetInformation() {
		return vtkDataObject_GetInformation($this->_cPtr);
	}

	function SetInformation($arg1) {
		vtkDataObject_SetInformation($this->_cPtr,$arg1);
	}

	function GetPipelineInformation() {
		return vtkDataObject_GetPipelineInformation($this->_cPtr);
	}

	function SetPipelineInformation($arg1) {
		vtkDataObject_SetPipelineInformation($this->_cPtr,$arg1);
	}

	function GetProducerPort() {
		return vtkDataObject_GetProducerPort($this->_cPtr);
	}

	function GetMTime() {
		return vtkDataObject_GetMTime($this->_cPtr);
	}

	function Initialize() {
		vtkDataObject_Initialize($this->_cPtr);
	}

	function ReleaseData() {
		vtkDataObject_ReleaseData($this->_cPtr);
	}

	function ShouldIReleaseData() {
		return vtkDataObject_ShouldIReleaseData($this->_cPtr);
	}

	function GetDataReleased() {
		return vtkDataObject_GetDataReleased($this->_cPtr);
	}

	function SetReleaseDataFlag($arg1) {
		vtkDataObject_SetReleaseDataFlag($this->_cPtr,$arg1);
	}

	function GetReleaseDataFlag() {
		return vtkDataObject_GetReleaseDataFlag($this->_cPtr);
	}

	function ReleaseDataFlagOn() {
		vtkDataObject_ReleaseDataFlagOn($this->_cPtr);
	}

	function ReleaseDataFlagOff() {
		vtkDataObject_ReleaseDataFlagOff($this->_cPtr);
	}

	static function SetGlobalReleaseDataFlag($val) {
		vtkDataObject_SetGlobalReleaseDataFlag($val);
	}

	function GlobalReleaseDataFlagOn() {
		vtkDataObject_GlobalReleaseDataFlagOn($this->_cPtr);
	}

	function GlobalReleaseDataFlagOff() {
		vtkDataObject_GlobalReleaseDataFlagOff($this->_cPtr);
	}

	static function GetGlobalReleaseDataFlag() {
		return vtkDataObject_GetGlobalReleaseDataFlag();
	}

	function SetFieldData($arg1) {
		vtkDataObject_SetFieldData($this->_cPtr,$arg1);
	}

	function GetFieldData() {
		return vtkDataObject_GetFieldData($this->_cPtr);
	}

	function Register($o) {
		vtkDataObject_Register($this->_cPtr,$o);
	}

	function UnRegister($o) {
		vtkDataObject_UnRegister($this->_cPtr,$o);
	}

	function Update() {
		vtkDataObject_Update($this->_cPtr);
	}

	function UpdateInformation() {
		vtkDataObject_UpdateInformation($this->_cPtr);
	}

	function PropagateUpdateExtent() {
		vtkDataObject_PropagateUpdateExtent($this->_cPtr);
	}

	function TriggerAsynchronousUpdate() {
		vtkDataObject_TriggerAsynchronousUpdate($this->_cPtr);
	}

	function UpdateData() {
		vtkDataObject_UpdateData($this->_cPtr);
	}

	function GetEstimatedMemorySize() {
		return vtkDataObject_GetEstimatedMemorySize($this->_cPtr);
	}

	function SetUpdateExtent($piece_or_x0_or_extent,$numPieces_or_x1=null,$ghostLevel_or_y0=null,$y1=null,$z0=null,$z1=null) {
		switch (func_num_args()) {
		case 1: vtkDataObject_SetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent); break;
		case 2: vtkDataObject_SetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent,$numPieces_or_x1); break;
		case 3: vtkDataObject_SetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent,$numPieces_or_x1,$ghostLevel_or_y0); break;
		case 4: vtkDataObject_SetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent,$numPieces_or_x1,$ghostLevel_or_y0,$y1); break;
		case 5: vtkDataObject_SetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent,$numPieces_or_x1,$ghostLevel_or_y0,$y1,$z0); break;
		default: vtkDataObject_SetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent,$numPieces_or_x1,$ghostLevel_or_y0,$y1,$z0,$z1);
		}
	}

	function GetUpdateExtent($x0_or_extent=null,$x1=null,$y0=null,$y1=null,$z0=null,$z1=null) {
		switch (func_num_args()) {
		case 0: $r=vtkDataObject_GetUpdateExtent($this->_cPtr); break;
		case 1: $r=vtkDataObject_GetUpdateExtent($this->_cPtr,$x0_or_extent); break;
		case 2: $r=vtkDataObject_GetUpdateExtent($this->_cPtr,$x0_or_extent,$x1); break;
		case 3: $r=vtkDataObject_GetUpdateExtent($this->_cPtr,$x0_or_extent,$x1,$y0); break;
		case 4: $r=vtkDataObject_GetUpdateExtent($this->_cPtr,$x0_or_extent,$x1,$y0,$y1); break;
		case 5: $r=vtkDataObject_GetUpdateExtent($this->_cPtr,$x0_or_extent,$x1,$y0,$y1,$z0); break;
		default: $r=vtkDataObject_GetUpdateExtent($this->_cPtr,$x0_or_extent,$x1,$y0,$y1,$z0,$z1);
		}
		return $r;
	}

	function GetDataObjectType() {
		return vtkDataObject_GetDataObjectType($this->_cPtr);
	}

	function GetUpdateTime() {
		return vtkDataObject_GetUpdateTime($this->_cPtr);
	}

	function SetUpdateExtentToWholeExtent() {
		vtkDataObject_SetUpdateExtentToWholeExtent($this->_cPtr);
	}

	function GetPipelineMTime() {
		return vtkDataObject_GetPipelineMTime($this->_cPtr);
	}

	function GetActualMemorySize() {
		return vtkDataObject_GetActualMemorySize($this->_cPtr);
	}

	function CopyInformation($data) {
		vtkDataObject_CopyInformation($this->_cPtr,$data);
	}

	function CopyTypeSpecificInformation($data) {
		vtkDataObject_CopyTypeSpecificInformation($this->_cPtr,$data);
	}

	function SetUpdatePiece($piece) {
		vtkDataObject_SetUpdatePiece($this->_cPtr,$piece);
	}

	function SetUpdateNumberOfPieces($num) {
		vtkDataObject_SetUpdateNumberOfPieces($this->_cPtr,$num);
	}

	function GetUpdatePiece() {
		return vtkDataObject_GetUpdatePiece($this->_cPtr);
	}

	function GetUpdateNumberOfPieces() {
		return vtkDataObject_GetUpdateNumberOfPieces($this->_cPtr);
	}

	function SetUpdateGhostLevel($level) {
		vtkDataObject_SetUpdateGhostLevel($this->_cPtr,$level);
	}

	function GetUpdateGhostLevel() {
		return vtkDataObject_GetUpdateGhostLevel($this->_cPtr);
	}

	function SetRequestExactExtent($flag) {
		vtkDataObject_SetRequestExactExtent($this->_cPtr,$flag);
	}

	function GetRequestExactExtent() {
		return vtkDataObject_GetRequestExactExtent($this->_cPtr);
	}

	function RequestExactExtentOn() {
		vtkDataObject_RequestExactExtentOn($this->_cPtr);
	}

	function RequestExactExtentOff() {
		vtkDataObject_RequestExactExtentOff($this->_cPtr);
	}

	function SetWholeExtent($x0_or_extent,$x1=null,$y0=null,$y1=null,$z0=null,$z1=null) {
		switch (func_num_args()) {
		case 1: vtkDataObject_SetWholeExtent($this->_cPtr,$x0_or_extent); break;
		case 2: vtkDataObject_SetWholeExtent($this->_cPtr,$x0_or_extent,$x1); break;
		case 3: vtkDataObject_SetWholeExtent($this->_cPtr,$x0_or_extent,$x1,$y0); break;
		case 4: vtkDataObject_SetWholeExtent($this->_cPtr,$x0_or_extent,$x1,$y0,$y1); break;
		case 5: vtkDataObject_SetWholeExtent($this->_cPtr,$x0_or_extent,$x1,$y0,$y1,$z0); break;
		default: vtkDataObject_SetWholeExtent($this->_cPtr,$x0_or_extent,$x1,$y0,$y1,$z0,$z1);
		}
	}

	function GetWholeExtent($x0_or_extent=null,$x1=null,$y0=null,$y1=null,$z0=null,$z1=null) {
		switch (func_num_args()) {
		case 0: $r=vtkDataObject_GetWholeExtent($this->_cPtr); break;
		case 1: $r=vtkDataObject_GetWholeExtent($this->_cPtr,$x0_or_extent); break;
		case 2: $r=vtkDataObject_GetWholeExtent($this->_cPtr,$x0_or_extent,$x1); break;
		case 3: $r=vtkDataObject_GetWholeExtent($this->_cPtr,$x0_or_extent,$x1,$y0); break;
		case 4: $r=vtkDataObject_GetWholeExtent($this->_cPtr,$x0_or_extent,$x1,$y0,$y1); break;
		case 5: $r=vtkDataObject_GetWholeExtent($this->_cPtr,$x0_or_extent,$x1,$y0,$y1,$z0); break;
		default: $r=vtkDataObject_GetWholeExtent($this->_cPtr,$x0_or_extent,$x1,$y0,$y1,$z0,$z1);
		}
		return $r;
	}

	function SetWholeBoundingBox($x0_or_bb,$x1=null,$y0=null,$y1=null,$z0=null,$z1=null) {
		switch (func_num_args()) {
		case 1: vtkDataObject_SetWholeBoundingBox($this->_cPtr,$x0_or_bb); break;
		case 2: vtkDataObject_SetWholeBoundingBox($this->_cPtr,$x0_or_bb,$x1); break;
		case 3: vtkDataObject_SetWholeBoundingBox($this->_cPtr,$x0_or_bb,$x1,$y0); break;
		case 4: vtkDataObject_SetWholeBoundingBox($this->_cPtr,$x0_or_bb,$x1,$y0,$y1); break;
		case 5: vtkDataObject_SetWholeBoundingBox($this->_cPtr,$x0_or_bb,$x1,$y0,$y1,$z0); break;
		default: vtkDataObject_SetWholeBoundingBox($this->_cPtr,$x0_or_bb,$x1,$y0,$y1,$z0,$z1);
		}
	}

	function GetWholeBoundingBox($x0_or_extent=null,$x1=null,$y0=null,$y1=null,$z0=null,$z1=null) {
		switch (func_num_args()) {
		case 0: $r=vtkDataObject_GetWholeBoundingBox($this->_cPtr); break;
		case 1: $r=vtkDataObject_GetWholeBoundingBox($this->_cPtr,$x0_or_extent); break;
		case 2: $r=vtkDataObject_GetWholeBoundingBox($this->_cPtr,$x0_or_extent,$x1); break;
		case 3: $r=vtkDataObject_GetWholeBoundingBox($this->_cPtr,$x0_or_extent,$x1,$y0); break;
		case 4: $r=vtkDataObject_GetWholeBoundingBox($this->_cPtr,$x0_or_extent,$x1,$y0,$y1); break;
		case 5: $r=vtkDataObject_GetWholeBoundingBox($this->_cPtr,$x0_or_extent,$x1,$y0,$y1,$z0); break;
		default: $r=vtkDataObject_GetWholeBoundingBox($this->_cPtr,$x0_or_extent,$x1,$y0,$y1,$z0,$z1);
		}
		return $r;
	}

	function SetMaximumNumberOfPieces($arg1) {
		vtkDataObject_SetMaximumNumberOfPieces($this->_cPtr,$arg1);
	}

	function GetMaximumNumberOfPieces() {
		return vtkDataObject_GetMaximumNumberOfPieces($this->_cPtr);
	}

	function CopyInformationToPipeline($request,$input,$output=null,$forceCopy=null) {
		switch (func_num_args()) {
		case 2: vtkDataObject_CopyInformationToPipeline($this->_cPtr,$request,$input); break;
		case 3: vtkDataObject_CopyInformationToPipeline($this->_cPtr,$request,$input,$output); break;
		default: vtkDataObject_CopyInformationToPipeline($this->_cPtr,$request,$input,$output,$forceCopy);
		}
	}

	function CopyInformationFromPipeline($request) {
		vtkDataObject_CopyInformationFromPipeline($this->_cPtr,$request);
	}

	static function GetActiveFieldInformation($info,$fieldAssociation,$attributeType) {
		return vtkDataObject_GetActiveFieldInformation($info,$fieldAssociation,$attributeType);
	}

	static function GetNamedFieldInformation($info,$fieldAssociation,$name) {
		return vtkDataObject_GetNamedFieldInformation($info,$fieldAssociation,$name);
	}

	static function RemoveNamedFieldInformation($info,$fieldAssociation,$name) {
		vtkDataObject_RemoveNamedFieldInformation($info,$fieldAssociation,$name);
	}

	static function SetActiveAttribute($info,$fieldAssociation,$attributeName,$attributeType) {
		return vtkDataObject_SetActiveAttribute($info,$fieldAssociation,$attributeName,$attributeType);
	}

	static function SetActiveAttributeInfo($info,$fieldAssociation,$attributeType,$name,$arrayType,$numComponents,$numTuples) {
		vtkDataObject_SetActiveAttributeInfo($info,$fieldAssociation,$attributeType,$name,$arrayType,$numComponents,$numTuples);
	}

	static function SetPointDataActiveScalarInfo($info,$arrayType,$numComponents) {
		vtkDataObject_SetPointDataActiveScalarInfo($info,$arrayType,$numComponents);
	}

	function DataHasBeenGenerated() {
		vtkDataObject_DataHasBeenGenerated($this->_cPtr);
	}

	function PrepareForNewData() {
		vtkDataObject_PrepareForNewData($this->_cPtr);
	}

	function ShallowCopy($src) {
		vtkDataObject_ShallowCopy($this->_cPtr,$src);
	}

	function DeepCopy($src) {
		vtkDataObject_DeepCopy($this->_cPtr,$src);
	}

	function SetExtentTranslator($translator) {
		vtkDataObject_SetExtentTranslator($this->_cPtr,$translator);
	}

	function GetExtentTranslator() {
		return vtkDataObject_GetExtentTranslator($this->_cPtr);
	}

	function GetExtentType() {
		return vtkDataObject_GetExtentType($this->_cPtr);
	}

	function Crop() {
		vtkDataObject_Crop($this->_cPtr);
	}

	const FIELD_ASSOCIATION_POINTS = 0;

	const FIELD_ASSOCIATION_CELLS = vtkDataObject_FIELD_ASSOCIATION_CELLS;

	const FIELD_ASSOCIATION_NONE = vtkDataObject_FIELD_ASSOCIATION_NONE;

	const FIELD_ASSOCIATION_POINTS_THEN_CELLS = vtkDataObject_FIELD_ASSOCIATION_POINTS_THEN_CELLS;

	const FIELD_ASSOCIATION_VERTICES = vtkDataObject_FIELD_ASSOCIATION_VERTICES;

	const FIELD_ASSOCIATION_EDGES = vtkDataObject_FIELD_ASSOCIATION_EDGES;

	const FIELD_ASSOCIATION_ROWS = vtkDataObject_FIELD_ASSOCIATION_ROWS;

	const NUMBER_OF_ASSOCIATIONS = vtkDataObject_NUMBER_OF_ASSOCIATIONS;

	const POINT = 0;

	const CELL = vtkDataObject_CELL;

	const FIELD = vtkDataObject_FIELD;

	const POINT_THEN_CELL = vtkDataObject_POINT_THEN_CELL;

	const VERTEX = vtkDataObject_VERTEX;

	const EDGE = vtkDataObject_EDGE;

	const ROW = vtkDataObject_ROW;

	const NUMBER_OF_ATTRIBUTE_TYPES = vtkDataObject_NUMBER_OF_ATTRIBUTE_TYPES;

	function GetAttributes($type) {
		return vtkDataObject_GetAttributes($this->_cPtr,$type);
	}

	function GetAttributesAsFieldData($type) {
		return vtkDataObject_GetAttributesAsFieldData($this->_cPtr,$type);
	}

	function GetAttributeTypeForArray($arr) {
		return vtkDataObject_GetAttributeTypeForArray($this->_cPtr,$arr);
	}

	function GetNumberOfElements($type) {
		return vtkDataObject_GetNumberOfElements($this->_cPtr,$type);
	}

	const FIELD_OPERATION_PRESERVED = 0;

	const FIELD_OPERATION_REINTERPOLATED = vtkDataObject_FIELD_OPERATION_REINTERPOLATED;

	const FIELD_OPERATION_MODIFIED = vtkDataObject_FIELD_OPERATION_MODIFIED;

	const FIELD_OPERATION_REMOVED = vtkDataObject_FIELD_OPERATION_REMOVED;

	static function GetAssociationTypeAsString($associationType) {
		return vtkDataObject_GetAssociationTypeAsString($associationType);
	}

	static function DATA_TYPE_NAME() {
		return vtkDataObject_DATA_TYPE_NAME();
	}

	static function DATA_OBJECT() {
		return vtkDataObject_DATA_OBJECT();
	}

	static function DATA_EXTENT_TYPE() {
		return vtkDataObject_DATA_EXTENT_TYPE();
	}

	static function DATA_EXTENT() {
		return vtkDataObject_DATA_EXTENT();
	}

	static function DATA_PIECE_NUMBER() {
		return vtkDataObject_DATA_PIECE_NUMBER();
	}

	static function DATA_NUMBER_OF_PIECES() {
		return vtkDataObject_DATA_NUMBER_OF_PIECES();
	}

	static function DATA_NUMBER_OF_GHOST_LEVELS() {
		return vtkDataObject_DATA_NUMBER_OF_GHOST_LEVELS();
	}

	static function DATA_RESOLUTION() {
		return vtkDataObject_DATA_RESOLUTION();
	}

	static function DATA_TIME_STEPS() {
		return vtkDataObject_DATA_TIME_STEPS();
	}

	static function POINT_DATA_VECTOR() {
		return vtkDataObject_POINT_DATA_VECTOR();
	}

	static function CELL_DATA_VECTOR() {
		return vtkDataObject_CELL_DATA_VECTOR();
	}

	static function VERTEX_DATA_VECTOR() {
		return vtkDataObject_VERTEX_DATA_VECTOR();
	}

	static function EDGE_DATA_VECTOR() {
		return vtkDataObject_EDGE_DATA_VECTOR();
	}

	static function FIELD_ARRAY_TYPE() {
		return vtkDataObject_FIELD_ARRAY_TYPE();
	}

	static function FIELD_ASSOCIATION() {
		return vtkDataObject_FIELD_ASSOCIATION();
	}

	static function FIELD_ATTRIBUTE_TYPE() {
		return vtkDataObject_FIELD_ATTRIBUTE_TYPE();
	}

	static function FIELD_ACTIVE_ATTRIBUTE() {
		return vtkDataObject_FIELD_ACTIVE_ATTRIBUTE();
	}

	static function FIELD_NUMBER_OF_COMPONENTS() {
		return vtkDataObject_FIELD_NUMBER_OF_COMPONENTS();
	}

	static function FIELD_NUMBER_OF_TUPLES() {
		return vtkDataObject_FIELD_NUMBER_OF_TUPLES();
	}

	static function FIELD_OPERATION() {
		return vtkDataObject_FIELD_OPERATION();
	}

	static function FIELD_RANGE() {
		return vtkDataObject_FIELD_RANGE();
	}

	static function PIECE_FIELD_RANGE() {
		return vtkDataObject_PIECE_FIELD_RANGE();
	}

	static function FIELD_ARRAY_NAME() {
		return vtkDataObject_FIELD_ARRAY_NAME();
	}

	static function PIECE_EXTENT() {
		return vtkDataObject_PIECE_EXTENT();
	}

	static function FIELD_NAME() {
		return vtkDataObject_FIELD_NAME();
	}

	static function ORIGIN() {
		return vtkDataObject_ORIGIN();
	}

	static function SPACING() {
		return vtkDataObject_SPACING();
	}

	static function DATA_GEOMETRY_UNMODIFIED() {
		return vtkDataObject_DATA_GEOMETRY_UNMODIFIED();
	}

	static function SIL() {
		return vtkDataObject_SIL();
	}

	static function GetData($info_or_v,$i=0) {
		$r=vtkDataObject_GetData($info_or_v,$i);
		if (!is_resource($r)) return $r;
		switch (get_resource_type($r)) {
		case '_p_vtkDataObject': return new vtkDataObject($r);
		default: return new vtkDataObject($r);
		}
	}
}

abstract class vtkDataSet extends vtkDataObject {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkDataObject::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkDataObject::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkDataObject::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	function CopyStructure($ds) {
		vtkDataSet_CopyStructure($this->_cPtr,$ds);
	}

	function CopyAttributes($ds) {
		vtkDataSet_CopyAttributes($this->_cPtr,$ds);
	}

	function GetNumberOfPoints() {
		return vtkDataSet_GetNumberOfPoints($this->_cPtr);
	}

	function GetNumberOfCells() {
		return vtkDataSet_GetNumberOfCells($this->_cPtr);
	}

	function GetPoint($ptId_or_id,$x=null) {
		switch (func_num_args()) {
		case 1: $r=vtkDataSet_GetPoint($this->_cPtr,$ptId_or_id); break;
		default: $r=vtkDataSet_GetPoint($this->_cPtr,$ptId_or_id,$x);
		}
		return $r;
	}

	function GetCell($cellId,$cell=null) {
		switch (func_num_args()) {
		case 1: $r=vtkDataSet_GetCell($this->_cPtr,$cellId); break;
		default: $r=vtkDataSet_GetCell($this->_cPtr,$cellId,$cell);
		}
		return $r;
	}

	function GetCellBounds($cellId,$bounds) {
		vtkDataSet_GetCellBounds($this->_cPtr,$cellId,$bounds);
	}

	function GetCellType($cellId) {
		return vtkDataSet_GetCellType($this->_cPtr,$cellId);
	}

	function GetCellTypes($types) {
		vtkDataSet_GetCellTypes($this->_cPtr,$types);
	}

	function GetCellPoints($cellId,$ptIds) {
		vtkDataSet_GetCellPoints($this->_cPtr,$cellId,$ptIds);
	}

	function GetPointCells($ptId,$cellIds) {
		vtkDataSet_GetPointCells($this->_cPtr,$ptId,$cellIds);
	}

	function GetCellNeighbors($cellId,$ptIds,$cellIds) {
		vtkDataSet_GetCellNeighbors($this->_cPtr,$cellId,$ptIds,$cellIds);
	}

	function FindPoint($x,$y=null,$z=null) {
		switch (func_num_args()) {
		case 1: $r=vtkDataSet_FindPoint($this->_cPtr,$x); break;
		case 2: $r=vtkDataSet_FindPoint($this->_cPtr,$x,$y); break;
		default: $r=vtkDataSet_FindPoint($this->_cPtr,$x,$y,$z);
		}
		return $r;
	}

	function FindCell($x,$cell,$cellId_or_gencell,$tol2_or_cellId,$subId_or_tol2,$pcoords_or_subId,$weights_or_pcoords,$weights=null) {
		switch (func_num_args()) {
		case 7: $r=vtkDataSet_FindCell($this->_cPtr,$x,$cell,$cellId_or_gencell,$tol2_or_cellId,$subId_or_tol2,$pcoords_or_subId,$weights_or_pcoords); break;
		default: $r=vtkDataSet_FindCell($this->_cPtr,$x,$cell,$cellId_or_gencell,$tol2_or_cellId,$subId_or_tol2,$pcoords_or_subId,$weights_or_pcoords,$weights);
		}
		return $r;
	}

	function FindAndGetCell($x,$cell,$cellId,$tol2,$subId,$pcoords,$weights) {
		return vtkDataSet_FindAndGetCell($this->_cPtr,$x,$cell,$cellId,$tol2,$subId,$pcoords,$weights);
	}

	function GetMTime() {
		return vtkDataSet_GetMTime($this->_cPtr);
	}

	function GetCellData() {
		return vtkDataSet_GetCellData($this->_cPtr);
	}

	function GetPointData() {
		return vtkDataSet_GetPointData($this->_cPtr);
	}

	function Squeeze() {
		vtkDataSet_Squeeze($this->_cPtr);
	}

	function ComputeBounds() {
		vtkDataSet_ComputeBounds($this->_cPtr);
	}

	function GetBounds($bounds=null) {
		switch (func_num_args()) {
		case 0: $r=vtkDataSet_GetBounds($this->_cPtr); break;
		default: $r=vtkDataSet_GetBounds($this->_cPtr,$bounds);
		}
		return $r;
	}

	function GetCenter($center=null) {
		switch (func_num_args()) {
		case 0: $r=vtkDataSet_GetCenter($this->_cPtr); break;
		default: $r=vtkDataSet_GetCenter($this->_cPtr,$center);
		}
		return $r;
	}

	function GetLength() {
		return vtkDataSet_GetLength($this->_cPtr);
	}

	function Initialize() {
		vtkDataSet_Initialize($this->_cPtr);
	}

	function GetScalarRange($range=null) {
		switch (func_num_args()) {
		case 0: $r=vtkDataSet_GetScalarRange($this->_cPtr); break;
		default: $r=vtkDataSet_GetScalarRange($this->_cPtr,$range);
		}
		return $r;
	}

	function GetMaxCellSize() {
		return vtkDataSet_GetMaxCellSize($this->_cPtr);
	}

	function GetActualMemorySize() {
		return vtkDataSet_GetActualMemorySize($this->_cPtr);
	}

	function GetDataObjectType() {
		return vtkDataSet_GetDataObjectType($this->_cPtr);
	}

	function ShallowCopy($src) {
		vtkDataSet_ShallowCopy($this->_cPtr,$src);
	}

	function DeepCopy($src) {
		vtkDataSet_DeepCopy($this->_cPtr,$src);
	}

	const DATA_OBJECT_FIELD = 0;

	const POINT_DATA_FIELD = 1;

	const CELL_DATA_FIELD = 2;

	function CheckAttributes() {
		return vtkDataSet_CheckAttributes($this->_cPtr);
	}

	function GenerateGhostLevelArray() {
		vtkDataSet_GenerateGhostLevelArray($this->_cPtr);
	}

	static function GetData($info_or_v,$i=0) {
		$r=vtkDataSet_GetData($info_or_v,$i);
		if (!is_resource($r)) return $r;
		switch (get_resource_type($r)) {
		case '_p_vtkDataSet': return new vtkDataSet($r);
		default: return new vtkDataSet($r);
		}
	}

	function GetAttributesAsFieldData($type) {
		return vtkDataSet_GetAttributesAsFieldData($this->_cPtr,$type);
	}

	function GetNumberOfElements($type) {
		return vtkDataSet_GetNumberOfElements($this->_cPtr,$type);
	}
}

class vtkImageData extends vtkDataSet {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkDataSet::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkDataSet::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkDataSet::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkImageData_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageData($r);
		}
		return $r;
	}

	function CopyStructure($ds) {
		vtkImageData_CopyStructure($this->_cPtr,$ds);
	}

	function GetDataObjectType() {
		return vtkImageData_GetDataObjectType($this->_cPtr);
	}

	function GetNumberOfCells() {
		return vtkImageData_GetNumberOfCells($this->_cPtr);
	}

	function GetNumberOfPoints() {
		return vtkImageData_GetNumberOfPoints($this->_cPtr);
	}

	function GetPoint($ptId_or_id,$x=null) {
		switch (func_num_args()) {
		case 1: $r=vtkImageData_GetPoint($this->_cPtr,$ptId_or_id); break;
		default: $r=vtkImageData_GetPoint($this->_cPtr,$ptId_or_id,$x);
		}
		return $r;
	}

	function GetCell($cellId,$cell=null) {
		switch (func_num_args()) {
		case 1: $r=vtkImageData_GetCell($this->_cPtr,$cellId); break;
		default: $r=vtkImageData_GetCell($this->_cPtr,$cellId,$cell);
		}
		return $r;
	}

	function GetCellBounds($cellId,$bounds) {
		vtkImageData_GetCellBounds($this->_cPtr,$cellId,$bounds);
	}

	function FindPoint($x,$y=null,$z=null) {
		switch (func_num_args()) {
		case 1: $r=vtkImageData_FindPoint($this->_cPtr,$x); break;
		case 2: $r=vtkImageData_FindPoint($this->_cPtr,$x,$y); break;
		default: $r=vtkImageData_FindPoint($this->_cPtr,$x,$y,$z);
		}
		return $r;
	}

	function FindCell($x,$cell,$cellId_or_gencell,$tol2_or_cellId,$subId_or_tol2,$pcoords_or_subId,$weights_or_pcoords,$weights=null) {
		switch (func_num_args()) {
		case 7: $r=vtkImageData_FindCell($this->_cPtr,$x,$cell,$cellId_or_gencell,$tol2_or_cellId,$subId_or_tol2,$pcoords_or_subId,$weights_or_pcoords); break;
		default: $r=vtkImageData_FindCell($this->_cPtr,$x,$cell,$cellId_or_gencell,$tol2_or_cellId,$subId_or_tol2,$pcoords_or_subId,$weights_or_pcoords,$weights);
		}
		return $r;
	}

	function FindAndGetCell($x,$cell,$cellId,$tol2,$subId,$pcoords,$weights) {
		return vtkImageData_FindAndGetCell($this->_cPtr,$x,$cell,$cellId,$tol2,$subId,$pcoords,$weights);
	}

	function GetCellType($cellId) {
		return vtkImageData_GetCellType($this->_cPtr,$cellId);
	}

	function GetCellPoints($cellId,$ptIds) {
		vtkImageData_GetCellPoints($this->_cPtr,$cellId,$ptIds);
	}

	function GetPointCells($ptId,$cellIds) {
		vtkImageData_GetPointCells($this->_cPtr,$ptId,$cellIds);
	}

	function ComputeBounds() {
		vtkImageData_ComputeBounds($this->_cPtr);
	}

	function GetMaxCellSize() {
		return vtkImageData_GetMaxCellSize($this->_cPtr);
	}

	function Initialize() {
		vtkImageData_Initialize($this->_cPtr);
	}

	function SetDimensions($i_or_dims,$j=null,$k=null) {
		switch (func_num_args()) {
		case 1: vtkImageData_SetDimensions($this->_cPtr,$i_or_dims); break;
		case 2: vtkImageData_SetDimensions($this->_cPtr,$i_or_dims,$j); break;
		default: vtkImageData_SetDimensions($this->_cPtr,$i_or_dims,$j,$k);
		}
	}

	function GetDimensions($dims=null) {
		switch (func_num_args()) {
		case 0: $r=vtkImageData_GetDimensions($this->_cPtr); break;
		default: $r=vtkImageData_GetDimensions($this->_cPtr,$dims);
		}
		return $r;
	}

	function ComputeStructuredCoordinates($x,$ijk,$pcoords) {
		return vtkImageData_ComputeStructuredCoordinates($this->_cPtr,$x,$ijk,$pcoords);
	}

	function GetVoxelGradient($i,$j,$k,$s,$g) {
		vtkImageData_GetVoxelGradient($this->_cPtr,$i,$j,$k,$s,$g);
	}

	function GetPointGradient($i,$j,$k,$s,$g) {
		vtkImageData_GetPointGradient($this->_cPtr,$i,$j,$k,$s,$g);
	}

	function GetDataDimension() {
		return vtkImageData_GetDataDimension($this->_cPtr);
	}

	function ComputePointId($ijk) {
		return vtkImageData_ComputePointId($this->_cPtr,$ijk);
	}

	function ComputeCellId($ijk) {
		return vtkImageData_ComputeCellId($this->_cPtr,$ijk);
	}

	function SetAxisUpdateExtent($axis,$min,$max) {
		vtkImageData_SetAxisUpdateExtent($this->_cPtr,$axis,$min,$max);
	}

	function GetAxisUpdateExtent($axis,$min,$max) {
		vtkImageData_GetAxisUpdateExtent($this->_cPtr,$axis,$min,$max);
	}

	function UpdateInformation() {
		vtkImageData_UpdateInformation($this->_cPtr);
	}

	function SetExtent($extent_or_x1,$x2=null,$y1=null,$y2=null,$z1=null,$z2=null) {
		switch (func_num_args()) {
		case 1: vtkImageData_SetExtent($this->_cPtr,$extent_or_x1); break;
		case 2: vtkImageData_SetExtent($this->_cPtr,$extent_or_x1,$x2); break;
		case 3: vtkImageData_SetExtent($this->_cPtr,$extent_or_x1,$x2,$y1); break;
		case 4: vtkImageData_SetExtent($this->_cPtr,$extent_or_x1,$x2,$y1,$y2); break;
		case 5: vtkImageData_SetExtent($this->_cPtr,$extent_or_x1,$x2,$y1,$y2,$z1); break;
		default: vtkImageData_SetExtent($this->_cPtr,$extent_or_x1,$x2,$y1,$y2,$z1,$z2);
		}
	}

	function GetExtent() {
		return vtkImageData_GetExtent($this->_cPtr);
	}

	function GetEstimatedMemorySize() {
		return vtkImageData_GetEstimatedMemorySize($this->_cPtr);
	}

	function GetScalarTypeMin() {
		return vtkImageData_GetScalarTypeMin($this->_cPtr);
	}

	function GetScalarTypeMax() {
		return vtkImageData_GetScalarTypeMax($this->_cPtr);
	}

	function GetScalarSize() {
		return vtkImageData_GetScalarSize($this->_cPtr);
	}

	function GetIncrements($incX_or_inc=null,$incY=null,$incZ=null) {
		switch (func_num_args()) {
		case 0: $r=vtkImageData_GetIncrements($this->_cPtr); break;
		case 1: $r=vtkImageData_GetIncrements($this->_cPtr,$incX_or_inc); break;
		case 2: $r=vtkImageData_GetIncrements($this->_cPtr,$incX_or_inc,$incY); break;
		default: $r=vtkImageData_GetIncrements($this->_cPtr,$incX_or_inc,$incY,$incZ);
		}
		return $r;
	}

	function GetContinuousIncrements($extent,$incX,$incY,$incZ) {
		vtkImageData_GetContinuousIncrements($this->_cPtr,$extent,$incX,$incY,$incZ);
	}

	function GetScalarPointerForExtent($extent) {
		return vtkImageData_GetScalarPointerForExtent($this->_cPtr,$extent);
	}

	function GetScalarPointer($coordinates_or_x=null,$y=null,$z=null) {
		switch (func_num_args()) {
		case 0: $r=vtkImageData_GetScalarPointer($this->_cPtr); break;
		case 1: $r=vtkImageData_GetScalarPointer($this->_cPtr,$coordinates_or_x); break;
		case 2: $r=vtkImageData_GetScalarPointer($this->_cPtr,$coordinates_or_x,$y); break;
		default: $r=vtkImageData_GetScalarPointer($this->_cPtr,$coordinates_or_x,$y,$z);
		}
		return $r;
	}

	function GetScalarComponentAsFloat($x,$y,$z,$component) {
		return vtkImageData_GetScalarComponentAsFloat($this->_cPtr,$x,$y,$z,$component);
	}

	function SetScalarComponentFromFloat($x,$y,$z,$component,$v) {
		vtkImageData_SetScalarComponentFromFloat($this->_cPtr,$x,$y,$z,$component,$v);
	}

	function GetScalarComponentAsDouble($x,$y,$z,$component) {
		return vtkImageData_GetScalarComponentAsDouble($this->_cPtr,$x,$y,$z,$component);
	}

	function SetScalarComponentFromDouble($x,$y,$z,$component,$v) {
		vtkImageData_SetScalarComponentFromDouble($this->_cPtr,$x,$y,$z,$component,$v);
	}

	function AllocateScalars() {
		vtkImageData_AllocateScalars($this->_cPtr);
	}

	function CopyAndCastFrom($inData,$extent_or_x0,$x1=null,$y0=null,$y1=null,$z0=null,$z1=null) {
		switch (func_num_args()) {
		case 2: vtkImageData_CopyAndCastFrom($this->_cPtr,$inData,$extent_or_x0); break;
		case 3: vtkImageData_CopyAndCastFrom($this->_cPtr,$inData,$extent_or_x0,$x1); break;
		case 4: vtkImageData_CopyAndCastFrom($this->_cPtr,$inData,$extent_or_x0,$x1,$y0); break;
		case 5: vtkImageData_CopyAndCastFrom($this->_cPtr,$inData,$extent_or_x0,$x1,$y0,$y1); break;
		case 6: vtkImageData_CopyAndCastFrom($this->_cPtr,$inData,$extent_or_x0,$x1,$y0,$y1,$z0); break;
		default: vtkImageData_CopyAndCastFrom($this->_cPtr,$inData,$extent_or_x0,$x1,$y0,$y1,$z0,$z1);
		}
	}

	function Crop() {
		vtkImageData_Crop($this->_cPtr);
	}

	function GetActualMemorySize() {
		return vtkImageData_GetActualMemorySize($this->_cPtr);
	}

	function SetSpacing($_arg1,$_arg2,$_arg3) {
		vtkImageData_SetSpacing($this->_cPtr,$_arg1,$_arg2,$_arg3);
	}

	function GetSpacing() {
		return vtkImageData_GetSpacing($this->_cPtr);
	}

	function SetOrigin($_arg1,$_arg2,$_arg3) {
		vtkImageData_SetOrigin($this->_cPtr,$_arg1,$_arg2,$_arg3);
	}

	function GetOrigin() {
		return vtkImageData_GetOrigin($this->_cPtr);
	}

	function SetScalarTypeToFloat() {
		vtkImageData_SetScalarTypeToFloat($this->_cPtr);
	}

	function SetScalarTypeToDouble() {
		vtkImageData_SetScalarTypeToDouble($this->_cPtr);
	}

	function SetScalarTypeToInt() {
		vtkImageData_SetScalarTypeToInt($this->_cPtr);
	}

	function SetScalarTypeToUnsignedInt() {
		vtkImageData_SetScalarTypeToUnsignedInt($this->_cPtr);
	}

	function SetScalarTypeToLong() {
		vtkImageData_SetScalarTypeToLong($this->_cPtr);
	}

	function SetScalarTypeToUnsignedLong() {
		vtkImageData_SetScalarTypeToUnsignedLong($this->_cPtr);
	}

	function SetScalarTypeToShort() {
		vtkImageData_SetScalarTypeToShort($this->_cPtr);
	}

	function SetScalarTypeToUnsignedShort() {
		vtkImageData_SetScalarTypeToUnsignedShort($this->_cPtr);
	}

	function SetScalarTypeToUnsignedChar() {
		vtkImageData_SetScalarTypeToUnsignedChar($this->_cPtr);
	}

	function SetScalarTypeToSignedChar() {
		vtkImageData_SetScalarTypeToSignedChar($this->_cPtr);
	}

	function SetScalarTypeToChar() {
		vtkImageData_SetScalarTypeToChar($this->_cPtr);
	}

	function SetScalarType($arg1) {
		vtkImageData_SetScalarType($this->_cPtr,$arg1);
	}

	function GetScalarType() {
		return vtkImageData_GetScalarType($this->_cPtr);
	}

	function GetScalarTypeAsString() {
		return vtkImageData_GetScalarTypeAsString($this->_cPtr);
	}

	function SetNumberOfScalarComponents($n) {
		vtkImageData_SetNumberOfScalarComponents($this->_cPtr,$n);
	}

	function GetNumberOfScalarComponents() {
		return vtkImageData_GetNumberOfScalarComponents($this->_cPtr);
	}

	function CopyTypeSpecificInformation($image) {
		vtkImageData_CopyTypeSpecificInformation($this->_cPtr,$image);
	}

	function CopyInformationToPipeline($request,$input,$output,$forceCopy) {
		vtkImageData_CopyInformationToPipeline($this->_cPtr,$request,$input,$output,$forceCopy);
	}

	function CopyInformationFromPipeline($request) {
		vtkImageData_CopyInformationFromPipeline($this->_cPtr,$request);
	}

	function PrepareForNewData() {
		vtkImageData_PrepareForNewData($this->_cPtr);
	}

	function ShallowCopy($src) {
		vtkImageData_ShallowCopy($this->_cPtr,$src);
	}

	function DeepCopy($src) {
		vtkImageData_DeepCopy($this->_cPtr,$src);
	}

	function GetArrayPointerForExtent($array,$extent) {
		return vtkImageData_GetArrayPointerForExtent($this->_cPtr,$array,$extent);
	}

	function GetArrayPointer($array,$coordinates) {
		return vtkImageData_GetArrayPointer($this->_cPtr,$array,$coordinates);
	}

	function GetArrayIncrements($array,$increments) {
		vtkImageData_GetArrayIncrements($this->_cPtr,$array,$increments);
	}

	function ComputeInternalExtent($intExt,$tgtExt,$bnds) {
		vtkImageData_ComputeInternalExtent($this->_cPtr,$intExt,$tgtExt,$bnds);
	}

	function GetExtentType() {
		return vtkImageData_GetExtentType($this->_cPtr);
	}

	static function GetData($info_or_v,$i=0) {
		$r=vtkImageData_GetData($info_or_v,$i);
		if (!is_resource($r)) return $r;
		switch (get_resource_type($r)) {
		case '_p_vtkImageData': return new vtkImageData($r);
		default: return new vtkImageData($r);
		}
	}
}

abstract class vtkPointSet extends vtkDataSet {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkDataSet::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkDataSet::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkDataSet::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	function Initialize() {
		vtkPointSet_Initialize($this->_cPtr);
	}

	function CopyStructure($pd) {
		vtkPointSet_CopyStructure($this->_cPtr,$pd);
	}

	function GetNumberOfPoints() {
		return vtkPointSet_GetNumberOfPoints($this->_cPtr);
	}

	function GetPoint($ptId,$x=null) {
		switch (func_num_args()) {
		case 1: $r=vtkPointSet_GetPoint($this->_cPtr,$ptId); break;
		default: $r=vtkPointSet_GetPoint($this->_cPtr,$ptId,$x);
		}
		return $r;
	}

	function FindPoint($x,$y=null,$z=null) {
		switch (func_num_args()) {
		case 1: $r=vtkPointSet_FindPoint($this->_cPtr,$x); break;
		case 2: $r=vtkPointSet_FindPoint($this->_cPtr,$x,$y); break;
		default: $r=vtkPointSet_FindPoint($this->_cPtr,$x,$y,$z);
		}
		return $r;
	}

	function FindCell($x,$cell,$cellId_or_gencell,$tol2_or_cellId,$subId_or_tol2,$pcoords_or_subId,$weights_or_pcoords,$weights=null) {
		switch (func_num_args()) {
		case 7: $r=vtkPointSet_FindCell($this->_cPtr,$x,$cell,$cellId_or_gencell,$tol2_or_cellId,$subId_or_tol2,$pcoords_or_subId,$weights_or_pcoords); break;
		default: $r=vtkPointSet_FindCell($this->_cPtr,$x,$cell,$cellId_or_gencell,$tol2_or_cellId,$subId_or_tol2,$pcoords_or_subId,$weights_or_pcoords,$weights);
		}
		return $r;
	}

	function GetMTime() {
		return vtkPointSet_GetMTime($this->_cPtr);
	}

	function ComputeBounds() {
		vtkPointSet_ComputeBounds($this->_cPtr);
	}

	function Squeeze() {
		vtkPointSet_Squeeze($this->_cPtr);
	}

	function SetPoints($arg1) {
		vtkPointSet_SetPoints($this->_cPtr,$arg1);
	}

	function GetPoints() {
		return vtkPointSet_GetPoints($this->_cPtr);
	}

	function GetActualMemorySize() {
		return vtkPointSet_GetActualMemorySize($this->_cPtr);
	}

	function ShallowCopy($src) {
		vtkPointSet_ShallowCopy($this->_cPtr,$src);
	}

	function DeepCopy($src) {
		vtkPointSet_DeepCopy($this->_cPtr,$src);
	}

	static function GetData($info_or_v,$i=0) {
		$r=vtkPointSet_GetData($info_or_v,$i);
		if (!is_resource($r)) return $r;
		switch (get_resource_type($r)) {
		case '_p_vtkPointSet': return new vtkPointSet($r);
		default: return new vtkPointSet($r);
		}
	}
}

class vtkPolyData extends vtkPointSet {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkPointSet::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkPointSet::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkPointSet::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkPolyData_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkPolyData($r);
		}
		return $r;
	}

	function GetDataObjectType() {
		return vtkPolyData_GetDataObjectType($this->_cPtr);
	}

	function CopyStructure($ds) {
		vtkPolyData_CopyStructure($this->_cPtr,$ds);
	}

	function GetNumberOfCells() {
		return vtkPolyData_GetNumberOfCells($this->_cPtr);
	}

	function GetCell($cellId,$cell=null) {
		switch (func_num_args()) {
		case 1: $r=vtkPolyData_GetCell($this->_cPtr,$cellId); break;
		default: $r=vtkPolyData_GetCell($this->_cPtr,$cellId,$cell);
		}
		return $r;
	}

	function GetCellType($cellId) {
		return vtkPolyData_GetCellType($this->_cPtr,$cellId);
	}

	function GetCellBounds($cellId,$bounds) {
		vtkPolyData_GetCellBounds($this->_cPtr,$cellId,$bounds);
	}

	function GetCellNeighbors($cellId,$ptIds,$cellIds) {
		vtkPolyData_GetCellNeighbors($this->_cPtr,$cellId,$ptIds,$cellIds);
	}

	function CopyCells($pd,$idList,$locator=null) {
		vtkPolyData_CopyCells($this->_cPtr,$pd,$idList,$locator);
	}

	function ComputeBounds() {
		vtkPolyData_ComputeBounds($this->_cPtr);
	}

	function Squeeze() {
		vtkPolyData_Squeeze($this->_cPtr);
	}

	function GetMaxCellSize() {
		return vtkPolyData_GetMaxCellSize($this->_cPtr);
	}

	function SetVerts($v) {
		vtkPolyData_SetVerts($this->_cPtr,$v);
	}

	function GetVerts() {
		return vtkPolyData_GetVerts($this->_cPtr);
	}

	function SetLines($l) {
		vtkPolyData_SetLines($this->_cPtr,$l);
	}

	function GetLines() {
		return vtkPolyData_GetLines($this->_cPtr);
	}

	function SetPolys($p) {
		vtkPolyData_SetPolys($this->_cPtr,$p);
	}

	function GetPolys() {
		return vtkPolyData_GetPolys($this->_cPtr);
	}

	function SetStrips($s) {
		vtkPolyData_SetStrips($this->_cPtr,$s);
	}

	function GetStrips() {
		return vtkPolyData_GetStrips($this->_cPtr);
	}

	function GetNumberOfVerts() {
		return vtkPolyData_GetNumberOfVerts($this->_cPtr);
	}

	function GetNumberOfLines() {
		return vtkPolyData_GetNumberOfLines($this->_cPtr);
	}

	function GetNumberOfPolys() {
		return vtkPolyData_GetNumberOfPolys($this->_cPtr);
	}

	function GetNumberOfStrips() {
		return vtkPolyData_GetNumberOfStrips($this->_cPtr);
	}

	function Allocate($numCells_or_inPolyData=null,$extSize_or_numCells=null,$extSize=null) {
		switch (func_num_args()) {
		case 0: vtkPolyData_Allocate($this->_cPtr); break;
		case 1: vtkPolyData_Allocate($this->_cPtr,$numCells_or_inPolyData); break;
		case 2: vtkPolyData_Allocate($this->_cPtr,$numCells_or_inPolyData,$extSize_or_numCells); break;
		default: vtkPolyData_Allocate($this->_cPtr,$numCells_or_inPolyData,$extSize_or_numCells,$extSize);
		}
	}

	function InsertNextCell($type,$npts_or_pts,$pts=null) {
		switch (func_num_args()) {
		case 2: $r=vtkPolyData_InsertNextCell($this->_cPtr,$type,$npts_or_pts); break;
		default: $r=vtkPolyData_InsertNextCell($this->_cPtr,$type,$npts_or_pts,$pts);
		}
		return $r;
	}

	function Reset() {
		vtkPolyData_Reset($this->_cPtr);
	}

	function BuildCells() {
		vtkPolyData_BuildCells($this->_cPtr);
	}

	function BuildLinks($initialSize=0) {
		vtkPolyData_BuildLinks($this->_cPtr,$initialSize);
	}

	function DeleteCells() {
		vtkPolyData_DeleteCells($this->_cPtr);
	}

	function DeleteLinks() {
		vtkPolyData_DeleteLinks($this->_cPtr);
	}

	function GetPointCells($ptId,$cellIds_or_ncells,$cells=null) {
		switch (func_num_args()) {
		case 2: vtkPolyData_GetPointCells($this->_cPtr,$ptId,$cellIds_or_ncells); break;
		default: vtkPolyData_GetPointCells($this->_cPtr,$ptId,$cellIds_or_ncells,$cells);
		}
	}

	function GetCellEdgeNeighbors($cellId,$p1,$p2,$cellIds) {
		vtkPolyData_GetCellEdgeNeighbors($this->_cPtr,$cellId,$p1,$p2,$cellIds);
	}

	function GetCellPoints($cellId,$ptIds_or_npts,$pts=null) {
		switch (func_num_args()) {
		case 2: vtkPolyData_GetCellPoints($this->_cPtr,$cellId,$ptIds_or_npts); break;
		default: vtkPolyData_GetCellPoints($this->_cPtr,$cellId,$ptIds_or_npts,$pts);
		}
	}

	function IsTriangle($v1,$v2,$v3) {
		return vtkPolyData_IsTriangle($this->_cPtr,$v1,$v2,$v3);
	}

	function IsEdge($p1,$p2) {
		return vtkPolyData_IsEdge($this->_cPtr,$p1,$p2);
	}

	function IsPointUsedByCell($ptId,$cellId) {
		return vtkPolyData_IsPointUsedByCell($this->_cPtr,$ptId,$cellId);
	}

	function ReplaceCell($cellId,$npts,$pts) {
		vtkPolyData_ReplaceCell($this->_cPtr,$cellId,$npts,$pts);
	}

	function ReplaceCellPoint($cellId,$oldPtId,$newPtId) {
		vtkPolyData_ReplaceCellPoint($this->_cPtr,$cellId,$oldPtId,$newPtId);
	}

	function ReverseCell($cellId) {
		vtkPolyData_ReverseCell($this->_cPtr,$cellId);
	}

	function DeletePoint($ptId) {
		vtkPolyData_DeletePoint($this->_cPtr,$ptId);
	}

	function DeleteCell($cellId) {
		vtkPolyData_DeleteCell($this->_cPtr,$cellId);
	}

	function RemoveDeletedCells() {
		vtkPolyData_RemoveDeletedCells($this->_cPtr);
	}

	function InsertNextLinkedPoint($numLinks_or_x,$numLinks=null) {
		switch (func_num_args()) {
		case 1: $r=vtkPolyData_InsertNextLinkedPoint($this->_cPtr,$numLinks_or_x); break;
		default: $r=vtkPolyData_InsertNextLinkedPoint($this->_cPtr,$numLinks_or_x,$numLinks);
		}
		return $r;
	}

	function InsertNextLinkedCell($type,$npts,$pts) {
		return vtkPolyData_InsertNextLinkedCell($this->_cPtr,$type,$npts,$pts);
	}

	function ReplaceLinkedCell($cellId,$npts,$pts) {
		vtkPolyData_ReplaceLinkedCell($this->_cPtr,$cellId,$npts,$pts);
	}

	function RemoveCellReference($cellId) {
		vtkPolyData_RemoveCellReference($this->_cPtr,$cellId);
	}

	function AddCellReference($cellId) {
		vtkPolyData_AddCellReference($this->_cPtr,$cellId);
	}

	function RemoveReferenceToCell($ptId,$cellId) {
		vtkPolyData_RemoveReferenceToCell($this->_cPtr,$ptId,$cellId);
	}

	function AddReferenceToCell($ptId,$cellId) {
		vtkPolyData_AddReferenceToCell($this->_cPtr,$ptId,$cellId);
	}

	function ResizeCellList($ptId,$size) {
		vtkPolyData_ResizeCellList($this->_cPtr,$ptId,$size);
	}

	function Initialize() {
		vtkPolyData_Initialize($this->_cPtr);
	}

	function GetUpdateExtent($piece_or_x0_or_extent=null,$numPieces_or_x1=null,$ghostLevel_or_y0=null,$y1=null,$z0=null,$z1=null) {
		switch (func_num_args()) {
		case 0: $r=vtkPolyData_GetUpdateExtent($this->_cPtr); break;
		case 1: $r=vtkPolyData_GetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent); break;
		case 2: $r=vtkPolyData_GetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent,$numPieces_or_x1); break;
		case 3: $r=vtkPolyData_GetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent,$numPieces_or_x1,$ghostLevel_or_y0); break;
		case 4: $r=vtkPolyData_GetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent,$numPieces_or_x1,$ghostLevel_or_y0,$y1); break;
		case 5: $r=vtkPolyData_GetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent,$numPieces_or_x1,$ghostLevel_or_y0,$y1,$z0); break;
		default: $r=vtkPolyData_GetUpdateExtent($this->_cPtr,$piece_or_x0_or_extent,$numPieces_or_x1,$ghostLevel_or_y0,$y1,$z0,$z1);
		}
		return $r;
	}

	function GetPiece() {
		return vtkPolyData_GetPiece($this->_cPtr);
	}

	function GetNumberOfPieces() {
		return vtkPolyData_GetNumberOfPieces($this->_cPtr);
	}

	function GetGhostLevel() {
		return vtkPolyData_GetGhostLevel($this->_cPtr);
	}

	function GetActualMemorySize() {
		return vtkPolyData_GetActualMemorySize($this->_cPtr);
	}

	function ShallowCopy($src) {
		vtkPolyData_ShallowCopy($this->_cPtr,$src);
	}

	function DeepCopy($src) {
		vtkPolyData_DeepCopy($this->_cPtr,$src);
	}

	function RemoveGhostCells($level) {
		vtkPolyData_RemoveGhostCells($this->_cPtr,$level);
	}

	static function GetData($info_or_v,$i=0) {
		$r=vtkPolyData_GetData($info_or_v,$i);
		if (!is_resource($r)) return $r;
		switch (get_resource_type($r)) {
		case '_p_vtkPolyData': return new vtkPolyData($r);
		default: return new vtkPolyData($r);
		}
	}

	const ERR_NO_SUCH_FIELD = -4;

	const ERR_INCORRECT_FIELD = -3;

	const ERR_NON_MANIFOLD_STAR = -2;

	const REGULAR_POINT = -1;

	const MINIMUM = 0;

	const SADDLE = 1;

	const MAXIMUM = 2;

	function GetScalarFieldCriticalIndex($pointId,$scalarField_or_fieldId_or_fieldName) {
		return vtkPolyData_GetScalarFieldCriticalIndex($this->_cPtr,$pointId,$scalarField_or_fieldId_or_fieldName);
	}
}

class vtkAlgorithm extends vtkObject {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'AbortExecute') return vtkAlgorithm_AbortExecute_set($this->_cPtr,$value);
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkObject::__set($var,$value);
	}

	function __isset($var) {
		if (function_exists('vtkAlgorithm_'.$var.'_set')) return true;
		if ($var === 'thisown') return true;
		return vtkObject::__isset($var);
	}

	function __get($var) {
		if ($var === 'AbortExecute') return vtkAlgorithm_AbortExecute_get($this->_cPtr);
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkObject::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkAlgorithm_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkAlgorithm($r);
		}
		return $r;
	}

	function HasExecutive() {
		return vtkAlgorithm_HasExecutive($this->_cPtr);
	}

	function GetExecutive() {
		return vtkAlgorithm_GetExecutive($this->_cPtr);
	}

	function SetExecutive($executive) {
		vtkAlgorithm_SetExecutive($this->_cPtr,$executive);
	}

	function ProcessRequest($request,$inInfo,$outInfo) {
		return vtkAlgorithm_ProcessRequest($this->_cPtr,$request,$inInfo,$outInfo);
	}

	function ComputePipelineMTime($request,$inInfoVec,$outInfoVec,$requestFromOutputPort,$mtime) {
		return vtkAlgorithm_ComputePipelineMTime($this->_cPtr,$request,$inInfoVec,$outInfoVec,$requestFromOutputPort,$mtime);
	}

	function ModifyRequest($request,$when) {
		return vtkAlgorithm_ModifyRequest($this->_cPtr,$request,$when);
	}

	function GetInputPortInformation($port) {
		return vtkAlgorithm_GetInputPortInformation($this->_cPtr,$port);
	}

	function GetOutputPortInformation($port) {
		return vtkAlgorithm_GetOutputPortInformation($this->_cPtr,$port);
	}

	function GetInformation() {
		return vtkAlgorithm_GetInformation($this->_cPtr);
	}

	function SetInformation($arg1) {
		vtkAlgorithm_SetInformation($this->_cPtr,$arg1);
	}

	function GetNumberOfInputPorts() {
		return vtkAlgorithm_GetNumberOfInputPorts($this->_cPtr);
	}

	function GetNumberOfOutputPorts() {
		return vtkAlgorithm_GetNumberOfOutputPorts($this->_cPtr);
	}

	function Register($o) {
		vtkAlgorithm_Register($this->_cPtr,$o);
	}

	function UnRegister($o) {
		vtkAlgorithm_UnRegister($this->_cPtr,$o);
	}

	function SetAbortExecute($_arg) {
		vtkAlgorithm_SetAbortExecute($this->_cPtr,$_arg);
	}

	function GetAbortExecute() {
		return vtkAlgorithm_GetAbortExecute($this->_cPtr);
	}

	function AbortExecuteOn() {
		vtkAlgorithm_AbortExecuteOn($this->_cPtr);
	}

	function AbortExecuteOff() {
		vtkAlgorithm_AbortExecuteOff($this->_cPtr);
	}

	function SetProgress($_arg) {
		vtkAlgorithm_SetProgress($this->_cPtr,$_arg);
	}

	function GetProgress() {
		return vtkAlgorithm_GetProgress($this->_cPtr);
	}

	function UpdateProgress($amount) {
		vtkAlgorithm_UpdateProgress($this->_cPtr,$amount);
	}

	function SetProgressText($ptext) {
		vtkAlgorithm_SetProgressText($this->_cPtr,$ptext);
	}

	function GetProgressText() {
		return vtkAlgorithm_GetProgressText($this->_cPtr);
	}

	function GetErrorCode() {
		return vtkAlgorithm_GetErrorCode($this->_cPtr);
	}

	static function INPUT_IS_OPTIONAL() {
		return vtkAlgorithm_INPUT_IS_OPTIONAL();
	}

	static function INPUT_IS_REPEATABLE() {
		return vtkAlgorithm_INPUT_IS_REPEATABLE();
	}

	static function INPUT_REQUIRED_FIELDS() {
		return vtkAlgorithm_INPUT_REQUIRED_FIELDS();
	}

	static function INPUT_REQUIRED_DATA_TYPE() {
		return vtkAlgorithm_INPUT_REQUIRED_DATA_TYPE();
	}

	static function INPUT_ARRAYS_TO_PROCESS() {
		return vtkAlgorithm_INPUT_ARRAYS_TO_PROCESS();
	}

	static function INPUT_PORT() {
		return vtkAlgorithm_INPUT_PORT();
	}

	static function INPUT_CONNECTION() {
		return vtkAlgorithm_INPUT_CONNECTION();
	}

	function SetInputArrayToProcess($idx,$port_or_info,$connection=null,$fieldAssociation=null,$name_or_fieldAttributeType_or_attributeTypeorName=null) {
		switch (func_num_args()) {
		case 2: vtkAlgorithm_SetInputArrayToProcess($this->_cPtr,$idx,$port_or_info); break;
		case 3: vtkAlgorithm_SetInputArrayToProcess($this->_cPtr,$idx,$port_or_info,$connection); break;
		case 4: vtkAlgorithm_SetInputArrayToProcess($this->_cPtr,$idx,$port_or_info,$connection,$fieldAssociation); break;
		default: vtkAlgorithm_SetInputArrayToProcess($this->_cPtr,$idx,$port_or_info,$connection,$fieldAssociation,$name_or_fieldAttributeType_or_attributeTypeorName);
		}
	}

	function GetInputArrayInformation($idx) {
		return vtkAlgorithm_GetInputArrayInformation($this->_cPtr,$idx);
	}

	function RemoveAllInputs() {
		vtkAlgorithm_RemoveAllInputs($this->_cPtr);
	}

	function GetOutputDataObject($port) {
		$r=vtkAlgorithm_GetOutputDataObject($this->_cPtr,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkDataObject($r);
		}
		return $r;
	}

	function GetInputDataObject($port,$connection) {
		$r=vtkAlgorithm_GetInputDataObject($this->_cPtr,$port,$connection);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkDataObject($r);
		}
		return $r;
	}

	function SetInputConnection($port_or_input,$input=null) {
		switch (func_num_args()) {
		case 1: vtkAlgorithm_SetInputConnection($this->_cPtr,$port_or_input); break;
		default: vtkAlgorithm_SetInputConnection($this->_cPtr,$port_or_input,$input);
		}
	}

	function AddInputConnection($port_or_input,$input=null) {
		switch (func_num_args()) {
		case 1: vtkAlgorithm_AddInputConnection($this->_cPtr,$port_or_input); break;
		default: vtkAlgorithm_AddInputConnection($this->_cPtr,$port_or_input,$input);
		}
	}

	function RemoveInputConnection($port,$input) {
		vtkAlgorithm_RemoveInputConnection($this->_cPtr,$port,$input);
	}

	function GetOutputPort($index=null) {
		switch (func_num_args()) {
		case 0: $r=vtkAlgorithm_GetOutputPort($this->_cPtr); break;
		default: $r=vtkAlgorithm_GetOutputPort($this->_cPtr,$index);
		}
		return $r;
	}

	function GetNumberOfInputConnections($port) {
		return vtkAlgorithm_GetNumberOfInputConnections($this->_cPtr,$port);
	}

	function GetTotalNumberOfInputConnections() {
		return vtkAlgorithm_GetTotalNumberOfInputConnections($this->_cPtr);
	}

	function GetInputConnection($port,$index) {
		return vtkAlgorithm_GetInputConnection($this->_cPtr,$port,$index);
	}

	function Update() {
		vtkAlgorithm_Update($this->_cPtr);
	}

	function UpdateInformation() {
		vtkAlgorithm_UpdateInformation($this->_cPtr);
	}

	function UpdateWholeExtent() {
		vtkAlgorithm_UpdateWholeExtent($this->_cPtr);
	}

	function ConvertTotalInputToPortConnection($ind,$port,$conn) {
		vtkAlgorithm_ConvertTotalInputToPortConnection($this->_cPtr,$ind,$port,$conn);
	}

	function SetReleaseDataFlag($arg1) {
		vtkAlgorithm_SetReleaseDataFlag($this->_cPtr,$arg1);
	}

	function GetReleaseDataFlag() {
		return vtkAlgorithm_GetReleaseDataFlag($this->_cPtr);
	}

	function ReleaseDataFlagOn() {
		vtkAlgorithm_ReleaseDataFlagOn($this->_cPtr);
	}

	function ReleaseDataFlagOff() {
		vtkAlgorithm_ReleaseDataFlagOff($this->_cPtr);
	}

	function UpdateExtentIsEmpty($output_or_pinfo,$extentType=null) {
		switch (func_num_args()) {
		case 1: $r=vtkAlgorithm_UpdateExtentIsEmpty($this->_cPtr,$output_or_pinfo); break;
		default: $r=vtkAlgorithm_UpdateExtentIsEmpty($this->_cPtr,$output_or_pinfo,$extentType);
		}
		return $r;
	}

	static function SetDefaultExecutivePrototype($proto) {
		vtkAlgorithm_SetDefaultExecutivePrototype($proto);
	}

	function ComputePriority() {
		return vtkAlgorithm_ComputePriority($this->_cPtr);
	}

	static function PRESERVES_DATASET() {
		return vtkAlgorithm_PRESERVES_DATASET();
	}

	static function PRESERVES_GEOMETRY() {
		return vtkAlgorithm_PRESERVES_GEOMETRY();
	}

	static function PRESERVES_BOUNDS() {
		return vtkAlgorithm_PRESERVES_BOUNDS();
	}

	static function PRESERVES_TOPOLOGY() {
		return vtkAlgorithm_PRESERVES_TOPOLOGY();
	}

	static function PRESERVES_ATTRIBUTES() {
		return vtkAlgorithm_PRESERVES_ATTRIBUTES();
	}

	static function PRESERVES_RANGES() {
		return vtkAlgorithm_PRESERVES_RANGES();
	}
}

class vtkImageAlgorithm extends vtkAlgorithm {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkAlgorithm::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkAlgorithm::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkAlgorithm::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	function GetOutput($arg1=null) {
		switch (func_num_args()) {
		case 0: $r=vtkImageAlgorithm_GetOutput($this->_cPtr); break;
		default: $r=vtkImageAlgorithm_GetOutput($this->_cPtr,$arg1);
		}
		if (!is_resource($r)) return $r;
		switch (get_resource_type($r)) {
		case '_p_vtkImageData': return new vtkImageData($r);
		default: return new vtkImageData($r);
		}
	}

	function SetOutput($d) {
		vtkImageAlgorithm_SetOutput($this->_cPtr,$d);
	}

	function SetInput($arg1,$arg2=null) {
		switch (func_num_args()) {
		case 1: vtkImageAlgorithm_SetInput($this->_cPtr,$arg1); break;
		default: vtkImageAlgorithm_SetInput($this->_cPtr,$arg1,$arg2);
		}
	}

	function GetInput($port=null) {
		switch (func_num_args()) {
		case 0: $r=vtkImageAlgorithm_GetInput($this->_cPtr); break;
		default: $r=vtkImageAlgorithm_GetInput($this->_cPtr,$port);
		}
		if (!is_resource($r)) return $r;
		switch (get_resource_type($r)) {
		case '_p_vtkDataObject': return new vtkDataObject($r);
		default: return new vtkDataObject($r);
		}
	}

	function GetImageDataInput($port) {
		$r=vtkImageAlgorithm_GetImageDataInput($this->_cPtr,$port);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageData($r);
		}
		return $r;
	}

	function AddInput($arg1,$arg2=null) {
		switch (func_num_args()) {
		case 1: vtkImageAlgorithm_AddInput($this->_cPtr,$arg1); break;
		default: vtkImageAlgorithm_AddInput($this->_cPtr,$arg1,$arg2);
		}
	}
}

class vtkThreadedImageAlgorithm extends vtkImageAlgorithm {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkImageAlgorithm::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkImageAlgorithm::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkImageAlgorithm::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	function ThreadedRequestData($request,$inputVector,$outputVector,$inData,$outData,$extent,$threadId) {
		vtkThreadedImageAlgorithm_ThreadedRequestData($this->_cPtr,$request,$inputVector,$outputVector,$inData,$outData,$extent,$threadId);
	}

	function ThreadedExecute($inData,$outData,$extent,$threadId) {
		vtkThreadedImageAlgorithm_ThreadedExecute($this->_cPtr,$inData,$outData,$extent,$threadId);
	}

	function SetNumberOfThreads($_arg) {
		vtkThreadedImageAlgorithm_SetNumberOfThreads($this->_cPtr,$_arg);
	}

	function GetNumberOfThreads() {
		return vtkThreadedImageAlgorithm_GetNumberOfThreads($this->_cPtr);
	}

	function SplitExtent($splitExt,$startExt,$num,$total) {
		return vtkThreadedImageAlgorithm_SplitExtent($this->_cPtr,$splitExt,$startExt,$num,$total);
	}
}

class vtkImageWriter extends vtkImageAlgorithm {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkImageAlgorithm::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkImageAlgorithm::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkImageAlgorithm::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkImageWriter_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageWriter($r);
		}
		return $r;
	}

	function SetFileName($_arg) {
		vtkImageWriter_SetFileName($this->_cPtr,$_arg);
	}

	function GetFileName() {
		return vtkImageWriter_GetFileName($this->_cPtr);
	}

	function SetFilePrefix($_arg) {
		vtkImageWriter_SetFilePrefix($this->_cPtr,$_arg);
	}

	function GetFilePrefix() {
		return vtkImageWriter_GetFilePrefix($this->_cPtr);
	}

	function SetFilePattern($_arg) {
		vtkImageWriter_SetFilePattern($this->_cPtr,$_arg);
	}

	function GetFilePattern() {
		return vtkImageWriter_GetFilePattern($this->_cPtr);
	}

	function SetFileDimensionality($_arg) {
		vtkImageWriter_SetFileDimensionality($this->_cPtr,$_arg);
	}

	function GetFileDimensionality() {
		return vtkImageWriter_GetFileDimensionality($this->_cPtr);
	}

	function Write() {
		vtkImageWriter_Write($this->_cPtr);
	}

	function DeleteFiles() {
		vtkImageWriter_DeleteFiles($this->_cPtr);
	}
}

class vtkImageReader2 extends vtkImageAlgorithm {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkImageAlgorithm::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkImageAlgorithm::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkImageAlgorithm::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkImageReader2_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageReader2($r);
		}
		return $r;
	}

	function SetFileName($arg1) {
		vtkImageReader2_SetFileName($this->_cPtr,$arg1);
	}

	function GetFileName() {
		return vtkImageReader2_GetFileName($this->_cPtr);
	}

	function SetFileNames($arg1) {
		vtkImageReader2_SetFileNames($this->_cPtr,$arg1);
	}

	function GetFileNames() {
		$r=vtkImageReader2_GetFileNames($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkStringArray($r);
		}
		return $r;
	}

	function SetFilePrefix($arg1) {
		vtkImageReader2_SetFilePrefix($this->_cPtr,$arg1);
	}

	function GetFilePrefix() {
		return vtkImageReader2_GetFilePrefix($this->_cPtr);
	}

	function SetFilePattern($arg1) {
		vtkImageReader2_SetFilePattern($this->_cPtr,$arg1);
	}

	function GetFilePattern() {
		return vtkImageReader2_GetFilePattern($this->_cPtr);
	}

	function SetDataScalarType($type) {
		vtkImageReader2_SetDataScalarType($this->_cPtr,$type);
	}

	function SetDataScalarTypeToFloat() {
		vtkImageReader2_SetDataScalarTypeToFloat($this->_cPtr);
	}

	function SetDataScalarTypeToDouble() {
		vtkImageReader2_SetDataScalarTypeToDouble($this->_cPtr);
	}

	function SetDataScalarTypeToInt() {
		vtkImageReader2_SetDataScalarTypeToInt($this->_cPtr);
	}

	function SetDataScalarTypeToUnsignedInt() {
		vtkImageReader2_SetDataScalarTypeToUnsignedInt($this->_cPtr);
	}

	function SetDataScalarTypeToShort() {
		vtkImageReader2_SetDataScalarTypeToShort($this->_cPtr);
	}

	function SetDataScalarTypeToUnsignedShort() {
		vtkImageReader2_SetDataScalarTypeToUnsignedShort($this->_cPtr);
	}

	function SetDataScalarTypeToChar() {
		vtkImageReader2_SetDataScalarTypeToChar($this->_cPtr);
	}

	function SetDataScalarTypeToSignedChar() {
		vtkImageReader2_SetDataScalarTypeToSignedChar($this->_cPtr);
	}

	function SetDataScalarTypeToUnsignedChar() {
		vtkImageReader2_SetDataScalarTypeToUnsignedChar($this->_cPtr);
	}

	function GetDataScalarType() {
		return vtkImageReader2_GetDataScalarType($this->_cPtr);
	}

	function SetNumberOfScalarComponents($_arg) {
		vtkImageReader2_SetNumberOfScalarComponents($this->_cPtr,$_arg);
	}

	function GetNumberOfScalarComponents() {
		return vtkImageReader2_GetNumberOfScalarComponents($this->_cPtr);
	}

	function GetDataExtent() {
		return vtkImageReader2_GetDataExtent($this->_cPtr);
	}

	function SetFileDimensionality($_arg) {
		vtkImageReader2_SetFileDimensionality($this->_cPtr,$_arg);
	}

	function GetFileDimensionality() {
		return vtkImageReader2_GetFileDimensionality($this->_cPtr);
	}

	function SetDataSpacing($_arg1,$_arg2,$_arg3) {
		vtkImageReader2_SetDataSpacing($this->_cPtr,$_arg1,$_arg2,$_arg3);
	}

	function GetDataSpacing() {
		return vtkImageReader2_GetDataSpacing($this->_cPtr);
	}

	function SetDataOrigin($_arg1,$_arg2,$_arg3) {
		vtkImageReader2_SetDataOrigin($this->_cPtr,$_arg1,$_arg2,$_arg3);
	}

	function GetDataOrigin() {
		return vtkImageReader2_GetDataOrigin($this->_cPtr);
	}

	function GetHeaderSize($slice=null) {
		switch (func_num_args()) {
		case 0: $r=vtkImageReader2_GetHeaderSize($this->_cPtr); break;
		default: $r=vtkImageReader2_GetHeaderSize($this->_cPtr,$slice);
		}
		return $r;
	}

	function SetHeaderSize($size) {
		vtkImageReader2_SetHeaderSize($this->_cPtr,$size);
	}

	function SetDataByteOrderToBigEndian() {
		vtkImageReader2_SetDataByteOrderToBigEndian($this->_cPtr);
	}

	function SetDataByteOrderToLittleEndian() {
		vtkImageReader2_SetDataByteOrderToLittleEndian($this->_cPtr);
	}

	function GetDataByteOrder() {
		return vtkImageReader2_GetDataByteOrder($this->_cPtr);
	}

	function SetDataByteOrder($arg1) {
		vtkImageReader2_SetDataByteOrder($this->_cPtr,$arg1);
	}

	function GetDataByteOrderAsString() {
		return vtkImageReader2_GetDataByteOrderAsString($this->_cPtr);
	}

	function SetFileNameSliceOffset($_arg) {
		vtkImageReader2_SetFileNameSliceOffset($this->_cPtr,$_arg);
	}

	function GetFileNameSliceOffset() {
		return vtkImageReader2_GetFileNameSliceOffset($this->_cPtr);
	}

	function SetFileNameSliceSpacing($_arg) {
		vtkImageReader2_SetFileNameSliceSpacing($this->_cPtr,$_arg);
	}

	function GetFileNameSliceSpacing() {
		return vtkImageReader2_GetFileNameSliceSpacing($this->_cPtr);
	}

	function SetSwapBytes($_arg) {
		vtkImageReader2_SetSwapBytes($this->_cPtr,$_arg);
	}

	function GetSwapBytes() {
		return vtkImageReader2_GetSwapBytes($this->_cPtr);
	}

	function SwapBytesOn() {
		vtkImageReader2_SwapBytesOn($this->_cPtr);
	}

	function SwapBytesOff() {
		vtkImageReader2_SwapBytesOff($this->_cPtr);
	}

	function GetFile() {
		return vtkImageReader2_GetFile($this->_cPtr);
	}

	function GetDataIncrements() {
		return vtkImageReader2_GetDataIncrements($this->_cPtr);
	}

	function OpenFile() {
		return vtkImageReader2_OpenFile($this->_cPtr);
	}

	function SeekFile($i,$j,$k) {
		vtkImageReader2_SeekFile($this->_cPtr,$i,$j,$k);
	}

	function FileLowerLeftOn() {
		vtkImageReader2_FileLowerLeftOn($this->_cPtr);
	}

	function FileLowerLeftOff() {
		vtkImageReader2_FileLowerLeftOff($this->_cPtr);
	}

	function GetFileLowerLeft() {
		return vtkImageReader2_GetFileLowerLeft($this->_cPtr);
	}

	function SetFileLowerLeft($_arg) {
		vtkImageReader2_SetFileLowerLeft($this->_cPtr,$_arg);
	}

	function ComputeInternalFileName($slice) {
		vtkImageReader2_ComputeInternalFileName($this->_cPtr,$slice);
	}

	function GetInternalFileName() {
		return vtkImageReader2_GetInternalFileName($this->_cPtr);
	}

	function CanReadFile($fname) {
		return vtkImageReader2_CanReadFile($this->_cPtr,$fname);
	}

	function GetFileExtensions() {
		return vtkImageReader2_GetFileExtensions($this->_cPtr);
	}

	function GetDescriptiveName() {
		return vtkImageReader2_GetDescriptiveName($this->_cPtr);
	}
}

class vtkMedicalImageReader2 extends vtkImageReader2 {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkImageReader2::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkImageReader2::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkImageReader2::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkMedicalImageReader2_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkMedicalImageReader2($r);
		}
		return $r;
	}

	function GetMedicalImageProperties() {
		$r=vtkMedicalImageReader2_GetMedicalImageProperties($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkMedicalImageProperties($r);
		}
		return $r;
	}

	function SetPatientName($arg1) {
		vtkMedicalImageReader2_SetPatientName($this->_cPtr,$arg1);
	}

	function GetPatientName() {
		return vtkMedicalImageReader2_GetPatientName($this->_cPtr);
	}

	function SetPatientID($arg1) {
		vtkMedicalImageReader2_SetPatientID($this->_cPtr,$arg1);
	}

	function GetPatientID() {
		return vtkMedicalImageReader2_GetPatientID($this->_cPtr);
	}

	function SetDate($arg1) {
		vtkMedicalImageReader2_SetDate($this->_cPtr,$arg1);
	}

	function GetDate() {
		return vtkMedicalImageReader2_GetDate($this->_cPtr);
	}

	function SetSeries($arg1) {
		vtkMedicalImageReader2_SetSeries($this->_cPtr,$arg1);
	}

	function GetSeries() {
		return vtkMedicalImageReader2_GetSeries($this->_cPtr);
	}

	function SetStudy($arg1) {
		vtkMedicalImageReader2_SetStudy($this->_cPtr,$arg1);
	}

	function GetStudy() {
		return vtkMedicalImageReader2_GetStudy($this->_cPtr);
	}

	function SetImageNumber($arg1) {
		vtkMedicalImageReader2_SetImageNumber($this->_cPtr,$arg1);
	}

	function GetImageNumber() {
		return vtkMedicalImageReader2_GetImageNumber($this->_cPtr);
	}

	function SetModality($arg1) {
		vtkMedicalImageReader2_SetModality($this->_cPtr,$arg1);
	}

	function GetModality() {
		return vtkMedicalImageReader2_GetModality($this->_cPtr);
	}
}

class vtkGDCMImageReader extends vtkMedicalImageReader2 {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkMedicalImageReader2::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkMedicalImageReader2::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkMedicalImageReader2::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkGDCMImageReader_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkGDCMImageReader($r);
		}
		return $r;
	}

	function CanReadFile($fname) {
		return vtkGDCMImageReader_CanReadFile($this->_cPtr,$fname);
	}

	function GetFileExtensions() {
		return vtkGDCMImageReader_GetFileExtensions($this->_cPtr);
	}

	function GetDescriptiveName() {
		return vtkGDCMImageReader_GetDescriptiveName($this->_cPtr);
	}

	function GetDirectionCosines() {
		$r=vtkGDCMImageReader_GetDirectionCosines($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkMatrix4x4($r);
		}
		return $r;
	}

	function GetMedicalImageProperties() {
		$r=vtkGDCMImageReader_GetMedicalImageProperties($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkMedicalImageProperties($r);
		}
		return $r;
	}

	function SetMedicalImageProperties($pd) {
		vtkGDCMImageReader_SetMedicalImageProperties($this->_cPtr,$pd);
	}

	function SetFileNames($arg1) {
		vtkGDCMImageReader_SetFileNames($this->_cPtr,$arg1);
	}

	function GetFileNames() {
		$r=vtkGDCMImageReader_GetFileNames($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkStringArray($r);
		}
		return $r;
	}

	function GetLoadOverlays() {
		return vtkGDCMImageReader_GetLoadOverlays($this->_cPtr);
	}

	function SetLoadOverlays($_arg) {
		vtkGDCMImageReader_SetLoadOverlays($this->_cPtr,$_arg);
	}

	function LoadOverlaysOn() {
		vtkGDCMImageReader_LoadOverlaysOn($this->_cPtr);
	}

	function LoadOverlaysOff() {
		vtkGDCMImageReader_LoadOverlaysOff($this->_cPtr);
	}

	function GetLoadIconImage() {
		return vtkGDCMImageReader_GetLoadIconImage($this->_cPtr);
	}

	function SetLoadIconImage($_arg) {
		vtkGDCMImageReader_SetLoadIconImage($this->_cPtr,$_arg);
	}

	function LoadIconImageOn() {
		vtkGDCMImageReader_LoadIconImageOn($this->_cPtr);
	}

	function LoadIconImageOff() {
		vtkGDCMImageReader_LoadIconImageOff($this->_cPtr);
	}

	function GetLossyFlag() {
		return vtkGDCMImageReader_GetLossyFlag($this->_cPtr);
	}

	function SetLossyFlag($_arg) {
		vtkGDCMImageReader_SetLossyFlag($this->_cPtr,$_arg);
	}

	function LossyFlagOn() {
		vtkGDCMImageReader_LossyFlagOn($this->_cPtr);
	}

	function LossyFlagOff() {
		vtkGDCMImageReader_LossyFlagOff($this->_cPtr);
	}

	function GetNumberOfOverlays() {
		return vtkGDCMImageReader_GetNumberOfOverlays($this->_cPtr);
	}

	function GetNumberOfIconImages() {
		return vtkGDCMImageReader_GetNumberOfIconImages($this->_cPtr);
	}

	function GetOverlay($i) {
		$r=vtkGDCMImageReader_GetOverlay($this->_cPtr,$i);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageData($r);
		}
		return $r;
	}

	function GetIconImage() {
		$r=vtkGDCMImageReader_GetIconImage($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageData($r);
		}
		return $r;
	}

	function GetApplyLookupTable() {
		return vtkGDCMImageReader_GetApplyLookupTable($this->_cPtr);
	}

	function SetApplyLookupTable($_arg) {
		vtkGDCMImageReader_SetApplyLookupTable($this->_cPtr,$_arg);
	}

	function ApplyLookupTableOn() {
		vtkGDCMImageReader_ApplyLookupTableOn($this->_cPtr);
	}

	function ApplyLookupTableOff() {
		vtkGDCMImageReader_ApplyLookupTableOff($this->_cPtr);
	}

	function GetApplyYBRToRGB() {
		return vtkGDCMImageReader_GetApplyYBRToRGB($this->_cPtr);
	}

	function SetApplyYBRToRGB($_arg) {
		vtkGDCMImageReader_SetApplyYBRToRGB($this->_cPtr,$_arg);
	}

	function ApplyYBRToRGBOn() {
		vtkGDCMImageReader_ApplyYBRToRGBOn($this->_cPtr);
	}

	function ApplyYBRToRGBOff() {
		vtkGDCMImageReader_ApplyYBRToRGBOff($this->_cPtr);
	}

	function GetImageFormat() {
		return vtkGDCMImageReader_GetImageFormat($this->_cPtr);
	}

	function GetPlanarConfiguration() {
		return vtkGDCMImageReader_GetPlanarConfiguration($this->_cPtr);
	}

	function GetImagePositionPatient() {
		return vtkGDCMImageReader_GetImagePositionPatient($this->_cPtr);
	}

	function GetImageOrientationPatient() {
		return vtkGDCMImageReader_GetImageOrientationPatient($this->_cPtr);
	}

	function GetCurve() {
		$r=vtkGDCMImageReader_GetCurve($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkPolyData($r);
		}
		return $r;
	}

	function SetCurve($pd) {
		vtkGDCMImageReader_SetCurve($this->_cPtr,$pd);
	}

	function GetShift() {
		return vtkGDCMImageReader_GetShift($this->_cPtr);
	}

	function GetScale() {
		return vtkGDCMImageReader_GetScale($this->_cPtr);
	}
}

class vtkGDCMImageWriter extends vtkImageWriter {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkImageWriter::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkImageWriter::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkImageWriter::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkGDCMImageWriter_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkGDCMImageWriter($r);
		}
		return $r;
	}

	function GetMedicalImageProperties() {
		$r=vtkGDCMImageWriter_GetMedicalImageProperties($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkMedicalImageProperties($r);
		}
		return $r;
	}

	function SetMedicalImageProperties($arg1) {
		vtkGDCMImageWriter_SetMedicalImageProperties($this->_cPtr,$arg1);
	}

	function SetFileNames($arg1) {
		vtkGDCMImageWriter_SetFileNames($this->_cPtr,$arg1);
	}

	function GetFileNames() {
		$r=vtkGDCMImageWriter_GetFileNames($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkStringArray($r);
		}
		return $r;
	}

	function GetLossyFlag() {
		return vtkGDCMImageWriter_GetLossyFlag($this->_cPtr);
	}

	function SetLossyFlag($_arg) {
		vtkGDCMImageWriter_SetLossyFlag($this->_cPtr,$_arg);
	}

	function LossyFlagOn() {
		vtkGDCMImageWriter_LossyFlagOn($this->_cPtr);
	}

	function LossyFlagOff() {
		vtkGDCMImageWriter_LossyFlagOff($this->_cPtr);
	}

	function Write() {
		vtkGDCMImageWriter_Write($this->_cPtr);
	}

	function GetFileExtensions() {
		return vtkGDCMImageWriter_GetFileExtensions($this->_cPtr);
	}

	function GetDescriptiveName() {
		return vtkGDCMImageWriter_GetDescriptiveName($this->_cPtr);
	}

	function SetDirectionCosines($matrix) {
		vtkGDCMImageWriter_SetDirectionCosines($this->_cPtr,$matrix);
	}

	function GetDirectionCosines() {
		$r=vtkGDCMImageWriter_GetDirectionCosines($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkMatrix4x4($r);
		}
		return $r;
	}

	function SetDirectionCosinesFromImageOrientationPatient($dircos) {
		vtkGDCMImageWriter_SetDirectionCosinesFromImageOrientationPatient($this->_cPtr,$dircos);
	}

	function SetShift($_arg) {
		vtkGDCMImageWriter_SetShift($this->_cPtr,$_arg);
	}

	function GetShift() {
		return vtkGDCMImageWriter_GetShift($this->_cPtr);
	}

	function SetScale($_arg) {
		vtkGDCMImageWriter_SetScale($this->_cPtr,$_arg);
	}

	function GetScale() {
		return vtkGDCMImageWriter_GetScale($this->_cPtr);
	}

	function GetImageFormat() {
		return vtkGDCMImageWriter_GetImageFormat($this->_cPtr);
	}

	function SetImageFormat($_arg) {
		vtkGDCMImageWriter_SetImageFormat($this->_cPtr,$_arg);
	}

	function FileLowerLeftOn() {
		vtkGDCMImageWriter_FileLowerLeftOn($this->_cPtr);
	}

	function FileLowerLeftOff() {
		vtkGDCMImageWriter_FileLowerLeftOff($this->_cPtr);
	}

	function GetFileLowerLeft() {
		return vtkGDCMImageWriter_GetFileLowerLeft($this->_cPtr);
	}

	function SetFileLowerLeft($_arg) {
		vtkGDCMImageWriter_SetFileLowerLeft($this->_cPtr,$_arg);
	}

	function SetPlanarConfiguration($_arg) {
		vtkGDCMImageWriter_SetPlanarConfiguration($this->_cPtr,$_arg);
	}

	function GetPlanarConfiguration() {
		return vtkGDCMImageWriter_GetPlanarConfiguration($this->_cPtr);
	}

	function SetStudyUID($_arg) {
		vtkGDCMImageWriter_SetStudyUID($this->_cPtr,$_arg);
	}

	function GetStudyUID() {
		return vtkGDCMImageWriter_GetStudyUID($this->_cPtr);
	}

	function SetSeriesUID($_arg) {
		vtkGDCMImageWriter_SetSeriesUID($this->_cPtr,$_arg);
	}

	function GetSeriesUID() {
		return vtkGDCMImageWriter_GetSeriesUID($this->_cPtr);
	}

	const NO_COMPRESSION = 0;

	const JPEG_COMPRESSION = vtkGDCMImageWriter_JPEG_COMPRESSION;

	const JPEG2000_COMPRESSION = vtkGDCMImageWriter_JPEG2000_COMPRESSION;

	const JPEGLS_COMPRESSION = vtkGDCMImageWriter_JPEGLS_COMPRESSION;

	const RLE_COMPRESSION = vtkGDCMImageWriter_RLE_COMPRESSION;

	function SetCompressionType($_arg) {
		vtkGDCMImageWriter_SetCompressionType($this->_cPtr,$_arg);
	}

	function GetCompressionType() {
		return vtkGDCMImageWriter_GetCompressionType($this->_cPtr);
	}
}

class vtkWindowToImageFilter extends vtkAlgorithm {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkAlgorithm::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkAlgorithm::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkAlgorithm::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkWindowToImageFilter_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkWindowToImageFilter($r);
		}
		return $r;
	}

	function SetInput($input) {
		vtkWindowToImageFilter_SetInput($this->_cPtr,$input);
	}

	function GetInput() {
		return vtkWindowToImageFilter_GetInput($this->_cPtr);
	}

	function SetMagnification($_arg) {
		vtkWindowToImageFilter_SetMagnification($this->_cPtr,$_arg);
	}

	function GetMagnification() {
		return vtkWindowToImageFilter_GetMagnification($this->_cPtr);
	}

	function SetFixBoundary($_arg) {
		vtkWindowToImageFilter_SetFixBoundary($this->_cPtr,$_arg);
	}

	function GetFixBoundary() {
		return vtkWindowToImageFilter_GetFixBoundary($this->_cPtr);
	}

	function FixBoundaryOn() {
		vtkWindowToImageFilter_FixBoundaryOn($this->_cPtr);
	}

	function FixBoundaryOff() {
		vtkWindowToImageFilter_FixBoundaryOff($this->_cPtr);
	}

	function ReadFrontBufferOn() {
		vtkWindowToImageFilter_ReadFrontBufferOn($this->_cPtr);
	}

	function ReadFrontBufferOff() {
		vtkWindowToImageFilter_ReadFrontBufferOff($this->_cPtr);
	}

	function GetReadFrontBuffer() {
		return vtkWindowToImageFilter_GetReadFrontBuffer($this->_cPtr);
	}

	function SetReadFrontBuffer($_arg) {
		vtkWindowToImageFilter_SetReadFrontBuffer($this->_cPtr,$_arg);
	}

	function ShouldRerenderOn() {
		vtkWindowToImageFilter_ShouldRerenderOn($this->_cPtr);
	}

	function ShouldRerenderOff() {
		vtkWindowToImageFilter_ShouldRerenderOff($this->_cPtr);
	}

	function SetShouldRerender($_arg) {
		vtkWindowToImageFilter_SetShouldRerender($this->_cPtr,$_arg);
	}

	function GetShouldRerender() {
		return vtkWindowToImageFilter_GetShouldRerender($this->_cPtr);
	}

	function GetViewport() {
		return vtkWindowToImageFilter_GetViewport($this->_cPtr);
	}

	function SetInputBufferType($_arg) {
		vtkWindowToImageFilter_SetInputBufferType($this->_cPtr,$_arg);
	}

	function GetInputBufferType() {
		return vtkWindowToImageFilter_GetInputBufferType($this->_cPtr);
	}

	function SetInputBufferTypeToRGB() {
		vtkWindowToImageFilter_SetInputBufferTypeToRGB($this->_cPtr);
	}

	function SetInputBufferTypeToRGBA() {
		vtkWindowToImageFilter_SetInputBufferTypeToRGBA($this->_cPtr);
	}

	function SetInputBufferTypeToZBuffer() {
		vtkWindowToImageFilter_SetInputBufferTypeToZBuffer($this->_cPtr);
	}

	function GetOutput() {
		$r=vtkWindowToImageFilter_GetOutput($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageData($r);
		}
		return $r;
	}

	function ProcessRequest($arg1,$arg2,$arg3) {
		return vtkWindowToImageFilter_ProcessRequest($this->_cPtr,$arg1,$arg2,$arg3);
	}
}

class vtkImageExport extends vtkImageAlgorithm {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkImageAlgorithm::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkImageAlgorithm::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkImageAlgorithm::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkImageExport_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageExport($r);
		}
		return $r;
	}

	function GetDataMemorySize() {
		return vtkImageExport_GetDataMemorySize($this->_cPtr);
	}

	function GetDataDimensions($ptr=null) {
		switch (func_num_args()) {
		case 0: $r=vtkImageExport_GetDataDimensions($this->_cPtr); break;
		default: $r=vtkImageExport_GetDataDimensions($this->_cPtr,$ptr);
		}
		return $r;
	}

	function GetDataNumberOfScalarComponents() {
		return vtkImageExport_GetDataNumberOfScalarComponents($this->_cPtr);
	}

	function GetDataScalarType() {
		return vtkImageExport_GetDataScalarType($this->_cPtr);
	}

	function GetDataScalarTypeAsString() {
		return vtkImageExport_GetDataScalarTypeAsString($this->_cPtr);
	}

	function GetDataExtent($ptr=null) {
		switch (func_num_args()) {
		case 0: $r=vtkImageExport_GetDataExtent($this->_cPtr); break;
		default: $r=vtkImageExport_GetDataExtent($this->_cPtr,$ptr);
		}
		return $r;
	}

	function GetDataSpacing($ptr=null) {
		switch (func_num_args()) {
		case 0: $r=vtkImageExport_GetDataSpacing($this->_cPtr); break;
		default: $r=vtkImageExport_GetDataSpacing($this->_cPtr,$ptr);
		}
		return $r;
	}

	function GetDataOrigin($ptr=null) {
		switch (func_num_args()) {
		case 0: $r=vtkImageExport_GetDataOrigin($this->_cPtr); break;
		default: $r=vtkImageExport_GetDataOrigin($this->_cPtr,$ptr);
		}
		return $r;
	}

	function GetInput() {
		$r=vtkImageExport_GetInput($this->_cPtr);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageData($r);
		}
		return $r;
	}

	function ImageLowerLeftOn() {
		vtkImageExport_ImageLowerLeftOn($this->_cPtr);
	}

	function ImageLowerLeftOff() {
		vtkImageExport_ImageLowerLeftOff($this->_cPtr);
	}

	function GetImageLowerLeft() {
		return vtkImageExport_GetImageLowerLeft($this->_cPtr);
	}

	function SetImageLowerLeft($_arg) {
		vtkImageExport_SetImageLowerLeft($this->_cPtr,$_arg);
	}

	function SetExportVoidPointer($arg1) {
		vtkImageExport_SetExportVoidPointer($this->_cPtr,$arg1);
	}

	function GetExportVoidPointer() {
		return vtkImageExport_GetExportVoidPointer($this->_cPtr);
	}

	function Export($arg1=null) {
		switch (func_num_args()) {
		case 0: vtkImageExport_Export($this->_cPtr); break;
		default: vtkImageExport_Export($this->_cPtr,$arg1);
		}
	}

	function GetPointerToData() {
		return vtkImageExport_GetPointerToData($this->_cPtr);
	}

	function GetCallbackUserData() {
		return vtkImageExport_GetCallbackUserData($this->_cPtr);
	}

	function GetUpdateInformationCallback() {
		return vtkImageExport_GetUpdateInformationCallback($this->_cPtr);
	}

	function GetPipelineModifiedCallback() {
		return vtkImageExport_GetPipelineModifiedCallback($this->_cPtr);
	}

	function GetWholeExtentCallback() {
		return vtkImageExport_GetWholeExtentCallback($this->_cPtr);
	}

	function GetSpacingCallback() {
		return vtkImageExport_GetSpacingCallback($this->_cPtr);
	}

	function GetOriginCallback() {
		return vtkImageExport_GetOriginCallback($this->_cPtr);
	}

	function GetScalarTypeCallback() {
		return vtkImageExport_GetScalarTypeCallback($this->_cPtr);
	}

	function GetNumberOfComponentsCallback() {
		return vtkImageExport_GetNumberOfComponentsCallback($this->_cPtr);
	}

	function GetPropagateUpdateExtentCallback() {
		return vtkImageExport_GetPropagateUpdateExtentCallback($this->_cPtr);
	}

	function GetUpdateDataCallback() {
		return vtkImageExport_GetUpdateDataCallback($this->_cPtr);
	}

	function GetDataExtentCallback() {
		return vtkImageExport_GetDataExtentCallback($this->_cPtr);
	}

	function GetBufferPointerCallback() {
		return vtkImageExport_GetBufferPointerCallback($this->_cPtr);
	}
}

class vtkImageImport extends vtkImageAlgorithm {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkImageAlgorithm::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkImageAlgorithm::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkImageAlgorithm::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkImageImport_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageImport($r);
		}
		return $r;
	}

	function CopyImportVoidPointer($ptr,$size) {
		vtkImageImport_CopyImportVoidPointer($this->_cPtr,$ptr,$size);
	}

	function GetImportVoidPointer() {
		return vtkImageImport_GetImportVoidPointer($this->_cPtr);
	}

	function SetImportVoidPointer($ptr,$save=null) {
		switch (func_num_args()) {
		case 1: vtkImageImport_SetImportVoidPointer($this->_cPtr,$ptr); break;
		default: vtkImageImport_SetImportVoidPointer($this->_cPtr,$ptr,$save);
		}
	}

	function SetDataScalarType($_arg) {
		vtkImageImport_SetDataScalarType($this->_cPtr,$_arg);
	}

	function SetDataScalarTypeToDouble() {
		vtkImageImport_SetDataScalarTypeToDouble($this->_cPtr);
	}

	function SetDataScalarTypeToFloat() {
		vtkImageImport_SetDataScalarTypeToFloat($this->_cPtr);
	}

	function SetDataScalarTypeToInt() {
		vtkImageImport_SetDataScalarTypeToInt($this->_cPtr);
	}

	function SetDataScalarTypeToShort() {
		vtkImageImport_SetDataScalarTypeToShort($this->_cPtr);
	}

	function SetDataScalarTypeToUnsignedShort() {
		vtkImageImport_SetDataScalarTypeToUnsignedShort($this->_cPtr);
	}

	function SetDataScalarTypeToUnsignedChar() {
		vtkImageImport_SetDataScalarTypeToUnsignedChar($this->_cPtr);
	}

	function GetDataScalarType() {
		return vtkImageImport_GetDataScalarType($this->_cPtr);
	}

	function GetDataScalarTypeAsString() {
		return vtkImageImport_GetDataScalarTypeAsString($this->_cPtr);
	}

	function SetNumberOfScalarComponents($_arg) {
		vtkImageImport_SetNumberOfScalarComponents($this->_cPtr,$_arg);
	}

	function GetNumberOfScalarComponents() {
		return vtkImageImport_GetNumberOfScalarComponents($this->_cPtr);
	}

	function GetDataExtent() {
		return vtkImageImport_GetDataExtent($this->_cPtr);
	}

	function SetDataExtentToWholeExtent() {
		vtkImageImport_SetDataExtentToWholeExtent($this->_cPtr);
	}

	function SetDataSpacing($_arg1,$_arg2,$_arg3) {
		vtkImageImport_SetDataSpacing($this->_cPtr,$_arg1,$_arg2,$_arg3);
	}

	function GetDataSpacing() {
		return vtkImageImport_GetDataSpacing($this->_cPtr);
	}

	function SetDataOrigin($_arg1,$_arg2,$_arg3) {
		vtkImageImport_SetDataOrigin($this->_cPtr,$_arg1,$_arg2,$_arg3);
	}

	function GetDataOrigin() {
		return vtkImageImport_GetDataOrigin($this->_cPtr);
	}

	function GetWholeExtent() {
		return vtkImageImport_GetWholeExtent($this->_cPtr);
	}

	function RequestUpdateExtent($request,$inputVector,$outputVector) {
		return vtkImageImport_RequestUpdateExtent($this->_cPtr,$request,$inputVector,$outputVector);
	}

	function SetScalarArrayName($_arg) {
		vtkImageImport_SetScalarArrayName($this->_cPtr,$_arg);
	}

	function GetScalarArrayName() {
		return vtkImageImport_GetScalarArrayName($this->_cPtr);
	}

	function SetUpdateInformationCallback($_arg) {
		vtkImageImport_SetUpdateInformationCallback($this->_cPtr,$_arg);
	}

	function GetUpdateInformationCallback() {
		return vtkImageImport_GetUpdateInformationCallback($this->_cPtr);
	}

	function SetPipelineModifiedCallback($_arg) {
		vtkImageImport_SetPipelineModifiedCallback($this->_cPtr,$_arg);
	}

	function GetPipelineModifiedCallback() {
		return vtkImageImport_GetPipelineModifiedCallback($this->_cPtr);
	}

	function SetWholeExtentCallback($_arg) {
		vtkImageImport_SetWholeExtentCallback($this->_cPtr,$_arg);
	}

	function GetWholeExtentCallback() {
		return vtkImageImport_GetWholeExtentCallback($this->_cPtr);
	}

	function SetSpacingCallback($_arg) {
		vtkImageImport_SetSpacingCallback($this->_cPtr,$_arg);
	}

	function GetSpacingCallback() {
		return vtkImageImport_GetSpacingCallback($this->_cPtr);
	}

	function SetOriginCallback($_arg) {
		vtkImageImport_SetOriginCallback($this->_cPtr,$_arg);
	}

	function GetOriginCallback() {
		return vtkImageImport_GetOriginCallback($this->_cPtr);
	}

	function SetScalarTypeCallback($_arg) {
		vtkImageImport_SetScalarTypeCallback($this->_cPtr,$_arg);
	}

	function GetScalarTypeCallback() {
		return vtkImageImport_GetScalarTypeCallback($this->_cPtr);
	}

	function SetNumberOfComponentsCallback($_arg) {
		vtkImageImport_SetNumberOfComponentsCallback($this->_cPtr,$_arg);
	}

	function GetNumberOfComponentsCallback() {
		return vtkImageImport_GetNumberOfComponentsCallback($this->_cPtr);
	}

	function SetPropagateUpdateExtentCallback($_arg) {
		vtkImageImport_SetPropagateUpdateExtentCallback($this->_cPtr,$_arg);
	}

	function GetPropagateUpdateExtentCallback() {
		return vtkImageImport_GetPropagateUpdateExtentCallback($this->_cPtr);
	}

	function SetUpdateDataCallback($_arg) {
		vtkImageImport_SetUpdateDataCallback($this->_cPtr,$_arg);
	}

	function GetUpdateDataCallback() {
		return vtkImageImport_GetUpdateDataCallback($this->_cPtr);
	}

	function SetDataExtentCallback($_arg) {
		vtkImageImport_SetDataExtentCallback($this->_cPtr,$_arg);
	}

	function GetDataExtentCallback() {
		return vtkImageImport_GetDataExtentCallback($this->_cPtr);
	}

	function SetBufferPointerCallback($_arg) {
		vtkImageImport_SetBufferPointerCallback($this->_cPtr,$_arg);
	}

	function GetBufferPointerCallback() {
		return vtkImageImport_GetBufferPointerCallback($this->_cPtr);
	}

	function SetCallbackUserData($_arg) {
		vtkImageImport_SetCallbackUserData($this->_cPtr,$_arg);
	}

	function GetCallbackUserData() {
		return vtkImageImport_GetCallbackUserData($this->_cPtr);
	}

	function InvokePipelineModifiedCallbacks() {
		return vtkImageImport_InvokePipelineModifiedCallbacks($this->_cPtr);
	}

	function InvokeUpdateInformationCallbacks() {
		vtkImageImport_InvokeUpdateInformationCallbacks($this->_cPtr);
	}

	function InvokeExecuteInformationCallbacks() {
		vtkImageImport_InvokeExecuteInformationCallbacks($this->_cPtr);
	}

	function InvokeExecuteDataCallbacks() {
		vtkImageImport_InvokeExecuteDataCallbacks($this->_cPtr);
	}

	function LegacyCheckWholeExtent() {
		vtkImageImport_LegacyCheckWholeExtent($this->_cPtr);
	}
}

class vtkImageCast extends vtkThreadedImageAlgorithm {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkThreadedImageAlgorithm::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkThreadedImageAlgorithm::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkThreadedImageAlgorithm::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkImageCast_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageCast($r);
		}
		return $r;
	}

	function SetOutputScalarType($_arg) {
		vtkImageCast_SetOutputScalarType($this->_cPtr,$_arg);
	}

	function GetOutputScalarType() {
		return vtkImageCast_GetOutputScalarType($this->_cPtr);
	}

	function SetOutputScalarTypeToFloat() {
		vtkImageCast_SetOutputScalarTypeToFloat($this->_cPtr);
	}

	function SetOutputScalarTypeToDouble() {
		vtkImageCast_SetOutputScalarTypeToDouble($this->_cPtr);
	}

	function SetOutputScalarTypeToInt() {
		vtkImageCast_SetOutputScalarTypeToInt($this->_cPtr);
	}

	function SetOutputScalarTypeToUnsignedInt() {
		vtkImageCast_SetOutputScalarTypeToUnsignedInt($this->_cPtr);
	}

	function SetOutputScalarTypeToLong() {
		vtkImageCast_SetOutputScalarTypeToLong($this->_cPtr);
	}

	function SetOutputScalarTypeToUnsignedLong() {
		vtkImageCast_SetOutputScalarTypeToUnsignedLong($this->_cPtr);
	}

	function SetOutputScalarTypeToShort() {
		vtkImageCast_SetOutputScalarTypeToShort($this->_cPtr);
	}

	function SetOutputScalarTypeToUnsignedShort() {
		vtkImageCast_SetOutputScalarTypeToUnsignedShort($this->_cPtr);
	}

	function SetOutputScalarTypeToUnsignedChar() {
		vtkImageCast_SetOutputScalarTypeToUnsignedChar($this->_cPtr);
	}

	function SetOutputScalarTypeToChar() {
		vtkImageCast_SetOutputScalarTypeToChar($this->_cPtr);
	}

	function SetClampOverflow($_arg) {
		vtkImageCast_SetClampOverflow($this->_cPtr,$_arg);
	}

	function GetClampOverflow() {
		return vtkImageCast_GetClampOverflow($this->_cPtr);
	}

	function ClampOverflowOn() {
		vtkImageCast_ClampOverflowOn($this->_cPtr);
	}

	function ClampOverflowOff() {
		vtkImageCast_ClampOverflowOff($this->_cPtr);
	}
}

abstract class vtkVolumeReader extends vtkImageAlgorithm {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkImageAlgorithm::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkImageAlgorithm::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkImageAlgorithm::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	function SetFilePrefix($_arg) {
		vtkVolumeReader_SetFilePrefix($this->_cPtr,$_arg);
	}

	function GetFilePrefix() {
		return vtkVolumeReader_GetFilePrefix($this->_cPtr);
	}

	function SetFilePattern($_arg) {
		vtkVolumeReader_SetFilePattern($this->_cPtr,$_arg);
	}

	function GetFilePattern() {
		return vtkVolumeReader_GetFilePattern($this->_cPtr);
	}

	function SetImageRange($_arg1,$_arg2) {
		vtkVolumeReader_SetImageRange($this->_cPtr,$_arg1,$_arg2);
	}

	function GetImageRange() {
		return vtkVolumeReader_GetImageRange($this->_cPtr);
	}

	function SetDataSpacing($_arg1,$_arg2,$_arg3) {
		vtkVolumeReader_SetDataSpacing($this->_cPtr,$_arg1,$_arg2,$_arg3);
	}

	function GetDataSpacing() {
		return vtkVolumeReader_GetDataSpacing($this->_cPtr);
	}

	function SetDataOrigin($_arg1,$_arg2,$_arg3) {
		vtkVolumeReader_SetDataOrigin($this->_cPtr,$_arg1,$_arg2,$_arg3);
	}

	function GetDataOrigin() {
		return vtkVolumeReader_GetDataOrigin($this->_cPtr);
	}

	function GetImage($ImageNumber) {
		$r=vtkVolumeReader_GetImage($this->_cPtr,$ImageNumber);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageData($r);
		}
		return $r;
	}
}

class vtkVolume16Reader extends vtkVolumeReader {
	public $_cPtr=null;

	function __set($var,$value) {
		if ($var === 'thisown') return swig_vtkgdcm_alter_newobject($this->_cPtr,$value);
		vtkVolumeReader::__set($var,$value);
	}

	function __isset($var) {
		if ($var === 'thisown') return true;
		return vtkVolumeReader::__isset($var);
	}

	function __get($var) {
		if ($var === 'thisown') return swig_vtkgdcm_get_newobject($this->_cPtr);
		return vtkVolumeReader::__get($var);
	}
	function __construct($h) {
		$this->_cPtr=$h;
	}

	static function c_New() {
		$r=vtkVolume16Reader_c_New();
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkVolume16Reader($r);
		}
		return $r;
	}

	function SetDataDimensions($_arg1,$_arg2) {
		vtkVolume16Reader_SetDataDimensions($this->_cPtr,$_arg1,$_arg2);
	}

	function GetDataDimensions() {
		return vtkVolume16Reader_GetDataDimensions($this->_cPtr);
	}

	function SetDataMask($_arg) {
		vtkVolume16Reader_SetDataMask($this->_cPtr,$_arg);
	}

	function GetDataMask() {
		return vtkVolume16Reader_GetDataMask($this->_cPtr);
	}

	function SetHeaderSize($_arg) {
		vtkVolume16Reader_SetHeaderSize($this->_cPtr,$_arg);
	}

	function GetHeaderSize() {
		return vtkVolume16Reader_GetHeaderSize($this->_cPtr);
	}

	function SetDataByteOrderToBigEndian() {
		vtkVolume16Reader_SetDataByteOrderToBigEndian($this->_cPtr);
	}

	function SetDataByteOrderToLittleEndian() {
		vtkVolume16Reader_SetDataByteOrderToLittleEndian($this->_cPtr);
	}

	function GetDataByteOrder() {
		return vtkVolume16Reader_GetDataByteOrder($this->_cPtr);
	}

	function SetDataByteOrder($arg1) {
		vtkVolume16Reader_SetDataByteOrder($this->_cPtr,$arg1);
	}

	function GetDataByteOrderAsString() {
		return vtkVolume16Reader_GetDataByteOrderAsString($this->_cPtr);
	}

	function SetSwapBytes($_arg) {
		vtkVolume16Reader_SetSwapBytes($this->_cPtr,$_arg);
	}

	function GetSwapBytes() {
		return vtkVolume16Reader_GetSwapBytes($this->_cPtr);
	}

	function SwapBytesOn() {
		vtkVolume16Reader_SwapBytesOn($this->_cPtr);
	}

	function SwapBytesOff() {
		vtkVolume16Reader_SwapBytesOff($this->_cPtr);
	}

	function SetTransform($arg1) {
		vtkVolume16Reader_SetTransform($this->_cPtr,$arg1);
	}

	function GetTransform() {
		return vtkVolume16Reader_GetTransform($this->_cPtr);
	}

	function GetImage($ImageNumber) {
		$r=vtkVolume16Reader_GetImage($this->_cPtr,$ImageNumber);
		if (is_resource($r)) {
			$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));
			if (class_exists($c)) return new $c($r);
			return new vtkImageData($r);
		}
		return $r;
	}
}


?>