Update version to 1.3

85 files changed, 13354 insertions, 0 deletions

diff --git a/matlab/algorithms/DART/DARTalgorithm.m b/matlab/algorithms/DART/DARTalgorithm.m
new file mode 100644
index 0000000..b7e63b5
--- /dev/null
+++ b/matlab/algorithms/DART/DARTalgorithm.m
@@ -0,0 +1,229 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef DARTalgorithm < matlab.mixin.Copyable
+
+	% Algorithm class for Discrete Algebraic Reconstruction Technique (DART).
+	
+	% todo: reset()
+	% todo: fixed random seed
+	% todo: initialize from settings (?)
+
+	%----------------------------------------------------------------------
+	properties (GetAccess=public, SetAccess=public)
+	
+		tomography		= TomographyDefault();		% POLICY: Tomography object. 
+		segmentation	= SegmentationDefault();	% POLICY: Segmentation object. 
+		smoothing		= SmoothingDefault();		% POLICY: Smoothing object.
+		masking			= MaskingDefault();			% POLICY: Masking object.
+		output			= OutputDefault();			% POLICY: Output object.
+		statistics		= StatisticsDefault();		% POLICY: Statistics object.
+
+		base			= struct();					% DATA(set): base structure, should contain: 'sinogram', 'proj_geom', 'phantom' (optional).
+		
+		memory			= 'yes';					% SETTING: reduce memory usage? (disables some features)
+		
+		testdata = struct();
+		
+	end
+	%----------------------------------------------------------------------
+	properties (GetAccess=public, SetAccess=private)
+		V0					= [];			% DATA(get): Initial reconstruction.
+		V					= [];			% DATA(get): Reconstruction.
+		S					= [];			% DATA(get): Segmentation.
+		R					= [];			% DATA(get): Residual projection data.
+		Mask				= [];			% DATA(get): Reconstruction Mask.
+		stats				= struct();		% Structure containing various statistics.
+		iterationcount		= 0;			% Number of performed iterations.	
+		start_tic			= 0;		  
+		initialized			= 0;			% Is initialized?
+	end
+	%----------------------------------------------------------------------
+	properties (Access=private)		
+		adaptparam_name		= {};
+		adaptparam_values	= {};
+		adaptparam_iters	= {};
+	end
+	
+	%----------------------------------------------------------------------
+	methods
+		
+		%------------------------------------------------------------------
+		function this = DARTalgorithm(base)
+			% Constructor
+			% >> D = DARTalgorithm(base); base is a matlab struct (or the path towards one) 
+			%					          that should contain 'sinogram', 'proj_geom'.
+
+			if ischar(base)
+				this.base = load(base);
+			else
+				this.base = base;
+			end
+		end	
+	
+		
+		%------------------------------------------------------------------
+		function D = deepcopy(this)
+			% Create a deep copy of this object.
+			% >> D2 = D.deepcopy();
+			
+			D = copy(this);
+			props = properties(this);
+			for i = 1:length(props)
+				if isa(this.(props{i}), 'handle')
+					D.(props{i}) = copy(this.(props{i}));
+				end
+			end			
+	
+		end
+		
+		%------------------------------------------------------------------
+		function this = initialize(this)
+			% Initializes this object.
+			% >> D.initialize();
+			
+			% Initialize tomography part
+			this.tomography.initialize(this);
+
+			% Create an Initial Reconstruction
+			if isfield(this.base, 'V0')
+				this.V0 = this.base.V0;
+			else
+				this.output.pre_initial_iteration(this);
+				this.V0 = this.tomography.createInitialReconstruction(this, this.base.sinogram);
+				this.output.post_initial_iteration(this);
+			end
+			this.V = this.V0;
+			if strcmp(this.memory,'yes')
+				this.base.V0 = [];
+				this.V0 = [];
+			end
+			this.initialized = 1;
+		end		
+		
+		%------------------------------------------------------------------
+		% iterate
+		function this = iterate(this, iters)
+			% Perform several iterations of the DART algorithm.
+			% >> D.iterate(iterations);			
+			
+			this.start_tic = tic;
+			
+			for iteration = 1:iters
+				
+				this.iterationcount = this.iterationcount + 1;				
+		
+				%----------------------------------------------------------
+				% Initial Output
+				this.output.pre_iteration(this);
+
+				%----------------------------------------------------------
+				% Update Adaptive Parameters
+				for i = 1:numel(this.adaptparam_name)
+					
+					for j = 1:numel(this.adaptparam_iters{i})
+						if this.iterationcount == this.adaptparam_iters{i}(j)
+							new_value = this.adaptparam_values{i}(j);
+							eval(['this.' this.adaptparam_name{i} ' = ' num2str(new_value) ';']);
+							disp(['value ' this.adaptparam_name{i} ' changed to ' num2str(new_value) ]);
+						end						
+					end
+				
+				end
+
+				%----------------------------------------------------------
+				% Segmentation
+				this.segmentation.estimate_grey_levels(this, this.V);
+				this.S = this.segmentation.apply(this, this.V);
+
+				%----------------------------------------------------------
+				% Select Update and Fixed Pixels
+				this.Mask = this.masking.apply(this, this.S);
+
+				this.V = (this.V .* this.Mask) + (this.S .* (1 - this.Mask));
+				%this.V(this.Mask == 0) = this.S(this.Mask == 0); 
+
+				F = this.V;
+				F(this.Mask == 1) = 0;
+
+				%----------------------------------------------------------
+				% Create Residual Projection Difference
+				%this.testdata.F{iteration} = F;
+				this.R = this.base.sinogram - this.tomography.createForwardProjection(this, F);
+				%this.testdata.R{iteration} = this.R;
+				
+				%----------------------------------------------------------
+				% ART Loose Part
+				%this.testdata.V1{iteration} = this.V;
+				%this.testdata.Mask{iteration} = this.Mask;
+				
+				%X = zeros(size(this.V));
+				%Y = this.tomography.createReconstruction(this, this.R, X, this.Mask);
+				%this.V(this.Mask) = Y(this.Mask);
+				this.V = this.tomography.createReconstruction(this, this.R, this.V, this.Mask);
+				
+				%this.testdata.V2{iteration} = this.V;
+				
+				%----------------------------------------------------------
+				% Blur
+				this.V = this.smoothing.apply(this, this.V);
+				%this.testdata.V3{iteration} = this.V;
+				
+				%----------------------------------------------------------
+				% Calculate Statistics
+				this.stats = this.statistics.apply(this);
+
+				%----------------------------------------------------------
+				% Output
+				this.output.post_iteration(this);
+			
+			end % end iteration loop
+			
+			%test = this.testdata;
+			%save('testdata.mat','test');
+		
+		end				
+
+		%------------------------------------------------------------------
+		% get data		
+		function data = getdata(this, string)
+			if numel(this.(string)) == 1
+				data = astra_mex_data2d('get',this.(string));
+			else
+				data = this.(string);
+			end
+		end
+		
+		%------------------------------------------------------------------
+		% add adaptive parameter
+		function this = adaptiveparameter(this, name, values, iterations)
+			this.adaptparam_name{end+1} = name;
+			this.adaptparam_values{end+1} = values;
+			this.adaptparam_iters{end+1} = iterations;
+		end	
+		
+		%------------------------------------------------------------------
+		function settings = getsettings(this)
+			% Returns a structure containing all settings of this object.
+			% >> settings = tomography.getsettings();		
+			
+			settings.tomography = this.tomography.getsettings();
+			settings.smoothing = this.smoothing.getsettings();
+			settings.masking = this.masking.getsettings();
+			settings.segmentation = this.segmentation.getsettings();
+		end		
+		%------------------------------------------------------------------
+		
+	end % methods
+		
+end % class
+
+
diff --git a/matlab/algorithms/DART/IterativeTomography.m b/matlab/algorithms/DART/IterativeTomography.m
new file mode 100644
index 0000000..b30640e
--- /dev/null
+++ b/matlab/algorithms/DART/IterativeTomography.m
@@ -0,0 +1,455 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef IterativeTomography < matlab.mixin.Copyable
+
+	% Algorithm class for 2D Iterative Tomography.
+
+	%----------------------------------------------------------------------
+	properties (SetAccess=public, GetAccess=public)				
+		superresolution		= 1;				% SETTING: Volume upsampling factor.
+		proj_type			= 'linear';			% SETTING: Projector type, only when gpu='no'.
+		method				= 'SIRT_CUDA';		% SETTING: Iterative method (see ASTRA toolbox documentation).
+		gpu					= 'yes';			% SETTING: Use gpu? {'yes', 'no'}
+		gpu_core			= 0;				% SETTING: Which gpu core to use? Only when gpu='yes'.
+		inner_circle		= 'yes';			% SETTING: Do roi only? {'yes', 'no'}
+		image_size			= [];				% SETTING: Overwrite default reconstruction size.  Only if no vol_geom is specified.
+		use_minc			= 'no';				% SETTING: Use minimum constraint. {'no', 'yes'}
+	end
+	%----------------------------------------------------------------------
+	properties (SetAccess=public, GetAccess=public)	
+		sinogram			= [];				% DATA: Projection data.
+		proj_geom			= [];				% DATA: Projection geometry.
+		V					= [];				% DATA: Volume data.  Also used to set initial estimate (optional).
+		vol_geom			= [];				% DATA: Volume geometry.
+	end
+	%----------------------------------------------------------------------
+	properties (SetAccess=private, GetAccess=public)
+		initialized     	= 0;				% Is this object initialized?
+	end
+	%----------------------------------------------------------------------
+	properties (SetAccess=protected, GetAccess=protected)
+		proj_geom_sr		= [];				% PROTECTED: geometry of sinogram (with super-resolution)
+        proj_id             = [];				% PROTECTED: astra id of projector (when gpu='no')
+        proj_id_sr          = [];				% PROTECTED: astra id of super-resolution projector (when gpu='no')	
+		cfg_base			= struct();			% PROTECTED: base configuration structure for the reconstruction algorithm.
+    end
+	%----------------------------------------------------------------------
+
+	methods (Access=public)
+		
+		%------------------------------------------------------------------
+		function this = IterativeTomography(varargin)
+			% Constructor
+			% >> tomography = IterativeTomography(); 
+			% >> tomography = IterativeTomography(base); base struct should contain fields 'sinogram' and 'proj_geom'.
+			% >> tomography = IterativeTomography(base_filename); mat-file should contain 'sinogram' and 'proj_geom'.
+			% >> tomography = IterativeTomography(proj_geom, vol_geom);
+			% >> tomography = IterativeTomography(sinogram, proj_geom);
+			
+			% Input: IterativeTomography(base)
+			if nargin == 1
+				if ischar(varargin{1})
+					this.sinogram = load(varargin{1},'sinogram');
+					this.proj_geom = load(varargin{1},'proj_geom');				
+				else
+					this.sinogram = varargin{1}.sinogram;
+					this.proj_geom = varargin{1}.proj_geom;
+				end
+			end
+			% Input: IterativeTomography(proj_geom, vol_geom)
+			if nargin == 2 && isstruct(varargin{1}) && isstruct(varargin{2})
+				this.proj_geom = varargin{1};
+				this.vol_geom =	varargin{2};
+			% Input: IterativeTomography(sinogram, proj_geom)
+			elseif nargin == 2
+				this.sinogram = varargin{1};
+				this.proj_geom = varargin{2};
+			end		
+
+		end
+
+		%------------------------------------------------------------------
+		function delete(this)
+			% Destructor
+			% >> clear tomography;
+			if strcmp(this.gpu,'no') && numel(this.proj_id) > 0
+				astra_mex_projector('delete', this.proj_id, this.proj_id_sr);
+			end
+		end
+			
+		%------------------------------------------------------------------
+		function settings = getsettings(this)
+			% Returns a structure containing all settings of this object.
+			% >> settings = tomography.getsettings();
+			settings.superresolution	= this.superresolution;
+			settings.proj_type			= this.proj_type;
+			settings.method				= this.method;
+			settings.gpu				= this.gpu;
+			settings.gpu_core			= this.gpu_core;
+			settings.inner_circle		= this.inner_circle;
+			settings.image_size			= this.image_size;	
+			settings.use_minc			= this.use_minc;
+		end		
+		
+		%------------------------------------------------------------------
+		function ok = initialize(this)
+			% Initialize this object.  Returns 1 if succesful.
+			% >> tomography.initialize();
+			
+			% create projection geometry with super-resolution
+			this.proj_geom_sr = astra_geom_superresolution(this.proj_geom, this.superresolution);			
+			
+			% if no volume geometry is specified by the user: create volume geometry
+			if numel(this.vol_geom) == 0
+				if numel(this.image_size) < 2
+					this.image_size(1) = this.proj_geom.DetectorCount;
+					this.image_size(2) = this.proj_geom.DetectorCount;
+				end
+				this.vol_geom = astra_create_vol_geom(this.image_size(1) * this.superresolution, this.image_size(2) * this.superresolution, ...
+													 -this.image_size(1)/2, this.image_size(1)/2, -this.image_size(2)/2, this.image_size(2)/2);
+			else
+				this.image_size(1) = this.vol_geom.GridRowCount;
+				this.image_size(2) = this.vol_geom.GridColCount;
+			end
+			
+			% create projector
+			if strcmp(this.gpu, 'no')
+				this.proj_id = astra_create_projector(this.proj_type, this.proj_geom, this.vol_geom);
+				this.proj_id_sr = astra_create_projector(this.proj_type, this.proj_geom_sr, this.vol_geom);			
+			end
+			
+			% create reconstruction configuration
+			this.cfg_base = astra_struct(upper(this.method));
+			if strcmp(this.gpu,'no')
+				this.cfg_base.ProjectorId = this.proj_id;
+				this.cfg_base.ProjectionGeometry = this.proj_geom;
+				this.cfg_base.ReconstructionGeometry = this.vol_geom;
+				this.cfg_base.option.ProjectionOrder = 'random';
+			end
+			this.cfg_base.option.DetectorSuperSampling = this.superresolution;
+			%this.cfg_base.option.DetectorSuperSampling = 8;
+			if strcmp(this.gpu,'yes')
+				this.cfg_base.option.GPUindex = this.gpu_core;
+			end
+			this.cfg_base.option.UseMinConstraint = this.use_minc;
+		
+			this.initialized = 1;
+			ok = this.initialized;
+		end
+		
+		%------------------------------------------------------------------
+		function P = project(this, volume)
+			% Compute forward projection.  
+			% Stores sinogram in tomography.sinogram if it is still empty.
+			% >> P = tomography.project();   projects 'tomography.V'.
+			% >> P = tomography.project(volume);   projects 'volume'.
+			
+			if ~this.initialized 
+				this.initialize();
+			end
+			
+			if nargin == 1 % tomography.project();
+				P = this.project_c(this.V);
+			
+			elseif nargin == 2 % tomography.project(volume); 
+				P = this.project_c(volume);
+			end
+			
+			% store
+			if numel(this.sinogram) == 0
+				this.sinogram = P;
+			end
+		end
+		
+		%------------------------------------------------------------------
+		function V = reconstruct(this, iterations)
+			% Compute reconstruction.
+			% Uses tomography.sinogram
+			% Initial solution (if available) should be stored in tomography.V  
+			% >> V = tomography.reconstruct(iterations);
+			
+			if ~this.initialized 
+				this.initialize();
+			end			
+			
+			this.V = this.reconstruct_c(this.sinogram, this.V, [], iterations);
+			if strcmp(this.inner_circle,'yes')
+				this.V = this.selectROI(this.V);
+			end
+			V = this.V;
+		end
+
+		%------------------------------------------------------------------
+		function I = reconstructMask(this, mask, iterations)
+			% Compute reconstruction with mask.
+			% Uses tomography.sinogram  
+			% Initial solution (if available) should be stored in tomography.V  
+			% >> V = tomography.reconstructMask(mask, iterations);			
+			
+			if ~this.initialized 
+				this.initialize();
+			end
+			
+			if strcmp(this.inner_circle,'yes')
+				mask = this.selectROI(mask);
+			end
+			I = this.reconstruct_c(this.sinogram, this.V, mask, iterations);
+		end	
+		%------------------------------------------------------------------
+	
+	end
+	
+	%----------------------------------------------------------------------
+	methods (Access = protected)
+	
+		%------------------------------------------------------------------
+		% Protected function: create FP
+		function sinogram = project_c(this, volume)
+			
+			if this.initialized == 0
+				error('IterativeTomography not initialized');
+			end
+            
+			% data is stored in astra memory
+			if numel(volume) == 1
+				
+				if strcmp(this.gpu, 'yes')
+					sinogram_tmp = astra_create_sino_cuda(volume, this.proj_geom_sr, this.vol_geom, this.gpu_core);
+				else
+					sinogram_tmp = astra_create_sino(volume, this.proj_id);
+				end
+				
+				% sinogram downsampling
+				if this.superresolution > 1
+					sinogram_data = astra_mex_data2d('get', sinogram_tmp);
+					astra_mex_data2d('delete', sinogram_tmp);
+					sinogram_data = downsample_sinogram(sinogram_data, this.superresolution);	
+					%if strcmp(this.proj_geom.type,'fanflat_vec') || strcmp(this.proj_geom.type,'fanflat')
+					%	sinogram = sinogram / this.superresolution;
+					%end
+					sinogram = astra_mex_data2d('create','sino', this.proj_geom, sinogram_data);
+				else
+					sinogram = sinogram_tmp;
+				end
+				
+			% data is stored in matlab memory	
+			else
+			
+				% 2D and 3D slice by slice
+				sinogram_tmp = zeros([astra_geom_size(this.proj_geom_sr), size(volume,3)]);
+				sinogram_tmp2 = zeros([astra_geom_size(this.proj_geom), size(volume,3)]);
+				for slice = 1:size(volume,3)
+					
+					if strcmp(this.gpu, 'yes')
+						[tmp_id, sinogram_tmp2(:,:,slice)] = astra_create_sino_sampling(volume(:,:,slice), this.proj_geom, this.vol_geom, this.gpu_core, this.superresolution);
+						astra_mex_data2d('delete', tmp_id);
+					else
+						[tmp_id, tmp] = astra_create_sino(volume(:,:,slice), this.proj_id_sr);
+						sinogram_tmp2(:,:,slice) = downsample_sinogram(tmp, this.superresolution) * (this.superresolution^2);
+						astra_mex_data2d('delete', tmp_id);
+					end
+					
+				end
+				
+				% sinogram downsampling
+				if strcmp(this.gpu, 'yes')
+					%sinogram = downsample_sinogram(sinogram_tmp, this.superresolution);
+					sinogram2 = sinogram_tmp2;
+					if strcmp(this.proj_geom.type,'fanflat_vec') || strcmp(this.proj_geom.type,'fanflat')
+						sinogram2 = sinogram2 / this.superresolution;
+					elseif strcmp(this.proj_geom.type,'parallel')
+						sinogram2 = sinogram2 / (this.superresolution * this.superresolution);
+					end
+					sinogram = sinogram2;
+				else
+					sinogram = sinogram_tmp2;
+				end
+				
+			end
+			
+		end		
+
+		%------------------------------------------------------------------
+		% Protected function: reconstruct
+		function V = reconstruct_c(this, sinogram, V0, mask, iterations)
+			
+			if this.initialized == 0
+				error('IterativeTomography not initialized');
+			end			
+			
+			% data is stored in astra memory
+			if numel(sinogram) == 1
+				V = this.reconstruct_c_astra(sinogram, V0, mask, iterations);
+			
+			% data is stored in matlab memory
+			else
+				V = this.reconstruct_c_matlab(sinogram, V0, mask, iterations);
+			end
+			
+		end
+		
+		%------------------------------------------------------------------
+		% Protected function: reconstruct (data in matlab)	
+		function V = reconstruct_c_matlab(this, sinogram, V0, mask, iterations)
+			
+			if this.initialized == 0
+				error('IterativeTomography not initialized');
+			end						
+			
+			% parse method
+			method2 = upper(this.method);
+			if strcmp(method2, 'SART') || strcmp(method2, 'SART_CUDA')
+				iterations = iterations * size(sinogram,1);
+			elseif strcmp(method2, 'ART')
+				iterations = iterations * numel(sinogram);
+			end
+			
+			% create data objects
+			V = zeros(this.vol_geom.GridRowCount, this.vol_geom.GridColCount, size(sinogram,3));
+			reconstruction_id = astra_mex_data2d('create', '-vol', this.vol_geom);
+			sinogram_id = astra_mex_data2d('create', '-sino', this.proj_geom);
+			if numel(mask) > 0
+				mask_id = astra_mex_data2d('create', '-vol', this.vol_geom);
+			end
+			
+			% algorithm configuration
+			cfg = this.cfg_base;
+			cfg.ProjectionDataId = sinogram_id;
+			cfg.ReconstructionDataId = reconstruction_id;
+			if numel(mask) > 0
+				cfg.option.ReconstructionMaskId = mask_id;
+			end
+			alg_id = astra_mex_algorithm('create', cfg);
+			
+			% loop slices
+			for slice = 1:size(sinogram,3)
+				
+				% fetch slice of initial reconstruction
+				if numel(V0) > 0
+					astra_mex_data2d('store', reconstruction_id, V0(:,:,slice));
+				else
+					astra_mex_data2d('store', reconstruction_id, 0);
+				end
+				
+				% fetch slice of sinogram
+				astra_mex_data2d('store', sinogram_id, sinogram(:,:,slice));
+				
+				% fecth slice of mask
+				if numel(mask) > 0
+					astra_mex_data2d('store', mask_id, mask(:,:,slice));    
+				end
+				
+				% iterate
+				astra_mex_algorithm('iterate', alg_id, iterations);
+				
+				% fetch data
+				V(:,:,slice) = astra_mex_data2d('get', reconstruction_id);
+				
+			end				
+			
+			% correct attenuation factors for super-resolution
+			if this.superresolution > 1 && strcmp(this.gpu,'yes')
+				if strcmp(this.proj_geom.type,'fanflat_vec') || strcmp(this.proj_geom.type,'fanflat')
+					if numel(mask) > 0
+						V(mask > 0) = V(mask > 0) ./ this.superresolution;
+					else
+						V = V ./ this.superresolution;
+					end
+				end		
+			end
+			
+			% garbage collection
+			astra_mex_algorithm('delete', alg_id);
+			astra_mex_data2d('delete', sinogram_id, reconstruction_id);
+			if numel(mask) > 0
+				astra_mex_data2d('delete', mask_id);
+			end	
+			
+		end
+		
+		%------------------------------------------------------------------
+		% Protected function: reconstruct (data in astra)	
+		function V = reconstruct_c_astra(this, sinogram, V0, mask, iterations)
+			
+			if this.initialized == 0
+				error('IterativeTomography not initialized');
+			end			
+		
+			if numel(V0) > 1 || numel(mask) > 1 || numel(sinogram) > 1
+				error('Not all required data is stored in the astra memory');
+			end			
+			
+			if numel(V0) == 0
+				V0 = astra_mex_data2d('create', '-vol', this.vol_geom, 0);
+			end
+			
+			% parse method
+			method2 = upper(this.method);
+			if strcmp(method2, 'SART') || strcmp(method2, 'SART_CUDA')
+				iterations = iterations * astra_geom_size(this.proj_geom, 1);
+			elseif strcmp(method2, 'ART')
+				s = astra_geom_size(this.proj_geom);
+				iterations = iterations * s(1) * s(2);
+			end	
+			
+			% algorithm configuration
+			cfg = this.cfg_base;
+			cfg.ProjectionDataId = sinogram;
+			cfg.ReconstructionDataId = V0;
+			if numel(mask) > 0
+				cfg.option.ReconstructionMaskId = mask;
+			end
+			alg_id = astra_mex_algorithm('create', cfg);				
+			
+			% iterate
+			astra_mex_algorithm('iterate', alg_id, iterations);	
+			
+			% fetch data
+			V = V0;
+			
+			% correct attenuation factors for super-resolution
+			if this.superresolution > 1
+				if strcmp(this.proj_geom.type,'fanflat_vec') || strcmp(this.proj_geom.type,'fanflat')
+					if numel(mask) > 0
+						astra_data_op_masked('$1./s1', [V V], [this.superresolution this.superresolution], mask, this.gpu_core);
+					else
+						astra_data_op('$1./s1', [V V], [this.superresolution this.superresolution], this.gpu_core);
+					end
+				end	
+			end
+			
+			% garbage collection
+			astra_mex_algorithm('delete', alg_id);
+			
+		end
+		
+		%------------------------------------------------------------------
+		function V_out = selectROI(~, V_in)
+			
+			if numel(V_in) == 1
+				cfg = astra_struct('RoiSelect_CUDA');
+				cfg.DataId = V_in;
+				alg_id = astra_mex_algorithm('create',cfg);
+				astra_mex_algorithm('run', alg_id);
+				astra_mex_algorithm('delete', alg_id);
+				V_out = V_in;
+			else
+				V_out = ROIselectfull(V_in, min([size(V_in,1), size(V_in,2)]));
+			end
+			
+		end
+		%------------------------------------------------------------------
+		
+	end
+		
+end
+
diff --git a/matlab/algorithms/DART/IterativeTomography3D.m b/matlab/algorithms/DART/IterativeTomography3D.m
new file mode 100644
index 0000000..3f89457
--- /dev/null
+++ b/matlab/algorithms/DART/IterativeTomography3D.m
@@ -0,0 +1,433 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef IterativeTomography3D < matlab.mixin.Copyable
+
+	% Algorithm class for 3D Iterative Tomography.
+
+	%----------------------------------------------------------------------
+	properties (SetAccess=public, GetAccess=public)				
+		superresolution		= 1;				% SETTING: Volume upsampling factor.
+		proj_type			= 'linear';			% SETTING: Projector type, only when gpu='no'.
+		method				= 'SIRT3D_CUDA';		% SETTING: Iterative method (see ASTRA toolbox documentation).
+		gpu					= 'yes';			% SETTING: Use gpu? {'yes', 'no'}
+		gpu_core			= 0;				% SETTING: Which gpu core to use? Only when gpu='yes'.
+		inner_circle		= 'yes';			% SETTING: Do roi only? {'yes', 'no'}
+		image_size			= [];				% SETTING: Overwrite default reconstruction size.  Only if no vol_geom is specified.
+		use_minc			= 'no';				% SETTING: Use minimum constraint. {'no', 'yes'}
+        maxc                = +Inf;             % SETTING: Maximum constraint. +Inf means off.
+	end
+	%----------------------------------------------------------------------
+	properties (SetAccess=public, GetAccess=public)	
+		sinogram			= [];				% DATA: Projection data.
+		proj_geom			= [];				% DATA: Projection geometry.
+		V					= [];				% DATA: Volume data.  Also used to set initial estimate (optional).
+		vol_geom			= [];				% DATA: Volume geometry.
+	end
+	%----------------------------------------------------------------------
+	properties (SetAccess=private, GetAccess=public)
+		initialized     	= 0;				% Is this object initialized?
+	end
+	%----------------------------------------------------------------------
+	properties (SetAccess=protected, GetAccess=protected)
+		proj_geom_sr		= [];				% PROTECTED: geometry of sinogram (with super-resolution)
+        proj_id             = [];				% PROTECTED: astra id of projector (when gpu='no')
+        proj_id_sr          = [];				% PROTECTED: astra id of super-resolution projector (when gpu='no')	
+		cfg_base			= struct();			% PROTECTED: base configuration structure for the reconstruction algorithm.
+    end
+	%----------------------------------------------------------------------
+
+	methods (Access=public)
+		
+		%------------------------------------------------------------------
+		function this = IterativeTomography(varargin)
+			% Constructor
+			% >> tomography = IterativeTomography(); 
+			% >> tomography = IterativeTomography(base); base struct should contain fields 'sinogram' and 'proj_geom'.
+			% >> tomography = IterativeTomography(base_filename); mat-file should contain 'sinogram' and 'proj_geom'.
+			% >> tomography = IterativeTomography(proj_geom, vol_geom);
+			% >> tomography = IterativeTomography(sinogram, proj_geom);
+			
+			% Input: IterativeTomography(base)
+			if nargin == 1
+				if ischar(varargin{1})
+					this.sinogram = load(varargin{1},'sinogram');
+					this.proj_geom = load(varargin{1},'proj_geom');				
+				else
+					this.sinogram = varargin{1}.sinogram;
+					this.proj_geom = varargin{1}.proj_geom;
+				end
+			end
+			% Input: IterativeTomography(proj_geom, vol_geom)
+			if nargin == 2 && isstruct(varargin{1}) && isstruct(varargin{2})
+				this.proj_geom = varargin{1};
+				this.vol_geom =	varargin{2};
+			% Input: IterativeTomography(sinogram, proj_geom)
+			elseif nargin == 2
+				this.sinogram = varargin{1};
+				this.proj_geom = varargin{2};
+			end		
+
+		end
+
+		%------------------------------------------------------------------
+		function delete(this)
+			% Destructor
+			% >> clear tomography;
+			if strcmp(this.gpu,'no') && numel(this.proj_id) > 0
+				astra_mex_projector('delete', this.proj_id, this.proj_id_sr);
+			end
+		end
+			
+		%------------------------------------------------------------------
+		function settings = getsettings(this)
+			% Returns a structure containing all settings of this object.
+			% >> settings = tomography.getsettings();
+			settings.superresolution	= this.superresolution;
+			settings.proj_type			= this.proj_type;
+			settings.method				= this.method;
+			settings.gpu				= this.gpu;
+			settings.gpu_core			= this.gpu_core;
+			settings.inner_circle		= this.inner_circle;
+			settings.image_size			= this.image_size;	
+			settings.use_minc			= this.use_minc;
+            settings.maxc               = this.maxc;
+		end		
+		
+		%------------------------------------------------------------------
+		function ok = initialize(this)
+			% Initialize this object.  Returns 1 if succesful.
+			% >> tomography.initialize();
+			
+% 			% create projection geometry with super-resolution
+% 			this.proj_geom_sr = astra_geom_superresolution(this.proj_geom, this.superresolution);		
+			
+			% if no volume geometry is specified by the user: create volume geometry
+			if numel(this.vol_geom) == 0
+				if numel(this.image_size) < 2
+					this.image_size(1) = this.proj_geom.DetectorRowCount;
+					this.image_size(2) = this.proj_geom.DetectorColCount;
+				end
+				this.vol_geom = astra_create_vol_geom(this.proj_geom.DetectorColCount, this.proj_geom.DetectorColCount, this.proj_geom.DetectorRowCount);
+			else
+				this.image_size(1) = this.vol_geom.GridRowCount;
+				this.image_size(2) = this.vol_geom.GridColCount;
+			end
+			
+			% create projector
+			if strcmp(this.gpu, 'no')
+				this.proj_id = astra_create_projector(this.proj_type, this.proj_geom, this.vol_geom);
+				this.proj_id_sr = astra_create_projector(this.proj_type, this.proj_geom_sr, this.vol_geom);			
+			end
+			
+			% create reconstruction configuration
+			this.cfg_base = astra_struct(upper(this.method));
+			if strcmp(this.gpu,'no')
+				this.cfg_base.ProjectorId = this.proj_id;
+				this.cfg_base.ProjectionGeometry = this.proj_geom;
+				this.cfg_base.ReconstructionGeometry = this.vol_geom;
+				this.cfg_base.option.ProjectionOrder = 'random';
+			end
+			this.cfg_base.option.DetectorSuperSampling = this.superresolution;
+			%this.cfg_base.option.DetectorSuperSampling = 8;
+			if strcmp(this.gpu,'yes')
+				this.cfg_base.option.GPUindex = this.gpu_core;
+			end
+			this.cfg_base.option.UseMinConstraint = this.use_minc;
+            if ~isinf(this.maxc)
+              this.cfg_base.option.UseMaxConstraint = 'yes';
+              this.cfg_base.option.MaxConstraintValue = this.maxc;
+            end
+		
+			this.initialized = 1;
+			ok = this.initialized;
+		end
+		
+		%------------------------------------------------------------------
+		function P = project(this, volume)
+			% Compute forward projection.  
+			% Stores sinogram in tomography.sinogram if it is still empty.
+			% >> P = tomography.project();   projects 'tomography.V'.
+			% >> P = tomography.project(volume);   projects 'volume'.
+			
+			if ~this.initialized 
+				this.initialize();
+			end
+			
+			if nargin == 1 % tomography.project();
+				P = this.project_c(this.V);
+			
+			elseif nargin == 2 % tomography.project(volume); 
+				P = this.project_c(volume);
+			end
+			
+			% store
+			if numel(this.sinogram) == 0
+				this.sinogram = P;
+			end
+		end
+		
+		%------------------------------------------------------------------
+		function V = reconstruct(this, iterations)
+			% Compute reconstruction.
+			% Uses tomography.sinogram
+			% Initial solution (if available) should be stored in tomography.V  
+			% >> V = tomography.reconstruct(iterations);
+			
+			if ~this.initialized 
+				this.initialize();
+			end			
+			
+			this.V = this.reconstruct_c(this.sinogram, this.V, [], iterations);
+			if strcmp(this.inner_circle,'yes')
+				this.V = this.selectROI(this.V);
+			end
+			V = this.V;
+		end
+
+		%------------------------------------------------------------------
+		function I = reconstructMask(this, mask, iterations)
+			% Compute reconstruction with mask.
+			% Uses tomography.sinogram  
+			% Initial solution (if available) should be stored in tomography.V  
+			% >> V = tomography.reconstructMask(mask, iterations);			
+			
+			if ~this.initialized 
+				this.initialize();
+			end
+			
+			if strcmp(this.inner_circle,'yes')
+				mask = this.selectROI(mask);
+			end
+			I = this.reconstruct_c(this.sinogram, this.V, mask, iterations);
+		end	
+		%------------------------------------------------------------------
+	
+	end
+	
+	%----------------------------------------------------------------------
+	methods (Access = protected)
+	
+		%------------------------------------------------------------------
+		% Protected function: create FP
+		function sinogram = project_c(this, volume)
+			
+			if this.initialized == 0
+				error('IterativeTomography not initialized');
+			end
+            
+			% data is stored in astra memory
+			if numel(volume) == 1
+				
+				if strcmp(this.gpu, 'yes')
+					sinogram_tmp = astra_create_sino_cuda(volume, this.proj_geom_sr, this.vol_geom, this.gpu_core);
+				else
+					sinogram_tmp = astra_create_sino(volume, this.proj_id);
+				end
+				
+				% sinogram downsampling
+				if this.superresolution > 1
+					sinogram_data = astra_mex_data2d('get', sinogram_tmp);
+					astra_mex_data2d('delete', sinogram_tmp);
+					sinogram_data = downsample_sinogram(sinogram_data, this.superresolution);	
+					%if strcmp(this.proj_geom.type,'fanflat_vec') || strcmp(this.proj_geom.type,'fanflat')
+					%	sinogram = sinogram / this.superresolution;
+					%end
+					sinogram = astra_mex_data2d('create','sino', this.proj_geom, sinogram_data);
+				else
+					sinogram = sinogram_tmp;
+				end
+				
+			% data is stored in matlab memory	
+			else
+			
+				[tmp_id, sinogram] = astra_create_sino3d_cuda(volume, this.proj_geom, this.vol_geom);
+				astra_mex_data3d('delete', tmp_id);
+				
+			end
+			
+		end		
+
+		%------------------------------------------------------------------
+		% Protected function: reconstruct
+		function V = reconstruct_c(this, sinogram, V0, mask, iterations)
+			
+			if this.initialized == 0
+				error('IterativeTomography not initialized');
+			end			
+			
+			% data is stored in astra memory
+			if numel(sinogram) == 1
+				V = this.reconstruct_c_astra(sinogram, V0, mask, iterations);
+			
+			% data is stored in matlab memory
+			else
+				V = this.reconstruct_c_matlab(sinogram, V0, mask, iterations);
+			end
+			
+		end
+		
+		%------------------------------------------------------------------
+		% Protected function: reconstruct (data in matlab)	
+		function V = reconstruct_c_matlab(this, sinogram, V0, mask, iterations)
+			
+			if this.initialized == 0
+				error('IterativeTomography not initialized');
+			end						
+			
+			% parse method
+			method2 = upper(this.method);
+			if strcmp(method2, 'SART') || strcmp(method2, 'SART_CUDA')
+				iterations = iterations * size(sinogram,1);
+			elseif strcmp(method2, 'ART')
+				iterations = iterations * numel(sinogram);
+			end
+			
+			% create data objects
+% 			V = zeros(this.vol_geom.GridRowCount, this.vol_geom.GridColCount, size(sinogram,3));
+			reconstruction_id = astra_mex_data3d('create', '-vol', this.vol_geom);
+			sinogram_id = astra_mex_data3d('create', '-proj3d', this.proj_geom);
+			if numel(mask) > 0
+				mask_id = astra_mex_data3d('create', '-vol', this.vol_geom);
+			end
+			
+			% algorithm configuration
+			cfg = this.cfg_base;
+			cfg.ProjectionDataId = sinogram_id;
+			cfg.ReconstructionDataId = reconstruction_id;
+			if numel(mask) > 0
+				cfg.option.ReconstructionMaskId = mask_id;
+			end
+			alg_id = astra_mex_algorithm('create', cfg);
+			
+% 			% loop slices
+% 			for slice = 1:size(sinogram,3)
+				
+				% fetch slice of initial reconstruction
+				if numel(V0) > 0
+					astra_mex_data3d('store', reconstruction_id, V0);
+				else
+					astra_mex_data3d('store', reconstruction_id, 0);
+				end
+				
+				% fetch slice of sinogram
+				astra_mex_data3d('store', sinogram_id, sinogram);
+				
+				% fecth slice of mask
+				if numel(mask) > 0
+					astra_mex_data3d('store', mask_id, mask);    
+				end
+				
+				% iterate
+				astra_mex_algorithm('iterate', alg_id, iterations);
+				
+				% fetch data
+				V = astra_mex_data3d('get', reconstruction_id);
+				
+%			end
+			
+			% correct attenuation factors for super-resolution
+			if this.superresolution > 1 && strcmp(this.gpu,'yes')
+				if strcmp(this.proj_geom.type,'fanflat_vec') || strcmp(this.proj_geom.type,'fanflat')
+					if numel(mask) > 0
+						V(mask > 0) = V(mask > 0) ./ this.superresolution;
+					else
+						V = V ./ this.superresolution;
+					end
+				end		
+			end
+			
+			% garbage collection
+			astra_mex_algorithm('delete', alg_id);
+			astra_mex_data3d('delete', sinogram_id, reconstruction_id);
+			if numel(mask) > 0
+				astra_mex_data3d('delete', mask_id);
+			end	
+			
+		end
+		
+		%------------------------------------------------------------------
+		% Protected function: reconstruct (data in astra)	
+		function V = reconstruct_c_astra(this, sinogram, V0, mask, iterations)
+			
+			if this.initialized == 0
+				error('IterativeTomography not initialized');
+			end			
+		
+			if numel(V0) > 1 || numel(mask) > 1 || numel(sinogram) > 1
+				error('Not all required data is stored in the astra memory');
+			end			
+			
+			if numel(V0) == 0
+				V0 = astra_mex_data2d('create', '-vol', this.vol_geom, 0);
+			end
+			
+			% parse method
+			method2 = upper(this.method);
+			if strcmp(method2, 'SART') || strcmp(method2, 'SART_CUDA')
+				iterations = iterations * astra_geom_size(this.proj_geom, 1);
+			elseif strcmp(method2, 'ART')
+				s = astra_geom_size(this.proj_geom);
+				iterations = iterations * s(1) * s(2);
+			end	
+			
+			% algorithm configuration
+			cfg = this.cfg_base;
+			cfg.ProjectionDataId = sinogram;
+			cfg.ReconstructionDataId = V0;
+			if numel(mask) > 0
+				cfg.option.ReconstructionMaskId = mask;
+			end
+			alg_id = astra_mex_algorithm('create', cfg);				
+			
+			% iterate
+			astra_mex_algorithm('iterate', alg_id, iterations);	
+			
+			% fetch data
+			V = V0;
+			
+			% correct attenuation factors for super-resolution
+			if this.superresolution > 1
+				if strcmp(this.proj_geom.type,'fanflat_vec') || strcmp(this.proj_geom.type,'fanflat')
+					if numel(mask) > 0
+						astra_data_op_masked('$1./s1', [V V], [this.superresolution this.superresolution], mask, this.gpu_core);
+					else
+						astra_data_op('$1./s1', [V V], [this.superresolution this.superresolution], this.gpu_core);
+					end
+				end	
+			end
+			
+			% garbage collection
+			astra_mex_algorithm('delete', alg_id);
+			
+		end
+		
+		%------------------------------------------------------------------
+		function V_out = selectROI(~, V_in)
+			
+			if numel(V_in) == 1
+				cfg = astra_struct('RoiSelect_CUDA');
+				cfg.DataId = V_in;
+				alg_id = astra_mex_algorithm('create',cfg);
+				astra_mex_algorithm('run', alg_id);
+				astra_mex_algorithm('delete', alg_id);
+				V_out = V_in;
+			else
+				V_out = ROIselectfull(V_in, min([size(V_in,1), size(V_in,2)]));
+			end
+			
+		end
+		%------------------------------------------------------------------
+		
+	end
+		
+end
+
diff --git a/matlab/algorithms/DART/Kernels.m b/matlab/algorithms/DART/Kernels.m
new file mode 100644
index 0000000..b5e3134
--- /dev/null
+++ b/matlab/algorithms/DART/Kernels.m
@@ -0,0 +1,68 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef Kernels
+	%KERNELS Summary of this class goes here
+	%   Detailed explanation goes here
+	
+	properties
+		
+	end
+	
+	methods(Static)
+
+		function K = BinaryPixelKernel(radius, conn)
+			
+			if nargin < 2
+				conn = 8;
+			end
+			
+			% 2D, 4conn
+			if conn == 4
+				K = [0 1 0; 1 1 1; 0 1 0];
+				for i = 2:radius
+					K = conv2(K,K);
+				end
+				K = double(K >= 1);
+			
+			% 2D, 8conn
+			elseif conn == 8
+				K = ones(2*radius+1, 2*radius+1);
+				
+			% 3D, 6conn	
+			elseif conn == 6
+				K = zeros(3,3,3);
+				K(:,:,1) = [0 0 0; 0 1 0; 0 0 0];
+				K(:,:,2) = [0 1 0; 1 1 1; 0 1 0];
+				K(:,:,3) = [0 0 0; 0 1 0; 0 0 0];
+				for i = 2:radius
+					K = convn(K,K);
+				end
+				K = double(K >= 1);				
+				
+			% 2D, 27conn
+			elseif conn == 26
+				K = ones(2*radius+1, 2*radius+1, 2*radius+1);
+				
+			else
+				disp('Invalid conn')
+			end
+		end
+
+		
+
+	
+		
+		
+	end
+	
+end
+
diff --git a/matlab/algorithms/DART/MaskingDefault.m b/matlab/algorithms/DART/MaskingDefault.m
new file mode 100644
index 0000000..6bd25a5
--- /dev/null
+++ b/matlab/algorithms/DART/MaskingDefault.m
@@ -0,0 +1,212 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef MaskingDefault < matlab.mixin.Copyable
+
+	% Default policy class for masking for DART.
+	
+	%----------------------------------------------------------------------
+	properties (Access=public)
+		
+		radius			= 1;			% SETTING: Radius of masking kernel.
+		conn			= 8;			% SETTING: Connectivity window. For 2D: 4 or 8.  For 3D: 6 or 26.
+		edge_threshold	= 1;			% SETTING: Number of pixels in the window that should be different.
+		random			= 0.1;			% SETTING: Percentage of random points.  Between 0 and 1.
+		gpu				= 'yes';		% SETTING: Use gpu? {'yes', 'no'}
+		gpu_core		= 0;			% SETTING: Which gpu core to use, only when gpu='yes'.
+				
+	end
+	
+	%----------------------------------------------------------------------
+	methods (Access=public)
+		
+		%------------------------------------------------------------------
+		function settings = getsettings(this)
+			% Returns a structure containing all settings of this object.
+			% >> settings = DART.masking.getsettings();				
+			settings.radius				= this.radius;
+			settings.conn				= this.conn;
+			settings.edge_threshold		= this.edge_threshold;
+			settings.random				= this.random;
+		end
+		
+		%------------------------------------------------------------------
+		function Mask = apply(this, ~, S)
+			% Applies masking.
+			% >> Mask = DART.segmentation.apply(DART, S);	
+			
+			% 2D, one slice
+			if size(S,3) == 1
+				if strcmp(this.gpu,'yes')
+					Mask = this.apply_2D_gpu(S);
+				else
+					Mask = this.apply_2D(S);
+				end
+						
+			% 3D, slice by slice
+			elseif this.conn == 4 || this.conn == 8
+				Mask = zeros(size(S));
+				for slice = 1:size(S,3)
+					if strcmp(this.gpu,'yes')
+						Mask(:,:,slice) = this.apply_2D_gpu(S(:,:,slice));
+					else
+						Mask(:,:,slice) = this.apply_2D(S(:,:,slice));						
+					end
+				end
+			
+			% 3D, full
+			else
+				if strcmp(this.gpu,'yes')
+					Mask = this.apply_3D_gpu(S);	
+				else
+					Mask = this.apply_3D(S);	
+				end
+			end
+			
+		end
+		
+	end
+		
+	%----------------------------------------------------------------------
+	methods (Access=protected)
+		
+		%------------------------------------------------------------------
+		function Mask = apply_2D_gpu(this, S)
+		
+			vol_geom = astra_create_vol_geom(size(S));
+			data_id = astra_mex_data2d('create', '-vol', vol_geom, S);
+			mask_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
+
+			cfg = astra_struct('DARTMASK_CUDA');
+			cfg.SegmentationDataId = data_id;
+			cfg.MaskDataId = mask_id;
+			cfg.option.GPUindex = this.gpu_core;
+			cfg.option.Connectivity = this.conn;
+			cfg.option.Threshold = this.edge_threshold;
+			cfg.option.Radius = this.radius;
+			
+			alg_id = astra_mex_algorithm('create',cfg);	
+			astra_mex_algorithm('iterate',alg_id,1);
+			Mask = astra_mex_data2d('get', mask_id);
+		
+			astra_mex_algorithm('delete', alg_id);
+			astra_mex_data2d('delete', data_id, mask_id);
+			
+			% random
+			RandomField = double(rand(size(S)) < this.random);
+
+			% combine
+			Mask = or(Mask, RandomField);			
+			
+		end			
+		
+		%------------------------------------------------------------------
+		function Mask = apply_2D(this, S)
+		
+			r = this.radius;
+			w = 2 * r + 1;
+			
+			kernel = Kernels.BinaryPixelKernel(r, this.conn);
+			
+			% edges
+			Xlarge = zeros(size(S,1)+w-1, size(S,2)+w-1); 
+			Xlarge(1+r:end-r, 1+r:end-r) = S;
+
+			Edges = zeros(size(S));
+			for s = -r:r
+				for t = -r:r
+					if kernel(s+r+1, t+r+1) == 0
+						continue
+					end
+					Temp = abs(Xlarge(1+r:end-r, 1+r:end-r) - Xlarge(1+r+s:end-r+s, 1+r+t:end-r+t));
+					Edges(Temp > eps) = Edges(Temp > eps) + 1;
+				end
+			end
+
+			Edges = Edges > this.edge_threshold;
+			
+			% random
+			RandomField = double(rand(size(S)) < this.random);
+
+			% combine
+			Mask = or(Edges, RandomField);
+			
+		end		
+		
+		%------------------------------------------------------------------
+		function Mask = apply_3D(this, S)
+		
+			r = this.radius;
+			w = 2 * r + 1;
+			
+			kernel = Kernels.BinaryPixelKernel(r, this.conn);			
+			
+			% edges
+			Xlarge = zeros(size(S,1)+w-1, size(S,2)+w-1, size(S,3)+w-1); 
+			Xlarge(1+r:end-r, 1+r:end-r, 1+r:end-r) = S;
+
+			Edges = zeros(size(S));
+			for s = -r:r
+				for t = -r:r
+					for u = -r:r
+						if kernel(s+r+1, t+r+1, u+r+1) == 0
+							continue
+						end
+						Temp = abs(Xlarge(1+r:end-r, 1+r:end-r, 1+r:end-r) - Xlarge(1+r+s:end-r+s, 1+r+t:end-r+t, 1+r+u:end-r+u));
+						Edges(Temp > eps) = 1;
+					end
+				end
+			end
+			
+			clear Xlarge;
+
+			% random
+			RandomField = double(rand(size(S)) < this.random);
+
+			% combine
+			Mask = or(Edges, RandomField);
+			
+		end		
+		
+		%------------------------------------------------------------------
+		function Mask = apply_3D_gpu(this, S)
+	
+			vol_geom = astra_create_vol_geom(size(S));
+			data_id = astra_mex_data3d('create', '-vol', vol_geom, S);
+
+			cfg = astra_struct('DARTMASK3D_CUDA');
+			cfg.SegmentationDataId = data_id;
+			cfg.MaskDataId = data_id;
+			cfg.option.GPUindex = this.gpu_core;
+			cfg.option.Connectivity = this.conn;
+			cfg.option.Threshold = this.edge_threshold;
+			cfg.option.Radius = this.radius;
+			
+			alg_id = astra_mex_algorithm('create',cfg);	
+			astra_mex_algorithm('iterate',alg_id,1);
+			Mask = astra_mex_data3d('get', data_id);
+		
+			astra_mex_algorithm('delete', alg_id);
+			astra_mex_data3d('delete', data_id);
+			
+			% random
+			RandomField = double(rand(size(S)) < this.random);
+
+			% combine
+			Mask = or(Mask, RandomField);			
+			
+		end					
+		
+		%------------------------------------------------------------------
+	end
+	
+end
+
diff --git a/matlab/algorithms/DART/MaskingGPU.m b/matlab/algorithms/DART/MaskingGPU.m
new file mode 100644
index 0000000..c4ef2b7
--- /dev/null
+++ b/matlab/algorithms/DART/MaskingGPU.m
@@ -0,0 +1,94 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef MaskingGPU < matlab.mixin.Copyable
+
+	% Policy class for masking for DART with GPU accelerated code (deprecated).
+	
+	%----------------------------------------------------------------------
+	properties (Access=public)
+		
+		radius			= 1;			% SETTING: Radius of masking kernel.
+		conn			= 8;			% SETTING: Connectivity window. For 2D: 4 or 8.  For 3D: 6 or 26.
+		edge_threshold	= 1;			% SETTING: Number of pixels in the window that should be different.
+		gpu_core		= 0;			% SETTING:
+		random			= 0.1;			% SETTING: Percentage of random points.  Between 0 and 1.
+		
+	end
+	
+	%----------------------------------------------------------------------
+	methods (Access=public)
+		
+		%------------------------------------------------------------------
+		function settings = getsettings(this)
+			% Returns a structure containing all settings of this object.
+			% >> settings = DART.masking.getsettings();				
+			settings.radius				= this.radius;
+			settings.conn				= this.conn;
+			settings.edge_threshold		= this.edge_threshold;
+			settings.random				= this.random;
+		end
+		
+		%------------------------------------------------------------------
+		function Mask = apply(this, ~, V_in)
+			% Applies masking.
+			% >> Mask = DART.segmentation.apply(DART, V_in);	
+			
+			% 2D, one slice
+			if size(V_in,3) == 1
+				Mask = this.apply_2D(V_in);
+						
+			% 3D, slice by slice
+			elseif this.conn == 4 || this.conn == 8
+				Mask = zeros(size(V_in));
+				for slice = 1:size(V_in,3)
+					Mask(:,:,slice) = this.apply_2D(V_in(:,:,slice)); 
+				end
+			
+			% 3D, full
+			else
+				error('Full 3D masking on GPU not implemented.')
+			end
+			
+		end
+		
+	end
+		
+	%----------------------------------------------------------------------
+	methods (Access=protected)
+		
+		%------------------------------------------------------------------
+		function Mask = apply_2D(this, S)
+		
+			vol_geom = astra_create_vol_geom(size(S));
+			data_id = astra_mex_data2d('create', '-vol', vol_geom, S);
+			mask_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
+
+			cfg = astra_struct('DARTMASK_CUDA');
+			cfg.SegmentationDataId = data_id;
+			cfg.MaskDataId = mask_id;
+			cfg.option.GPUindex = this.gpu_core;
+			%cfg.option.Connectivity = this.conn;
+			
+			alg_id = astra_mex_algorithm('create',cfg);	
+			astra_mex_algorithm('iterate',alg_id,1);
+			Mask = astra_mex_data2d('get', mask_id);
+		
+			astra_mex_algorithm('delete', alg_id);
+			astra_mex_data2d('delete', data_id, mask_id);
+			
+		end	
+	end
+
+
+	
+end
+
diff --git a/matlab/algorithms/DART/OutputDefault.m b/matlab/algorithms/DART/OutputDefault.m
new file mode 100644
index 0000000..a34a430
--- /dev/null
+++ b/matlab/algorithms/DART/OutputDefault.m
@@ -0,0 +1,173 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef OutputDefault < matlab.mixin.Copyable
+	 
+	% Default policy class for output for DART.
+	
+	properties (Access=public)
+		
+		directory				= '';		% SETTING: Directory to save output.
+		pre						= '';		% SETTING: Prefix of output.
+
+		save_images				= 'no';		% SETTING: Save the images. 'no', 'yes' (='S') OR {'S', 'I', 'Mask', 'P'}
+		save_results			= 'no';		% SETTING: Save the results. 'yes', 'no' OR {'base', 'stats', 'settings', 'S', 'V', 'V0'}
+		save_object				= 'no';		% SETTING: Save the DART object. {'no','yes'}
+
+		save_interval			= 1;		% SETTING: # DART iteration between saves.
+		save_images_interval	= [];		% SETTING: Overwrite interval for save_images.
+		save_results_interval	= [];		% SETTING: Overwrite interval for save_results.
+		save_object_interval	= [];		% SETTING: Overwrite interval for save_object.
+
+		slices					= 1;		% SETTING: In case of 3D, which slices to save?		
+		
+		verbose					= 'no';		% SETTING: Verbose? {'no','yes'}
+		
+	end
+	
+	methods (Access=public)
+		
+		%------------------------------------------------------------------
+		function pre_initial_iteration(this, ~)
+			if strcmp(this.verbose,'yes')
+				tic
+				fprintf(1, 'initial iteration...');
+			end
+		end
+
+		%------------------------------------------------------------------
+		function post_initial_iteration(this, ~)
+			if strcmp(this.verbose,'yes')
+				t = toc;
+				fprintf(1, 'done in %f s.\n', t);
+			end
+		end
+		
+		%------------------------------------------------------------------
+		function pre_iteration(this, DART)
+			if strcmp(this.verbose,'yes')
+				tic;
+				fprintf(1, '%s dart iteration %d...', this.pre, DART.iterationcount);
+			end
+		end
+		
+		%------------------------------------------------------------------
+		function post_iteration(this, DART)
+
+			% print output
+			if strcmp(this.verbose,'yes')
+				t = toc;
+				s = DART.statistics.tostring(DART.stats);
+				fprintf(1, 'done in %0.2fs %s.\n', t, s);
+			end
+			
+			% save DART object	
+			if do_object(this, DART)
+				save(sprintf('%s%sobject_%i.mat', this.directory, this.pre, DART.iterationcount), '-v7.3', 'DART');					
+			end
+			
+			% save .mat
+			if do_results(this, DART)
+				base = DART.base;
+				stats = DART.stats;
+				S = DART.S;
+				V = DART.V;
+				V0 = DART.V0;
+				settings = DART.getsettings();
+				if ~iscell(this.save_results) 
+					save(sprintf('%s%sresults_%i.mat', this.directory, this.pre, DART.iterationcount), '-v7.3', 'base', 'stats', 'S', 'V', 'V0', 'settings');
+				else
+					string = [];
+					for i = 1:numel(this.save_results)
+						string = [string this.save_results{i} '|'];
+					end
+					save(sprintf('%s%sresults_%i.mat', this.directory, this.pre, DART.iterationcount), '-v7.3', '-regexp', string(1:end-1));
+				end
+			end	
+			
+			% save images
+			if do_images(this, DART)
+			
+				if ~iscell(this.save_images) && strcmp(this.save_images, 'yes')
+					output_image(this, DART, 'S')
+				elseif iscell(this.save_images)
+					for i = 1:numel(this.save_images)
+						output_image(this, DART, this.save_images{i});
+					end
+				end
+				
+			end					
+			
+		end
+		%------------------------------------------------------------------
+		
+	end
+	
+	%----------------------------------------------------------------------
+	methods (Access=private)
+		
+		function output_image(this, DART, data)
+			% 2D
+			if numel(size(DART.S)) == 2 
+				eval(['imwritesc(DART.' data ', sprintf(''%s%s' data '_%i.png'', this.directory, this.pre, DART.iterationcount))']);	
+			% 3D
+			elseif numel(size(DART.S)) == 3  
+				for slice = this.slices
+					eval(['imwritesc(DART.' data '(:,:,slice), sprintf(''%s%s' data '_%i_slice%i.png'', this.directory, this.pre, DART.iterationcount, slice))']);
+				end
+			end
+		end
+	
+		%------------------------------------------------------------------
+		function out = do_object(this, DART)
+			if strcmp(this.save_object,'no')
+				out = 0;
+				return
+			end			
+			if numel(this.save_object_interval) == 0 && mod(DART.iterationcount, this.save_interval) == 0 
+				out = 1;
+			elseif mod(DART.iterationcount, this.save_object_interval) == 0 
+				out = 1;
+			else
+				out = 0;
+			end
+		end				
+		%------------------------------------------------------------------
+		function out = do_results(this, DART)
+			if strcmp(this.save_results,'no')
+				out = 0;
+				return
+			end
+			if numel(this.save_results_interval) == 0 && mod(DART.iterationcount, this.save_interval) == 0 
+				out = 1;
+			elseif mod(DART.iterationcount, this.save_results_interval) == 0 
+				out = 1;
+			else
+				out = 0;
+			end
+		end		
+		
+		%------------------------------------------------------------------
+		function out = do_images(this, DART)
+			if numel(this.save_images_interval) == 0 && mod(DART.iterationcount, this.save_interval) == 0 
+				out = 1;
+			elseif mod(DART.iterationcount, this.save_images_interval) == 0 
+				out = 1;
+			else
+				out = 0;				
+			end
+		end
+		%------------------------------------------------------------------
+		
+	end
+	
+end
+
diff --git a/matlab/algorithms/DART/SegmentationDefault.m b/matlab/algorithms/DART/SegmentationDefault.m
new file mode 100644
index 0000000..c1d7d99
--- /dev/null
+++ b/matlab/algorithms/DART/SegmentationDefault.m
@@ -0,0 +1,55 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef SegmentationDefault < matlab.mixin.Copyable
+		
+	% Default policy class for segmentation for DART.
+	
+	%----------------------------------------------------------------------
+	properties (Access=public)
+		rho			= [];		% SETTING: Grey levels.
+		tau			= [];		% SETTING: Threshold values.
+	end
+	
+	%----------------------------------------------------------------------
+	methods (Access=public)
+		
+		%------------------------------------------------------------------
+		function settings = getsettings(this)
+			% Returns a structure containing all settings of this object.
+			% >> settings = DART.segmentation.getsettings();			
+			settings.rho	= this.rho;
+			settings.tau	= this.tau;
+		end
+	
+		%------------------------------------------------------------------
+		function this = estimate_grey_levels(this, ~, ~)
+			% Estimates grey levels
+			% >> DART.segmentation.estimate_grey_levels();				
+		end
+		
+		%------------------------------------------------------------------
+		function V_out = apply(this, ~, V_in)
+			% Applies segmentation.
+			% >> V_out = DART.segmentation.apply(DART, V_in);	
+			
+			V_out = ones(size(V_in)) * this.rho(1);
+			for n = 2:length(this.rho)
+				V_out(this.tau(n-1) < V_in) = this.rho(n);
+			end
+			
+		end
+		%------------------------------------------------------------------
+			
+	end
+	
+end
+
diff --git a/matlab/algorithms/DART/SmoothingDefault.m b/matlab/algorithms/DART/SmoothingDefault.m
new file mode 100644
index 0000000..58a8baa
--- /dev/null
+++ b/matlab/algorithms/DART/SmoothingDefault.m
@@ -0,0 +1,179 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef SmoothingDefault < matlab.mixin.Copyable
+	 
+	% Default policy class for smoothing for DART.
+	
+	%----------------------------------------------------------------------
+	properties (Access=public)
+		radius		= 1;			% SETTING: Radius of smoothing kernel.
+		b			= 0.1;			% SETTING: Intensity of smoothing.  Between 0 and 1.	
+		full3d		= 'yes';		% SETTING: smooth in 3D? {'yes','no'}
+		gpu			= 'yes';		% SETTING: Use gpu? {'yes', 'no'}
+		gpu_core	= 0;			% SETTING: Which gpu core to use, only when gpu='yes'.		
+	end
+	
+	
+	%----------------------------------------------------------------------
+	methods (Access=public)
+
+		%------------------------------------------------------------------
+		function settings = getsettings(this)
+			% Returns a structure containing all settings of this object.
+			% >> settings = DART.smoothing.getsettings();					
+			settings.radius				= this.radius;
+			settings.b					= this.b;
+			settings.full3d				= this.full3d;
+		end		
+		
+		%------------------------------------------------------------------
+		function V_out = apply(this, ~, V_in)
+			% Applies smoothing.
+			% >> V_out = DART.smoothing.apply(DART, V_in);	
+			
+			% 2D, one slice
+			if size(V_in,3) == 1
+				if strcmp(this.gpu,'yes')
+					V_out = this.apply_2D_gpu(V_in);
+				else
+					V_out = this.apply_2D(V_in);
+				end
+						
+			% 3D, slice by slice
+			elseif ~strcmp(this.full3d,'yes')
+				V_out = zeros(size(V_in));
+				for slice = 1:size(V_in,3)
+					if strcmp(this.gpu,'yes')
+						V_out(:,:,slice) = this.apply_2D_gpu(V_in(:,:,slice));
+					else
+						V_out(:,:,slice) = this.apply_2D(V_in(:,:,slice));						
+					end
+				end
+			
+			% 3D, full
+			else
+				if strcmp(this.gpu,'yes')
+					V_out = this.apply_3D_gpu(V_in);
+				else
+					V_out = this.apply_3D(V_in);
+				end
+			end
+			
+		end	
+			
+	end
+		
+	%----------------------------------------------------------------------
+	methods (Access=protected)
+		
+		%------------------------------------------------------------------
+		function V_out = apply_2D(this, V_in)
+			
+			r = this.radius;
+			w = 2 * r + 1;
+			
+			% Set Kernel
+			K = ones(w) * this.b / (w.^2-1); % edges
+			K(r+1,r+1) = 1 - this.b; % center
+			
+			% output window
+			V_out = zeros(size(V_in,1) + w-1, size(V_in,2) + w - 1);
+
+			% blur convolution
+			for s = -r:r 
+				for t = -r:r 
+					V_out(1+r+s:end-r+s, 1+r+t:end-r+t) = V_out(1+r+s:end-r+s, 1+r+t:end-r+t) + K(r+1+s, r+1+t) * V_in;
+				end
+			end
+			
+			% shrink output window
+			V_out = V_out(1+r:end-r, 1+r:end-r);
+			
+		end
+
+		%------------------------------------------------------------------
+		function V_out = apply_2D_gpu(this, V_in)
+			
+			vol_geom = astra_create_vol_geom(size(V_in));
+			in_id = astra_mex_data2d('create', '-vol', vol_geom, V_in);
+			out_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
+
+			cfg = astra_struct('DARTSMOOTHING_CUDA');
+			cfg.InDataId = in_id;
+			cfg.OutDataId = out_id;
+			cfg.option.Intensity = this.b;
+			cfg.option.Radius = this.radius;			
+			cfg.option.GPUindex = this.gpu_core;
+			
+			alg_id = astra_mex_algorithm('create',cfg);	
+			astra_mex_algorithm('iterate',alg_id,1);
+			V_out = astra_mex_data2d('get', out_id);
+		
+			astra_mex_algorithm('delete', alg_id);
+			astra_mex_data2d('delete', in_id, out_id);
+			
+		end		
+		
+		%------------------------------------------------------------------
+		function I_out = apply_3D(this, I_in)
+			
+			r = this.radius;
+			w = 2 * r + 1;
+			
+			% Set Kernel
+			K = ones(w,w,w) * this.b / (w.^3-1); % edges
+			K(r+1,r+1,r+1) = 1 - this.b; % center
+			
+			% output window
+			I_out = zeros(size(I_in,1)+w-1, size(I_in,2)+w-1, size(I_in,3)+w-1);
+
+			% blur convolution
+			for s = -r:r 
+				for t = -r:r 
+					for u = -r:r 
+						I_out(1+r+s:end-r+s, 1+r+t:end-r+t, 1+r+u:end-r+u) = I_out(1+r+s:end-r+s, 1+r+t:end-r+t, 1+r+u:end-r+u) + K(r+1+s, r+1+t, r+1+u) * I_in;
+					end
+				end
+			end
+			
+			% shrink output window
+			I_out = I_out(1+r:end-r, 1+r:end-r, 1+r:end-r);
+			
+		end		
+		
+		%------------------------------------------------------------------
+		function V_out = apply_3D_gpu(this, V_in)
+
+			vol_geom = astra_create_vol_geom(size(V_in));
+			data_id = astra_mex_data3d('create', '-vol', vol_geom, V_in);
+
+			cfg = astra_struct('DARTSMOOTHING3D_CUDA');
+			cfg.InDataId = data_id;
+			cfg.OutDataId = data_id;
+			cfg.option.Intensity = this.b;
+			cfg.option.Radius = this.radius;
+			cfg.option.GPUindex = this.gpu_core;
+			
+			alg_id = astra_mex_algorithm('create',cfg);	
+			astra_mex_algorithm('iterate', alg_id, 1);
+			V_out = astra_mex_data3d('get', data_id);
+		
+			astra_mex_algorithm('delete', alg_id);
+			astra_mex_data3d('delete', data_id);
+			
+		end		
+		%------------------------------------------------------------------
+		
+	end
+	
+end
+
diff --git a/matlab/algorithms/DART/SmoothingGPU.m b/matlab/algorithms/DART/SmoothingGPU.m
new file mode 100644
index 0000000..857da37
--- /dev/null
+++ b/matlab/algorithms/DART/SmoothingGPU.m
@@ -0,0 +1,119 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef SmoothingGPU < matlab.mixin.Copyable
+	 
+	% Default policy class for smoothing for DART.
+	
+	%----------------------------------------------------------------------
+	properties (Access=public)
+		radius		= 1;			% SETTING: Radius of smoothing kernel.
+		b			= 0.1;			% SETTING: Intensity of smoothing.  Between 0 and 1.	
+		full3d		= 'yes';		% SETTING: smooth in 3D? {'yes','no'}
+		gpu_core	= 0;			% SETTING:		
+	end
+	
+	
+	%----------------------------------------------------------------------
+	methods (Access=public)
+
+		%------------------------------------------------------------------
+		function settings = getsettings(this)
+			% Returns a structure containing all settings of this object.
+			% >> settings = DART.smoothing.getsettings();					
+			settings.radius				= this.radius;
+			settings.b					= this.b;
+			settings.full3d				= this.full3d;
+		end		
+		
+		%------------------------------------------------------------------
+		function V_out = apply(this, ~, V_in)
+			% Applies smoothing.
+			% >> V_out = DART.smoothing.apply(DART, V_in);	
+			
+			% 2D, one slice
+			if size(V_in,3) == 1
+				V_out = this.apply_2D(V_in);
+						
+			% 3D, slice by slice
+			elseif ~strcmp(this.full3d,'yes')
+				V_out = zeros(size(V_in));
+				for slice = 1:size(V_in,3)
+					V_out(:,:,slice) = this.apply_2D(V_in(:,:,slice)); 
+				end
+			
+			% 3D, full
+			else
+				V_out = this.apply_3D(V_in);
+			end
+			
+		end	
+			
+	end
+		
+	%----------------------------------------------------------------------
+	methods (Access=protected)
+		
+		%------------------------------------------------------------------
+		function V_out = apply_2D(this, V_in)
+			
+			vol_geom = astra_create_vol_geom(size(V_in));
+			in_id = astra_mex_data2d('create', '-vol', vol_geom, V_in);
+			out_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
+
+			cfg = astra_struct('DARTSMOOTHING_CUDA');
+			cfg.InDataId = in_id;
+			cfg.OutDataId = out_id;
+			cfg.Intensity = this.b;
+			cfg.option.GPUindex = this.gpu_core;
+			
+			alg_id = astra_mex_algorithm('create',cfg);	
+			astra_mex_algorithm('iterate',alg_id,1);
+			V_out = astra_mex_data2d('get', out_id);
+		
+			astra_mex_algorithm('delete', alg_id);
+			astra_mex_data2d('delete', in_id, out_id);
+			
+			
+		end
+		
+		%------------------------------------------------------------------
+		function I_out = apply_3D(this, I_in)
+			
+			r = this.radius;
+			w = 2 * r + 1;
+			
+			% Set Kernel
+			K = ones(w,w,w) * this.b / (w.^3-1); % edges
+			K(r+1,r+1,r+1) = 1 - this.b; % center
+			
+			% output window
+			I_out = zeros(size(I_in,1)+w-1, size(I_in,2)+w-1, size(I_in,3)+w-1);
+
+			% blur convolution
+			for s = -r:r 
+				for t = -r:r 
+					for u = -r:r 
+						I_out(1+r+s:end-r+s, 1+r+t:end-r+t, 1+r+u:end-r+u) = I_out(1+r+s:end-r+s, 1+r+t:end-r+t, 1+r+u:end-r+u) + K(r+1+s, r+1+t, r+1+u) * I_in;
+					end
+				end
+			end
+			
+			% shrink output window
+			I_out = I_out(1+r:end-r, 1+r:end-r, 1+r:end-r);
+			
+		end		
+		%------------------------------------------------------------------
+		
+	end
+	
+end
+
diff --git a/matlab/algorithms/DART/StatisticsDefault.m b/matlab/algorithms/DART/StatisticsDefault.m
new file mode 100644
index 0000000..7822c5f
--- /dev/null
+++ b/matlab/algorithms/DART/StatisticsDefault.m
@@ -0,0 +1,72 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef StatisticsDefault < matlab.mixin.Copyable
+	
+	% Default policy class for statistics for DART.	
+	
+	properties (Access=public)
+		pixel_error		= 'yes';		% SETTING: Store pixel error? {'yes','no'}
+		proj_diff		= 'yes';		% SETTING: Store projection difference? {'yes','no'}
+		timing			= 'yes';		% SETTING: Store timings? {'yes','no'}
+	end
+
+	
+	methods (Access=public)
+		
+		%------------------------------------------------------------------
+		function stats = apply(this, DART)
+			% Applies statistics.
+			% >> stats = DART.statistics.apply(DART);				
+			
+			stats = DART.stats;
+			
+			% timing
+			if strcmp(this.timing, 'yes')
+				stats.timing(DART.iterationcount) = toc(DART.start_tic);
+			end
+			
+			% pixel error
+			if strcmp(this.pixel_error, 'yes') && isfield(DART.base,'phantom')
+				[stats.rnmp, stats.nmp] = compute_rnmp(DART.base.phantom, DART.S);
+				stats.rnmp_hist(DART.iterationcount) = stats.rnmp;
+				stats.nmp_hist(DART.iterationcount) = stats.nmp;
+			end
+			
+			% projection difference
+			if strcmp(this.proj_diff, 'yes') 
+				new_sino = DART.tomography.createForwardProjection(DART, DART.S);
+				stats.proj_diff = sum((new_sino(:) - DART.base.sinogram(:)) .^2 ) ./ (sum(DART.base.sinogram(:)) );
+				stats.proj_diff_hist(DART.iterationcount) = stats.proj_diff;
+			end
+			
+		end
+		
+		%------------------------------------------------------------------
+		function s = tostring(~, stats)
+			% To string.
+			% >> stats = DART.statistics.apply(stats);				
+			
+			s = '';
+			if isfield(stats, 'nmp')
+				s = sprintf('%s [%d]', s, stats.nmp); 
+			end
+			if isfield(stats, 'proj_diff')
+				s = sprintf('%s {%0.2d}', s, stats.proj_diff); 
+			end			
+			
+		end
+		%------------------------------------------------------------------
+		
+	end
+	
+end
+
diff --git a/matlab/algorithms/DART/TomographyDefault.m b/matlab/algorithms/DART/TomographyDefault.m
new file mode 100644
index 0000000..4db3905
--- /dev/null
+++ b/matlab/algorithms/DART/TomographyDefault.m
@@ -0,0 +1,73 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef TomographyDefault < IterativeTomography
+
+	% Policy class for tomography for DART.
+
+	%----------------------------------------------------------------------
+	properties (Access=public)
+		t					= 5;		% SETTING: # ARMiterations, each DART iteration.
+		t0					= 100;		% SETTING: # ARM iterations at DART initialization.
+	end
+	%----------------------------------------------------------------------
+
+	methods
+
+		%------------------------------------------------------------------
+		function settings = getsettings(this)
+			% Returns a structure containing all settings of this object.
+			% >> settings = DART.tomography.getsettings();
+%			settings = getsettings@IterativeTomography();
+			settings.t					= this.t;
+			settings.t0					= this.t0;
+		end
+
+		%------------------------------------------------------------------
+		function initialize(this, DART)
+			% Initializes this object. 
+			% >> DART.tomography.initialize();
+			this.proj_geom = DART.base.proj_geom;
+			this.initialize@IterativeTomography();
+		end
+		
+		%------------------------------------------------------------------
+		function P = createForwardProjection(this, ~, volume)
+			% Compute forward projection. 
+			% >> DART.tomography.createForwardProjection(DART, volume);
+			P = this.project_c(volume);
+		end
+		
+		%------------------------------------------------------------------
+		function I = createReconstruction(this, ~, sinogram, V0, mask)
+			% Compute reconstruction (with mask).
+			% >> DART.tomography.createReconstruction(DART, sinogram, V0, mask);			
+			if strcmp(this.inner_circle,'yes')
+				mask = ROIselectfull(mask, size(mask,1));
+			end
+			I = this.reconstruct_c(sinogram, V0, mask, this.t);
+		end	
+		
+		%------------------------------------------------------------------
+		function I = createInitialReconstruction(this, ~, sinogram)
+			% Compute reconstruction (initial).
+			% >> DART.tomography.createInitialReconstruction(DART, sinogram);						
+			I = this.reconstruct_c(sinogram, [], [], this.t0);
+			if strcmp(this.inner_circle,'yes')
+				I = ROIselectfull(I, size(I,1));
+			end
+		end			
+		%------------------------------------------------------------------
+	
+	end		
+		
+end
+
diff --git a/matlab/algorithms/DART/TomographyDefault3D.m b/matlab/algorithms/DART/TomographyDefault3D.m
new file mode 100644
index 0000000..2be1b17
--- /dev/null
+++ b/matlab/algorithms/DART/TomographyDefault3D.m
@@ -0,0 +1,73 @@
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%
+% Author of this DART Algorithm: Wim van Aarle
+
+
+classdef TomographyDefault3D < IterativeTomography3D
+
+	% Policy class for 3D tomography for DART.
+
+	%----------------------------------------------------------------------
+	properties (Access=public)
+		t					= 5;		% SETTING: # ARMiterations, each DART iteration.
+		t0					= 100;		% SETTING: # ARM iterations at DART initialization.
+	end
+	%----------------------------------------------------------------------
+
+	methods
+
+		%------------------------------------------------------------------
+		function settings = getsettings(this)
+			% Returns a structure containing all settings of this object.
+			% >> settings = DART.tomography.getsettings();
+%			settings = getsettings@IterativeTomography();
+			settings.t					= this.t;
+			settings.t0					= this.t0;
+		end
+
+		%------------------------------------------------------------------
+		function initialize(this, DART)
+			% Initializes this object. 
+			% >> DART.tomography.initialize();
+			this.proj_geom = DART.base.proj_geom;
+			this.initialize@IterativeTomography3D();
+		end
+		
+		%------------------------------------------------------------------
+		function P = createForwardProjection(this, ~, volume)
+			% Compute forward projection. 
+			% >> DART.tomography.createForwardProjection(DART, volume);
+			P = this.project_c(volume);
+		end
+		
+		%------------------------------------------------------------------
+		function I = createReconstruction(this, ~, sinogram, V0, mask)
+			% Compute reconstruction (with mask).
+			% >> DART.tomography.createReconstruction(DART, sinogram, V0, mask);			
+			if strcmp(this.inner_circle,'yes')
+				mask = ROIselectfull(mask, size(mask,1));
+			end
+			I = this.reconstruct_c(sinogram, V0, mask, this.t);
+		end	
+		
+		%------------------------------------------------------------------
+		function I = createInitialReconstruction(this, ~, sinogram)
+			% Compute reconstruction (initial).
+			% >> DART.tomography.createInitialReconstruction(DART, sinogram);						
+			I = this.reconstruct_c(sinogram, [], [], this.t0);
+			if strcmp(this.inner_circle,'yes')
+				I = ROIselectfull(I, size(I,1));
+			end
+		end			
+		%------------------------------------------------------------------
+	
+	end		
+		
+end
+
diff --git a/matlab/algorithms/DART/examples/cylinders.png b/matlab/algorithms/DART/examples/cylinders.png
new file mode 100644
index 0000000..8d1c0b2
--- /dev/null
+++ b/matlab/algorithms/DART/examples/cylinders.png
diff --git a/matlab/algorithms/DART/examples/example1.m b/matlab/algorithms/DART/examples/example1.m
new file mode 100644
index 0000000..daa3ce8
--- /dev/null
+++ b/matlab/algorithms/DART/examples/example1.m
@@ -0,0 +1,79 @@
+clear all;
+
+addpath('..');
+
+%
+% Example 1: parallel beam, three slices.
+%
+
+% Configuration
+proj_count = 20;
+slice_count = 3;
+dart_iterations = 20;
+filename = 'cylinders.png';
+outdir = './';
+prefix = 'example1';
+rho = [0, 1];
+tau = 0.5;
+gpu_core = 0;
+
+% Load phantom.
+I = double(imread(filename)) / 255;
+
+% Create projection and volume geometries.
+det_count = size(I, 1);
+angles = linspace(0, pi - pi / proj_count, proj_count);
+proj_geom = astra_create_proj_geom('parallel3d', 1, 1, slice_count, det_count, angles);
+vol_geom = astra_create_vol_geom(det_count, det_count, 1);
+
+% Create sinogram.
+[sinogram_id, sinogram] = astra_create_sino3d_cuda(I, proj_geom, vol_geom);
+astra_mex_data3d('delete', sinogram_id);
+
+%
+% DART
+%
+
+base.sinogram = sinogram;
+base.proj_geom = proj_geom;
+
+D                      = DARTalgorithm(base);
+
+D.tomography           = TomographyDefault3D();
+D.tomography.t0        = 100;
+D.tomography.t         = 10;
+D.tomography.method    = 'SIRT3D_CUDA';
+D.tomography.gpu_core  = gpu_core;
+D.tomography.use_minc  = 'yes';
+% D.tomography.maxc      = 0.003; % Not a sensible value, just for demonstration.
+
+D.segmentation.rho     = rho;
+D.segmentation.tau     = tau;
+
+D.smoothing.b          = 0.1;
+D.smoothing.full3d     = 'yes';
+D.smoothing.gpu_core   = gpu_core;
+ 
+D.masking.random       = 0.1;
+D.masking.conn         = 6;
+D.masking.gpu_core     = gpu_core;
+
+D.output.directory     = outdir;
+D.output.pre           = [prefix '_'];
+D.output.save_images   = 'no';
+D.output.save_results  = {'stats', 'settings', 'S', 'V'};
+D.output.save_interval = dart_iterations;
+D.output.verbose       = 'yes';
+
+D.statistics.proj_diff = 'no';
+
+D.initialize();
+
+disp([D.output.directory D.output.pre]);
+
+D.iterate(dart_iterations);
+
+% Convert middle slice of final iteration to png.
+load([outdir '/' prefix '_results_' num2str(dart_iterations) '.mat']);
+imwritesc(D.S(:, :, round(slice_count / 2)), [outdir '/' prefix '_slice_2_S.png']);
+imwritesc(D.V(:, :, round(slice_count / 2)), [outdir '/' prefix '_slice_2_V.png']);
diff --git a/matlab/algorithms/DART/examples/example2.m b/matlab/algorithms/DART/examples/example2.m
new file mode 100644
index 0000000..8ee8cba
--- /dev/null
+++ b/matlab/algorithms/DART/examples/example2.m
@@ -0,0 +1,80 @@
+clear all;
+
+addpath('..');
+
+%
+% Example 2: cone beam, full cube.
+%
+
+% Configuration
+det_count = 128;
+proj_count = 45;
+slice_count = det_count;
+dart_iterations = 20;
+outdir = './';
+prefix = 'example2';
+rho = [0 0.5 1];
+tau = [0.25 0.75];
+gpu_core = 0;
+
+% Create phantom.
+% I = phantom3d([1 0.9 0.9 0.9 0 0 0 0 0 0; -0.5 0.8 0.8 0.8 0 0 0 0 0 0; -0.5 0.3 0.3 0.3 0 0 0 0 0 0], det_count);
+% save('phantom3d', 'I');
+load('phantom3d'); % Loads I.
+
+% Create projection and volume geometries.
+angles = linspace(0, pi - pi / proj_count, proj_count);
+proj_geom = astra_create_proj_geom('cone', 1, 1, slice_count, det_count, angles, 500, 0);
+vol_geom = astra_create_vol_geom(det_count, det_count, slice_count);
+
+% Create sinogram.
+[sinogram_id, sinogram] = astra_create_sino3d_cuda(I, proj_geom, vol_geom);
+astra_mex_data3d('delete', sinogram_id);
+
+%
+% DART
+%
+
+base.sinogram = sinogram;
+base.proj_geom = proj_geom;
+
+D                      = DARTalgorithm(base);
+
+D.tomography           = TomographyDefault3D();
+D.tomography.t0        = 100;
+D.tomography.t         = 10;
+D.tomography.method    = 'SIRT3D_CUDA';
+D.tomography.gpu_core  = gpu_core;
+D.tomography.use_minc  = 'yes';
+% D.tomography.maxc      = 0.003; % Not a sensible value, just for demonstration.
+
+D.segmentation.rho     = rho;
+D.segmentation.tau     = tau;
+
+D.smoothing.b          = 0.1;
+D.smoothing.full3d     = 'yes';
+D.smoothing.gpu_core   = gpu_core;
+ 
+D.masking.random       = 0.1;
+D.masking.conn         = 6;
+D.masking.gpu_core     = gpu_core;
+
+D.output.directory     = outdir;
+D.output.pre           = [prefix '_'];
+D.output.save_images   = 'no';
+D.output.save_results  = {'stats', 'settings', 'S', 'V'};
+D.output.save_interval = dart_iterations;
+D.output.verbose       = 'yes';
+
+D.statistics.proj_diff = 'no';
+
+D.initialize();
+
+disp([D.output.directory D.output.pre]);
+
+D.iterate(dart_iterations);
+
+% Convert middle slice of final iteration to png.
+load([outdir '/' prefix '_results_' num2str(dart_iterations) '.mat']);
+imwritesc(D.S(:, :, round(slice_count / 2)), [outdir '/' prefix '_slice_2_S.png']);
+imwritesc(D.V(:, :, round(slice_count / 2)), [outdir '/' prefix '_slice_2_V.png']);
diff --git a/matlab/algorithms/DART/examples/example3.m b/matlab/algorithms/DART/examples/example3.m
new file mode 100644
index 0000000..f6e360e
--- /dev/null
+++ b/matlab/algorithms/DART/examples/example3.m
@@ -0,0 +1,79 @@
+clear all;
+
+addpath('..');
+
+%
+% Example 3: parallel beam, 2D
+%
+
+% Configuration
+proj_count = 30;
+dart_iterations = 20;
+filename = 'cylinders.png';
+outdir = './';
+prefix = 'example3';
+rho = [0, 1];
+tau = 0.5;
+gpu_core = 0;
+
+% Load phantom.
+I = double(imread(filename)) / 255;
+
+% Create projection and volume geometries.
+det_count = size(I, 1);
+angles = linspace(0, pi - pi / proj_count, proj_count);
+proj_geom = astra_create_proj_geom('parallel', 1, det_count, angles);
+vol_geom = astra_create_vol_geom(det_count, det_count);
+
+% Create sinogram.
+[sinogram_id, sinogram] = astra_create_sino_cuda(I, proj_geom, vol_geom);
+astra_mex_data2d('delete', sinogram_id);
+
+%
+% DART
+%
+
+base.sinogram = sinogram;
+base.proj_geom = proj_geom;
+
+D                      = DARTalgorithm(base);
+
+%D.tomography           = TomographyDefault3D();
+D.tomography.t0        = 100;
+D.tomography.t         = 10;
+D.tomography.method    = 'SIRT_CUDA';
+D.tomography.proj_type = 'strip';
+D.tomography.gpu_core  = gpu_core;
+D.tomography.use_minc  = 'yes';
+% D.tomography.maxc      = 0.003; % Not a sensible value, just for demonstration.
+
+D.segmentation.rho     = rho;
+D.segmentation.tau     = tau;
+
+D.smoothing.b          = 0.1;
+D.smoothing.full3d     = 'yes';
+D.smoothing.gpu_core   = gpu_core;
+ 
+D.masking.random       = 0.1;
+D.masking.conn         = 6;
+D.masking.gpu_core     = gpu_core;
+
+D.output.directory     = outdir;
+D.output.pre           = [prefix '_'];
+D.output.save_images   = 'no';
+D.output.save_results  = {'stats', 'settings', 'S', 'V'};
+D.output.save_interval = dart_iterations;
+D.output.verbose       = 'yes';
+
+D.statistics.proj_diff = 'no';
+
+D.initialize();
+
+disp([D.output.directory D.output.pre]);
+
+D.iterate(dart_iterations);
+
+% Convert output of final iteration to png.
+load([outdir '/' prefix '_results_' num2str(dart_iterations) '.mat']);
+imwritesc(D.S, [outdir '/' prefix '_S.png']);
+imwritesc(D.V, [outdir '/' prefix '_V.png']);
diff --git a/matlab/algorithms/DART/examples/phantom3d.mat b/matlab/algorithms/DART/examples/phantom3d.mat
new file mode 100644
index 0000000..6d70c16
--- /dev/null
+++ b/matlab/algorithms/DART/examples/phantom3d.mat
diff --git a/matlab/mex/astra_mex.cpp b/matlab/mex/astra_mex.cpp
new file mode 100644
index 0000000..4b77f76
--- /dev/null
+++ b/matlab/mex/astra_mex.cpp
@@ -0,0 +1,121 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+#include <mex.h>
+#include "mexHelpFunctions.h"
+
+#include "astra/Globals.h"
+
+using namespace std;
+using namespace astra;
+
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex('credits');
+ * 
+ * Print Credits
+ */
+void astra_mex_credits(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	cout << "All Scale Tomographic Reconstruction Antwerp Toolbox (ASTRA-Toolbox) was developed at the University of Antwerp by" << endl;
+	cout << " * Joost Batenburg, PhD" << endl;
+	cout << " * Gert Merckx" << endl;
+	cout << " * Willem Jan Palenstijn" << endl;
+	cout << " * Tom Roelandts" << endl;
+	cout << " * Prof. Dr. Jan Sijbers" << endl;
+	cout << " * Wim van Aarle" << endl;
+	cout << " * Sander van der Maar" << endl;
+	cout << " * Gert Van Gompel, PhD" << endl;
+}
+
+//-----------------------------------------------------------------------------------------
+/** use_cuda = astra_mex('use_cuda');
+ * 
+ * Is CUDA enabled?
+ */
+void astra_mex_use_cuda(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(astra::cudaEnabled() ? 1 : 0);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** version_number = astra_mex('version');
+ * 
+ * Fetch the version number of the toolbox.
+ */
+void astra_mex_version(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(astra::getVersion());
+	} else {
+		cout << "astra toolbox version " << astra::getVersionString() << endl;
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+
+static void printHelp()
+{
+	mexPrintf("Please specify a mode of operation.\n");
+	mexPrintf("   Valid modes: version, use_cuda, credits\n");
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * ... = astra_mex(type,...);
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+				 int nrhs, const mxArray* prhs[])
+{
+
+	// INPUT0: Mode
+	string sMode = "";
+	if (1 <= nrhs) {
+		sMode = mex_util_get_string(prhs[0]);	
+	} else {
+		printHelp();
+		return;
+	}
+
+	// SWITCH (MODE)
+	if (sMode ==  std::string("version")) { 
+		astra_mex_version(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("use_cuda")) {	
+		astra_mex_use_cuda(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("credits")) {	
+		astra_mex_credits(nlhs, plhs, nrhs, prhs); 
+	} else {
+		printHelp();
+	}
+
+	return;
+}
+
+
diff --git a/matlab/mex/astra_mex_algorithm_c.cpp b/matlab/mex/astra_mex_algorithm_c.cpp
new file mode 100644
index 0000000..7476ba4
--- /dev/null
+++ b/matlab/mex/astra_mex_algorithm_c.cpp
@@ -0,0 +1,348 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+/** \file astra_mex_algorithm_c.cpp
+ *
+ *  \brief Creates and manages algorithms (reconstruction,projection,...).
+ */
+#include <mex.h>
+#include "mexHelpFunctions.h"
+
+#define USE_MATLAB_UNDOCUMENTED
+
+#ifdef USE_MATLAB_UNDOCUMENTED
+extern "C" { bool utIsInterruptPending(); }
+
+#ifdef __linux__
+#define USE_PTHREADS_CTRLC
+#include <pthread.h>
+#else
+#include <boost/thread.hpp>
+#endif
+
+#endif
+
+
+
+#include "astra/Globals.h"
+
+#include "astra/AstraObjectManager.h"
+#include "astra/AstraObjectFactory.h"
+
+#include "astra/XMLNode.h"
+#include "astra/XMLDocument.h"
+
+using namespace std;
+using namespace astra;
+//-----------------------------------------------------------------------------------------
+/** id = astra_mex_algorithm('create', cfg);
+ *
+ * Create and configure a new algorithm object.
+ * cfg: MATLAB struct containing the configuration parameters, see doxygen documentation for details.
+ * id: identifier of the algorithm object as it is now stored in the astra-library.
+ */
+void astra_mex_algorithm_create(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	if (!mxIsStruct(prhs[1])) {
+		mexErrMsgTxt("Argument 1 not a valid MATLAB struct. \n");
+	}
+
+	// turn MATLAB struct to an XML-based Config object
+	XMLDocument* xml = struct2XML("Algorithm", prhs[1]);
+	Config cfg;
+	cfg.self = xml->getRootNode();
+
+	CAlgorithm* pAlg = CAlgorithmFactory::getSingleton().create(cfg.self->getAttribute("type"));
+	if (!pAlg) {
+		delete xml;
+		mexErrMsgTxt("Unknown algorithm. \n");
+		return;
+	}
+
+	// create algorithm
+	if (!pAlg->initialize(cfg)) {
+		delete xml;
+		delete pAlg;
+		mexErrMsgTxt("Algorithm not initialized. \n");
+		return;
+	}
+
+	delete xml;
+
+	// store algorithm
+	int iIndex = CAlgorithmManager::getSingleton().store(pAlg);
+
+	// step4: set output
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(iIndex);
+	}
+
+}
+
+#ifdef USE_MATLAB_UNDOCUMENTED
+
+#ifndef USE_PTHREADS_CTRLC
+
+// boost version
+void waitForInterrupt_boost(CAlgorithm* _pAlg)
+{
+	boost::posix_time::milliseconds rel(2000);
+
+	while (!utIsInterruptPending()) {
+
+		// This is an interruption point. If the main thread calls
+		// interrupt(), this thread will terminate here.
+		boost::this_thread::sleep(rel);
+	}
+
+	//mexPrintf("Aborting. Please wait.\n");
+
+	// One last quick check to see if the algorithm already finished
+	boost::this_thread::interruption_point();
+
+	_pAlg->signalAbort();
+}
+
+#else
+
+// pthreads version
+void *waitForInterrupt_pthreads(void *threadid)
+{
+	CAlgorithm* _pAlg = (CAlgorithm*)threadid;
+
+	while (!utIsInterruptPending()) {
+		usleep(50000);
+		pthread_testcancel();
+	}
+
+	//mexPrintf("Aborting. Please wait.\n");
+
+	// One last quick check to see if the algorithm already finished
+	pthread_testcancel();
+
+	_pAlg->signalAbort();
+
+	return 0;
+}
+
+#endif
+#endif
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_algorithm('run', id); or astra_mex_algorithm('iterate', id, iterations);
+ *
+ * Run or do iterations on a certain algorithm.
+ * id: identifier of the algorithm object as stored in the astra-library.
+ * iterations: if the algorithm is iterative, this specifies the number of iterations to perform.
+ */
+void astra_mex_algorithm_run(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: get input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iAid = (int)(mxGetScalar(prhs[1]));
+	int iIterations = 0;
+	if (3 <= nrhs) {
+		iIterations = (int)(mxGetScalar(prhs[2]));
+	}
+
+	// step2: get algorithm object
+	CAlgorithm* pAlg = CAlgorithmManager::getSingleton().get(iAid);
+	if (!pAlg) {
+		mexErrMsgTxt("Invalid algorithm ID.\n");
+		return;
+	}
+	if (!pAlg->isInitialized()) {
+		mexErrMsgTxt("Algorithm not initialized. \n");
+		return;
+	}
+
+	// step3: perform actions
+#ifndef USE_MATLAB_UNDOCUMENTED
+
+	pAlg->run(iIterations);
+
+#elif defined(USE_PTHREADS_CTRLC)
+
+	// Start a new thread to watch if the user pressed Ctrl-C
+	pthread_t thread;
+	pthread_create(&thread, 0, waitForInterrupt_pthreads, (void*)pAlg);
+
+	pAlg->run(iIterations);
+
+	// kill the watcher thread in case it's still running
+	pthread_cancel(thread);
+	pthread_join(thread, 0);
+
+#else
+
+	// Start a new thread to watch if the user pressed Ctrl-C
+	boost::thread interruptThread(waitForInterrupt_boost, pAlg);
+
+	pAlg->run(iIterations);
+
+	// kill the watcher thread in case it's still running
+	interruptThread.interrupt();
+	interruptThread.join();
+
+#endif
+}
+//-----------------------------------------------------------------------------------------
+/** astra_mex_algorithm('get_res_norm', id);
+ *
+ * Get the L2-norm of the residual sinogram. Not all algorithms
+ * support this operation.
+ */
+void astra_mex_algorithm_get_res_norm(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: get input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iAid = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get algorithm object
+	CAlgorithm* pAlg = CAlgorithmManager::getSingleton().get(iAid);
+	if (!pAlg) {
+		mexErrMsgTxt("Invalid algorithm ID.\n");
+		return;
+	}
+	if (!pAlg->isInitialized()) {
+		mexErrMsgTxt("Algorithm not initialized. \n");
+		return;
+	}
+
+	CReconstructionAlgorithm2D* pAlg2D = dynamic_cast<CReconstructionAlgorithm2D*>(pAlg);
+	CReconstructionAlgorithm3D* pAlg3D = dynamic_cast<CReconstructionAlgorithm3D*>(pAlg);
+
+	float res = 0.0f;
+	bool ok;
+	if (pAlg2D)
+		ok = pAlg2D->getResidualNorm(res);
+	else if (pAlg3D)
+		ok = pAlg3D->getResidualNorm(res);
+	else
+		ok = false;
+
+	if (!ok) {
+		mexErrMsgTxt("Operation not supported.\n");
+		return;
+	}
+
+	plhs[0] = mxCreateDoubleScalar(res);
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_algorithm('delete', id1, id2, ...);
+ *
+ * Delete one or more algorithm objects currently stored in the astra-library. 
+ * id1, id2, ... : identifiers of the algorithm objects as stored in the astra-library.
+ */
+void astra_mex_algorithm_delete(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	// step1: get algorithm ID
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	for (int i = 1; i < nrhs; i++) {
+		int iAid = (int)(mxGetScalar(prhs[i]));
+		CAlgorithmManager::getSingleton().remove(iAid);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_algorithm('clear');
+ *
+ * Delete all algorithm objects currently stored in the astra-library.
+ */
+void astra_mex_algorithm_clear(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	CAlgorithmManager::getSingleton().clear();
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_algorithm('info');
+ *
+ * Print information about all the algorithm objects currently stored in the astra-library.
+ */
+void astra_mex_algorithm_info(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	mexPrintf("%s", astra::CAlgorithmManager::getSingleton().info().c_str());
+}
+
+//-----------------------------------------------------------------------------------------
+static void printHelp()
+{
+	mexPrintf("Please specify a mode of operation.\n");
+	mexPrintf("Valid modes: create, info, delete, clear, run/iterate, get_res_norm\n");
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * ... = astra_mex_algorithm(mode, ...);
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+				 int nrhs, const mxArray* prhs[])
+{
+	// INPUT: Mode
+	string sMode = "";
+	if (1 <= nrhs) {
+		sMode = mex_util_get_string(prhs[0]);	
+	} else {
+		printHelp();
+		return;
+	}
+
+	// SWITCH (MODE)
+	if (sMode == "create") {
+		astra_mex_algorithm_create(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "info") {
+		astra_mex_algorithm_info(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "delete") {
+		astra_mex_algorithm_delete(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "clear") {
+		astra_mex_algorithm_clear(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "run" || sMode == "iterate") {
+		astra_mex_algorithm_run(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "get_res_norm") {
+		astra_mex_algorithm_get_res_norm(nlhs, plhs, nrhs, prhs);
+	} else {
+		printHelp();
+	}
+	return;
+}
diff --git a/matlab/mex/astra_mex_algorithm_vc08.vcproj b/matlab/mex/astra_mex_algorithm_vc08.vcproj
new file mode 100644
index 0000000..baa4c44
--- /dev/null
+++ b/matlab/mex/astra_mex_algorithm_vc08.vcproj
@@ -0,0 +1,593 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="astra_mex_algorithm"
+	ProjectGUID="{056BF7A9-294D-487C-8CC3-BE629077CA94}"
+	RootNamespace="astraMatlab"
+	TargetFrameworkVersion="131072"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32.lib libmex.lib libmx.lib libut.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft;..\..\lib\win32"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64.lib libmex.lib libmx.lib libut.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft;..\..\lib\x64"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32.lib libmex.lib libmx.lib libut.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft;..\..\lib\win32"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="false"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;&quot;$(CUDA_INC_PATH)&quot;;..\..\lib\include;..\..\lib\include\cuda;..\..\include\;"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64.lib libmex.lib libmx.lib libut.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft;..\..\lib\x64"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32D.lib libmex.lib libmx.lib libut.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft;..\..\lib\win32"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;&quot;$(CUDA_INC_PATH)&quot;;..\..\lib\include;..\..\lib\include\cuda;..\..\include\;"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				BrowseInformation="1"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64D.lib libmex.lib libmx.lib libut.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft;..\..\lib\x64"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32D.lib libmex.lib libmx.lib libut.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft;..\..\lib\win32"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64D.lib libmex.lib libmx.lib libut.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft;..\..\lib\x64"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<File
+			RelativePath=".\astra_mex_algorithm_c.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.h"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/matlab/mex/astra_mex_c.cpp b/matlab/mex/astra_mex_c.cpp
new file mode 100644
index 0000000..0068664
--- /dev/null
+++ b/matlab/mex/astra_mex_c.cpp
@@ -0,0 +1,127 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+/** \file astra_mex_c.cpp
+ *
+ *  \brief Contains some basic "about" functions.
+ */
+
+#include <mex.h>
+#include "mexHelpFunctions.h"
+
+#include "astra/Globals.h"
+
+using namespace std;
+using namespace astra;
+
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex('credits');
+ * 
+ * Print Credits
+ */
+void astra_mex_credits(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	mexPrintf("All Scale Tomographic Reconstruction Antwerp Toolbox (ASTRA-Toolbox) was developed at the University of Antwerp by\n");
+	mexPrintf(" * Prof. dr. Joost Batenburg\n");
+	mexPrintf(" * Andrei Dabravolski\n");
+	mexPrintf(" * Gert Merckx\n");
+	mexPrintf(" * Willem Jan Palenstijn\n");
+	mexPrintf(" * Tom Roelandts\n");
+	mexPrintf(" * Prof. dr. Jan Sijbers\n");
+	mexPrintf(" * dr. Wim van Aarle\n");
+	mexPrintf(" * Sander van der Maar\n");
+	mexPrintf(" * dr. Gert Van Gompel\n");
+}
+
+//-----------------------------------------------------------------------------------------
+/** use_cuda = astra_mex('use_cuda');
+ * 
+ * Is CUDA enabled?
+ */
+void astra_mex_use_cuda(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(astra::cudaEnabled() ? 1 : 0);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** version_number = astra_mex('version');
+ * 
+ * Fetch the version number of the toolbox.
+ */
+void astra_mex_version(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(astra::getVersion());
+	} else {
+		mexPrintf("astra toolbox version %s\n", astra::getVersionString());
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+
+static void printHelp()
+{
+	mexPrintf("Please specify a mode of operation.\n");
+	mexPrintf("   Valid modes: version, use_cuda, credits\n");
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * ... = astra_mex(type,...);
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+				 int nrhs, const mxArray* prhs[])
+{
+
+	// INPUT0: Mode
+	string sMode = "";
+	if (1 <= nrhs) {
+		sMode = mex_util_get_string(prhs[0]);	
+	} else {
+		printHelp();
+		return;
+	}
+
+	// SWITCH (MODE)
+	if (sMode ==  std::string("version")) { 
+		astra_mex_version(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("use_cuda")) {	
+		astra_mex_use_cuda(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("credits")) {	
+		astra_mex_credits(nlhs, plhs, nrhs, prhs); 
+	} else {
+		printHelp();
+	}
+
+	return;
+}
+
+
diff --git a/matlab/mex/astra_mex_data2d_c.cpp b/matlab/mex/astra_mex_data2d_c.cpp
new file mode 100644
index 0000000..99fb38e
--- /dev/null
+++ b/matlab/mex/astra_mex_data2d_c.cpp
@@ -0,0 +1,667 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+/** \file astra_mex_data2d_c.cpp
+ *
+ *  \brief Creates, manages and manipulates 2D volume and projection data objects.
+ */
+#include <mex.h>
+#include "mexHelpFunctions.h"
+
+#include <list>
+
+#include "astra/Globals.h"
+
+#include "astra/AstraObjectManager.h"
+
+#include "astra/Float32ProjectionData2D.h"
+#include "astra/Float32VolumeData2D.h"
+#include "astra/SparseMatrixProjectionGeometry2D.h"
+#include "astra/FanFlatProjectionGeometry2D.h"
+#include "astra/FanFlatVecProjectionGeometry2D.h"
+
+using namespace std;
+using namespace astra;
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_data2d('delete', id1, id2, ...);
+ *
+ * Delete one or more data objects currently stored in the astra-library.
+ * id1, id2, ... : identifiers of the 2d data objects as stored in the astra-library.
+ */
+void astra_mex_data2d_delete(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: read input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	// step2: delete all specified data objects
+	for (int i = 1; i < nrhs; i++) {
+		int iDataID = (int)(mxGetScalar(prhs[i]));
+		CData2DManager::getSingleton().remove(iDataID);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_data2d('clear');
+ *
+ * Delete all data objects currently stored in the astra-library.
+ */
+void astra_mex_data2d_clear(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	CData2DManager::getSingleton().clear();
+}
+
+//-----------------------------------------------------------------------------------------
+/** id = astra_mex_data2d('create', datatype, geometry, data);
+ *   
+ * Create a new data 2d object in the astra-library.
+ * type: '-vol' for volume data, '-sino' for projection data
+ * geom: MATLAB struct with the geometry for the data
+ * data: Optional. Can be either a MATLAB matrix containing the data. In that case the dimensions 
+ * should match that of the geometry of the object.  It can also be a single value, in which case 
+ * the entire data will be set to that value.  If this isn't specified all values are set to 0.
+ * id: identifier of the 2d data object as it is now stored in the astra-library.
+ */
+void astra_mex_data2d_create(int& nlhs, mxArray* plhs[], int& nrhs, const mxArray* prhs[])
+{ 
+	// step1: get datatype
+	if (nrhs < 3) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	string sDataType = mex_util_get_string(prhs[1]);	
+	CFloat32Data2D* pDataObject2D = NULL;
+
+	if (nrhs >= 4 && !(mex_is_scalar(prhs[3])|| mxIsDouble(prhs[3]) || mxIsLogical(prhs[3]) || mxIsSingle(prhs[3]) )) {
+		mexErrMsgTxt("Data must be single, double or logical.");
+		return;
+	}
+
+	// SWITCH DataType
+	if (sDataType == "-vol") {
+		// Read geometry
+		if (!mxIsStruct(prhs[2])) {
+			mexErrMsgTxt("Argument 3 is not a valid MATLAB struct.\n");
+		}
+		XMLDocument* xml = struct2XML(string("VolumeGeometry"), prhs[2]);
+		if (!xml)
+			return;
+		Config cfg;
+		cfg.self = xml->getRootNode();
+		CVolumeGeometry2D* pGeometry = new CVolumeGeometry2D();
+		if (!pGeometry->initialize(cfg)) {
+			mexErrMsgTxt("Geometry class not initialized. \n");
+			delete xml;
+			delete pGeometry;
+			return;
+		}
+		// If data is specified, check dimensions
+		if (nrhs >= 4 && !mex_is_scalar(prhs[3])) {
+			if (pGeometry->getGridColCount() != mxGetN(prhs[3]) || pGeometry->getGridRowCount() != mxGetM(prhs[3])) {
+				mexErrMsgTxt("The dimensions of the data do not match those specified in the geometry. \n");
+				delete xml;
+				delete pGeometry;
+				return;
+			}
+		}
+		// Initialize data object
+		pDataObject2D = new CFloat32VolumeData2D(pGeometry);		
+		delete pGeometry;
+		delete xml;
+	}
+	else if (sDataType == "-sino") {
+		// Read geometry
+		if (!mxIsStruct(prhs[2])) {
+			mexErrMsgTxt("Argument 3 is not a valid MATLAB struct.\n");
+		}
+		XMLDocument* xml = struct2XML("ProjectionGeometry", prhs[2]);
+		if (!xml)
+			return;
+		Config cfg;
+		cfg.self = xml->getRootNode();
+		// FIXME: Change how the base class is created. (This is duplicated
+		// in 'change_geometry' and Projector2D.cpp.)
+		std::string type = cfg.self->getAttribute("type");
+		CProjectionGeometry2D* pGeometry;
+		if (type == "sparse_matrix") {
+			pGeometry = new CSparseMatrixProjectionGeometry2D();
+		} else if (type == "fanflat") {
+			//CFanFlatProjectionGeometry2D* pFanFlatProjectionGeometry = new CFanFlatProjectionGeometry2D();
+			//pFanFlatProjectionGeometry->initialize(Config(node));
+			//m_pProjectionGeometry = pFanFlatProjectionGeometry;
+			pGeometry = new CFanFlatProjectionGeometry2D();	
+		} else if (type == "fanflat_vec") {
+			pGeometry = new CFanFlatVecProjectionGeometry2D();	
+		} else {
+			pGeometry = new CParallelProjectionGeometry2D();	
+		}
+		if (!pGeometry->initialize(cfg)) {
+			mexErrMsgTxt("Geometry class not initialized. \n");
+			delete pGeometry;
+			delete xml;
+			return;
+		}
+		// If data is specified, check dimensions
+		if (nrhs >= 4 && !mex_is_scalar(prhs[3])) {
+			if (pGeometry->getDetectorCount() != mxGetN(prhs[3]) || pGeometry->getProjectionAngleCount() != mxGetM(prhs[3])) {
+				mexErrMsgTxt("The dimensions of the data do not match those specified in the geometry. \n");
+				delete pGeometry;
+				delete xml;
+				return;
+			}
+		}
+		// Initialize data object
+		pDataObject2D = new CFloat32ProjectionData2D(pGeometry);
+		delete pGeometry;
+		delete xml;
+	}
+	else {
+		mexErrMsgTxt("Invalid datatype.  Please specify '-vol' or '-sino'. \n");
+		return;
+	}
+
+	// Check initialization
+	if (!pDataObject2D->isInitialized()) {
+		mexErrMsgTxt("Couldn't initialize data object.\n");
+		delete pDataObject2D;
+		return;
+	}
+
+	// Store data
+	if (nrhs == 3) {
+		for (int i = 0; i < pDataObject2D->getSize(); ++i) {
+			pDataObject2D->getData()[i] = 0.0f;
+		}
+	}
+
+	// Store data
+	if (nrhs >= 4) {
+		// fill with scalar value
+		if (mex_is_scalar(prhs[3])) {
+			float32 fValue = (float32)mxGetScalar(prhs[3]);
+			for (int i = 0; i < pDataObject2D->getSize(); ++i) {
+				pDataObject2D->getData()[i] = fValue;
+			}
+		}
+		// fill with array value
+		else {
+			const mwSize* dims = mxGetDimensions(prhs[3]);
+			// Check Data dimensions
+			if (pDataObject2D->getWidth() != mxGetN(prhs[3]) || pDataObject2D->getHeight() != mxGetM(prhs[3])) {
+				mexErrMsgTxt("The dimensions of the data do not match those specified in the geometry. \n");
+				return;
+			}
+
+			// logical data		
+			if (mxIsLogical(prhs[3])) {
+				bool* pbMatlabData = mxGetLogicals(prhs[3]);
+				int i = 0;
+				int col, row;
+				for (col = 0; col < dims[1]; ++col) {
+					for (row = 0; row < dims[0]; ++row) {
+						pDataObject2D->getData2D()[row][col] = (float32)pbMatlabData[i];
+						++i;
+					}
+				}
+			// double data
+			} else if (mxIsDouble(prhs[3])) {
+				double* pdMatlabData = mxGetPr(prhs[3]);
+				int i = 0;
+				int col, row;
+				for (col = 0; col < dims[1]; ++col) {
+					for (row = 0; row < dims[0]; ++row) {
+						pDataObject2D->getData2D()[row][col] = pdMatlabData[i];
+						++i;
+					}
+				}
+			// single data
+			} else if (mxIsSingle(prhs[3])) {
+				const float* pfMatlabData = (const float *)mxGetData(prhs[3]);
+				int i = 0;
+				int col, row;
+				for (col = 0; col < dims[1]; ++col) {
+					for (row = 0; row < dims[0]; ++row) {
+						pDataObject2D->getData2D()[row][col] = pfMatlabData[i];
+						++i;
+					}
+				}
+			} else {
+				ASTRA_ASSERT(false);
+			}
+		}
+	}
+
+	// step4: store data object
+	int iIndex = CData2DManager::getSingleton().store(pDataObject2D);
+
+	// step5: return data id
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(iIndex);
+	}
+
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_data2d('store', id, data);
+ *
+ * Store data in an existing astra 2d dataobject with a MATLAB matrix or with a scalar value. 
+ * id: identifier of the 2d data object as stored in the astra-library.
+ * data: can be either a MATLAB matrix containing the data. In that case the dimensions should match that of the geometry of the object.  It can also be a single value, in which case the entire data will be set to that value.
+ */
+void astra_mex_data2d_store(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	// step1: input
+	if (nrhs < 3) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	if (!mxIsDouble(prhs[1])) {
+		mexErrMsgTxt("Identifier should be a scalar value. \n");
+		return;
+	}
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+
+	if (!(mex_is_scalar(prhs[2]) || mxIsDouble(prhs[2]) || mxIsLogical(prhs[2]) || mxIsSingle(prhs[2]))) {
+		mexErrMsgTxt("Data must be single, double or logical.");
+		return;
+	}
+
+	// step2: get data object
+	CFloat32Data2D* pDataObject = astra::CData2DManager::getSingleton().get(iDataID);
+	if (!pDataObject || !pDataObject->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+	
+	// step3: insert data
+	// fill with scalar value
+	if (mex_is_scalar(prhs[2])) {
+		float32 fValue = (float32)mxGetScalar(prhs[2]);
+		for (int i = 0; i < pDataObject->getSize(); ++i) {
+			pDataObject->getData()[i] = fValue;
+		}
+	} else {
+		// Check Data dimensions
+		if (pDataObject->getWidth() != mxGetN(prhs[2]) || pDataObject->getHeight() != mxGetM(prhs[2])) {
+			mexErrMsgTxt("The dimensions of the data do not match those specified in the geometry. \n");
+			return;
+		}
+		const mwSize* dims = mxGetDimensions(prhs[2]);
+
+		// logical data		
+		if (mxIsLogical(prhs[2])) {
+			bool* pbMatlabData = mxGetLogicals(prhs[2]);
+			int i = 0;
+			int col, row;
+			for (col = 0; col < dims[1]; ++col) {
+				for (row = 0; row < dims[0]; ++row) {
+					pDataObject->getData2D()[row][col] = (float32)pbMatlabData[i];
+					++i;
+				}
+			}
+		// double data
+		} else if (mxIsDouble(prhs[2])) {
+			double* pdMatlabData = mxGetPr(prhs[2]);
+			int i = 0;
+			int col, row;
+			for (col = 0; col < dims[1]; ++col) {
+				for (row = 0; row < dims[0]; ++row) {
+					pDataObject->getData2D()[row][col] = pdMatlabData[i];
+					++i;
+				}
+			}
+		// single data
+		} else if (mxIsSingle(prhs[2])) {
+			const float* pfMatlabData = (const float *)mxGetData(prhs[2]);
+			int i = 0;
+			int col, row;
+			for (col = 0; col < dims[1]; ++col) {
+				for (row = 0; row < dims[0]; ++row) {
+					pDataObject->getData2D()[row][col] = pfMatlabData[i];
+					++i;
+				}
+			}
+		} else {
+			ASTRA_ASSERT(false);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** geom = astra_mex_data2d('get_geometry', id);
+ * 
+ * Fetch the geometry of a 2d data object stored in the astra-library.
+ * id: identifier of the 2d data object as stored in the astra-library.
+ * geom: MATLAB-struct containing information about the used geometry.
+ */
+void astra_mex_data2d_get_geometry(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	if (!mxIsDouble(prhs[1])) {
+		mexErrMsgTxt("Identifier should be a scalar value. \n");
+		return;
+	}
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get data object
+	CFloat32Data2D* pDataObject = astra::CData2DManager::getSingleton().get(iDataID);
+	if (!pDataObject || !pDataObject->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+
+	// create output
+	if (1 <= nlhs) {
+		if (pDataObject->getType() == CFloat32Data2D::PROJECTION) {
+			CFloat32ProjectionData2D* pDataObject2 = dynamic_cast<CFloat32ProjectionData2D*>(pDataObject);
+			plhs[0] = createProjectionGeometryStruct(pDataObject2->getGeometry());
+		}
+		else if (pDataObject->getType() == CFloat32Data2D::VOLUME) {
+			CFloat32VolumeData2D* pDataObject2 = dynamic_cast<CFloat32VolumeData2D*>(pDataObject);
+			plhs[0] = createVolumeGeometryStruct(pDataObject2->getGeometry());
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_data2d('change_geometry', id, geom);
+ *
+ * Change the associated geometry of a 2d data object (volume or sinogram)
+ * id: identifier of the 2d data object as stored in the astra-library.
+ * geom: the new geometry struct, as created by astra_create_vol/proj_geom
+ */
+void astra_mex_data2d_change_geometry(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: check input
+	if (nrhs < 3) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	if (!mxIsDouble(prhs[1])) {
+		mexErrMsgTxt("Identifier should be a scalar value. \n");
+		return;
+	}
+
+	// step2: get data object
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+	CFloat32Data2D* pDataObject = astra::CData2DManager::getSingleton().get(iDataID);
+	if (!pDataObject || !pDataObject->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+
+	CFloat32ProjectionData2D* pSinogram = dynamic_cast<CFloat32ProjectionData2D*>(pDataObject);
+
+	if (pSinogram) {
+		// Projection data
+
+		// Read geometry
+		if (!mxIsStruct(prhs[2])) {
+			mexErrMsgTxt("Argument 3 is not a valid MATLAB struct.\n");
+		}
+		XMLDocument* xml = struct2XML("ProjectionGeometry", prhs[2]);
+		Config cfg;
+		cfg.self = xml->getRootNode();
+		// FIXME: Change how the base class is created. (This is duplicated
+		// in 'create' and Projector2D.cpp.)
+		std::string type = cfg.self->getAttribute("type");
+		CProjectionGeometry2D* pGeometry;
+		if (type == "sparse_matrix") {
+			pGeometry = new CSparseMatrixProjectionGeometry2D();
+		} else if (type == "fanflat") {
+			//CFanFlatProjectionGeometry2D* pFanFlatProjectionGeometry = new CFanFlatProjectionGeometry2D();
+			//pFanFlatProjectionGeometry->initialize(Config(node));
+			//m_pProjectionGeometry = pFanFlatProjectionGeometry;
+			pGeometry = new CFanFlatProjectionGeometry2D();	
+		} else if (type == "fanflat_vec") {
+			pGeometry = new CFanFlatVecProjectionGeometry2D();	
+		} else {
+			pGeometry = new CParallelProjectionGeometry2D();	
+		}
+		if (!pGeometry->initialize(cfg)) {
+			mexErrMsgTxt("Geometry class not initialized. \n");
+			delete pGeometry;
+			delete xml;
+			return;
+		}
+		// If data is specified, check dimensions
+		if (pGeometry->getDetectorCount() != pSinogram->getDetectorCount() || pGeometry->getProjectionAngleCount() != pSinogram->getAngleCount()) {
+			mexErrMsgTxt("The dimensions of the data do not match those specified in the geometry. \n");
+			delete pGeometry;
+			delete xml;
+			return;
+		}
+
+		// If ok, change geometry
+		pSinogram->changeGeometry(pGeometry);
+		delete pGeometry;
+		delete xml;
+
+		return;
+	}
+
+	CFloat32VolumeData2D* pVolume = dynamic_cast<CFloat32VolumeData2D*>(pDataObject);
+
+	if (pVolume) {
+		// Volume data
+
+		// Read geometry
+		if (!mxIsStruct(prhs[2])) {
+			mexErrMsgTxt("Argument 3 is not a valid MATLAB struct.\n");
+		}
+		XMLDocument* xml = struct2XML(string("VolumeGeometry"), prhs[2]);
+		Config cfg;
+		cfg.self = xml->getRootNode();
+		CVolumeGeometry2D* pGeometry = new CVolumeGeometry2D();
+		if (!pGeometry->initialize(cfg)) {
+			mexErrMsgTxt("Geometry class not initialized. \n");
+			delete xml;
+			delete pGeometry;
+			return;
+		}
+		// If data is specified, check dimensions
+		if (pGeometry->getGridColCount() != pVolume->getWidth() || pGeometry->getGridRowCount() != pVolume->getHeight()) {
+			mexErrMsgTxt("The dimensions of the data do not match those specified in the geometry. \n");
+			delete xml;
+			delete pGeometry;
+			return;
+		}
+
+		// If ok, change geometry
+		pVolume->changeGeometry(pGeometry);
+		delete xml;
+		delete pGeometry;
+
+	}
+
+	mexErrMsgTxt("Data object not found or not initialized properly.\n");
+	return;
+}
+
+//-----------------------------------------------------------------------------------------
+/** data = astra_mex_data2d('get', id);
+ *
+ * Fetch data from the astra-library to a MATLAB matrix.
+ * id: identifier of the 2d data object as stored in the astra-library.
+ * data: MATLAB data
+ */
+void astra_mex_data2d_get(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: check input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	if (!mxIsDouble(prhs[1])) {
+		mexErrMsgTxt("Identifier should be a scalar value. \n");
+		return;
+	}
+
+	// step2: get data object
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+	CFloat32Data2D* pDataObject = astra::CData2DManager::getSingleton().get(iDataID);
+	if (!pDataObject || !pDataObject->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+
+	// create output
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleMatrix(pDataObject->getHeight(),	// # rows
+									   pDataObject->getWidth(),		// # cols
+									   mxREAL);						// datatype 64-bits
+		double* out = mxGetPr(plhs[0]);
+		int i = 0;
+		int row, col;
+		for (col = 0; col < pDataObject->getWidth(); ++col) {
+			for (row = 0; row < pDataObject->getHeight(); ++row) {
+				out[i] = pDataObject->getData2D()[row][col];
+				++i;
+			}
+		}	
+	}
+	
+}
+
+//-----------------------------------------------------------------------------------------
+/** data = astra_mex_data2d('get_single', id);
+ *
+ * Fetch data from the astra-library to a MATLAB matrix.
+ * id: identifier of the 2d data object as stored in the astra-library.
+ * data: MATLAB data
+ */
+void astra_mex_data2d_get_single(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: check input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	if (!mxIsDouble(prhs[1])) {
+		mexErrMsgTxt("Identifier should be a scalar value. \n");
+		return;
+	}
+
+	// step2: get data object
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+	CFloat32Data2D* pDataObject = astra::CData2DManager::getSingleton().get(iDataID);
+	if (!pDataObject || !pDataObject->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+
+	// create output
+	if (1 <= nlhs) {
+		mwSize dims[2];
+		dims[0] = pDataObject->getHeight();
+		dims[1] = pDataObject->getWidth();
+		plhs[0] = mxCreateNumericArray(2, dims, mxSINGLE_CLASS, mxREAL);
+		float* out = (float *)mxGetData(plhs[0]);
+		int i = 0;
+		int row, col;
+		for (col = 0; col < pDataObject->getWidth(); ++col) {
+			for (row = 0; row < pDataObject->getHeight(); ++row) {
+				out[i] = pDataObject->getData2D()[row][col];
+				++i;
+			}
+		}	
+	}
+	
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_data2d('info');
+ * 
+ * Print information about all the 2d data objects currently stored in the astra-library.
+ */
+void astra_mex_data2d_info(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	mexPrintf("%s", astra::CData2DManager::getSingleton().info().c_str());
+}
+
+//-----------------------------------------------------------------------------------------
+
+static void printHelp()
+{
+	mexPrintf("Please specify a mode of operation.\n");
+	mexPrintf("Valid modes: get, get_single, delete, clear, set/store, create, get_geometry, change_geometry, info\n");
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * ... = astra_mex_data2d(type,...);
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+				 int nrhs, const mxArray* prhs[])
+{
+
+	// INPUT0: Mode
+	string sMode = "";
+	if (1 <= nrhs) {
+		sMode = mex_util_get_string(prhs[0]);	
+	} else {
+		printHelp();
+		return;
+	}
+
+	// SWITCH (MODE)
+	if (sMode ==  std::string("get")) { 
+		astra_mex_data2d_get(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("get_single")) { 
+		astra_mex_data2d_get_single(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("delete")) {	
+		astra_mex_data2d_delete(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == "clear") {
+		astra_mex_data2d_clear(nlhs, plhs, nrhs, prhs);
+	} else if (sMode ==  std::string("store") ||
+	           sMode ==  std::string("set")) {	
+		astra_mex_data2d_store(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == std::string("create")) { 
+		astra_mex_data2d_create(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == std::string("get_geometry")) { 
+		astra_mex_data2d_get_geometry(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == std::string("change_geometry")) { 
+		astra_mex_data2d_change_geometry(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == std::string("info")) { 
+		astra_mex_data2d_info(nlhs, plhs, nrhs, prhs); 
+	} else {
+		printHelp();
+	}
+
+	return;
+}
+
+
diff --git a/matlab/mex/astra_mex_data2d_vc08.vcproj b/matlab/mex/astra_mex_data2d_vc08.vcproj
new file mode 100644
index 0000000..8f1fc13
--- /dev/null
+++ b/matlab/mex/astra_mex_data2d_vc08.vcproj
@@ -0,0 +1,591 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="astra_mex_data2d"
+	ProjectGUID="{E4092269-B19C-46F7-A84E-4F146CC70E44}"
+	RootNamespace="astraMatlab"
+	TargetFrameworkVersion="131072"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;&quot;$(CUDA_INC_PATH)&quot;;..\..\lib\include;..\..\lib\include\cuda;..\..\include\;"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="&quot;$(CUDA_INC_PATH)&quot;;$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				BrowseInformation="1"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<File
+			RelativePath=".\astra_mex_data2d_c.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.h"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/matlab/mex/astra_mex_data3d_c.cpp b/matlab/mex/astra_mex_data3d_c.cpp
new file mode 100644
index 0000000..1af8844
--- /dev/null
+++ b/matlab/mex/astra_mex_data3d_c.cpp
@@ -0,0 +1,1036 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+/** \file astra_mex_data3d_c.cpp
+ *
+ *  \brief Creates, manages and manipulates 3D volume and projection data objects.
+ */
+#include <mex.h>
+#include "mexHelpFunctions.h"
+
+#include <list>
+
+#include "astra/Globals.h"
+
+#include "astra/AstraObjectManager.h"
+
+#include "astra/Float32ProjectionData2D.h"
+#include "astra/Float32VolumeData2D.h"
+#include "astra/Float32ProjectionData3D.h"
+#include "astra/Float32ProjectionData3DMemory.h"
+#include "astra/Float32VolumeData3D.h"
+#include "astra/Float32VolumeData3DMemory.h"
+#include "astra/ParallelProjectionGeometry3D.h"
+#include "astra/ParallelVecProjectionGeometry3D.h"
+#include "astra/ConeProjectionGeometry3D.h"
+#include "astra/ConeVecProjectionGeometry3D.h"
+
+using namespace std;
+using namespace astra;
+
+
+
+//-----------------------------------------------------------------------------------------
+/**
+ * id = astra_mex_io_data('create', datatype, geometry, data);
+ *        datatype: ['-vol','-sino','-sinocone'] 
+ */
+void astra_mex_data3d_create(int& nlhs, mxArray* plhs[], int& nrhs, const mxArray* prhs[])
+{ 
+	// step1: get datatype
+	if (nrhs < 3) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	string sDataType = mex_util_get_string(prhs[1]);	
+	CFloat32Data3DMemory* pDataObject3D = NULL;
+
+	if (nrhs >= 4 && !(mex_is_scalar(prhs[3]) || mxIsDouble(prhs[3]) || mxIsSingle(prhs[3]))) {
+		mexErrMsgTxt("Data must be single or double.");
+		return;
+	}
+
+	mwSize dims[3];
+
+	// SWITCH DataType
+	if (sDataType == "-vol") {
+
+		// Read geometry
+		if (!mxIsStruct(prhs[2])) {
+			mexErrMsgTxt("Argument 3 is not a valid MATLAB struct.\n");
+		}
+		Config cfg;
+		XMLDocument* xml = struct2XML("VolumeGeometry", prhs[2]);
+		if (!xml)
+			return;
+		cfg.self = xml->getRootNode();
+		CVolumeGeometry3D* pGeometry = new CVolumeGeometry3D();
+		if (!pGeometry->initialize(cfg)) {
+			mexErrMsgTxt("Geometry class not initialized. \n");
+			delete pGeometry;
+			delete xml;
+			return;
+		}
+		delete xml;
+
+		// If data is specified, check dimensions
+		if (nrhs >= 4 && !mex_is_scalar(prhs[3])) {
+			get3DMatrixDims(prhs[3], dims);
+			if (pGeometry->getGridColCount() != dims[0] || pGeometry->getGridRowCount() != dims[1] || pGeometry->getGridSliceCount() != dims[2]) {
+				mexErrMsgTxt("The dimensions of the data do not match those specified in the geometry. \n");
+				delete pGeometry;
+				return;
+			}
+		}
+
+		// Initialize data object
+		pDataObject3D = new CFloat32VolumeData3DMemory(pGeometry);		
+		delete pGeometry;
+	}
+
+	else if (sDataType == "-sino" || sDataType == "-proj3d") {
+
+		// Read geometry
+		if (!mxIsStruct(prhs[2])) {
+			mexErrMsgTxt("Argument 3 is not a valid MATLAB struct.\n");
+		}
+		XMLDocument* xml = struct2XML("ProjectionGeometry", prhs[2]);
+		if (!xml)
+			return;
+		Config cfg;
+		cfg.self = xml->getRootNode();
+
+		// FIXME: Change how the base class is created. (This is duplicated
+		// in Projector2D.cpp.)
+		std::string type = cfg.self->getAttribute("type");
+		CProjectionGeometry3D* pGeometry = 0;
+		if (type == "parallel3d") {
+			pGeometry = new CParallelProjectionGeometry3D();
+		} else if (type == "parallel3d_vec") {
+			pGeometry = new CParallelVecProjectionGeometry3D();
+		} else if (type == "cone") {
+			pGeometry = new CConeProjectionGeometry3D();
+		} else if (type == "cone_vec") {
+			pGeometry = new CConeVecProjectionGeometry3D();
+		} else {
+			mexErrMsgTxt("Invalid geometry type.\n");
+			return;
+		}
+
+		if (!pGeometry->initialize(cfg)) {
+			mexErrMsgTxt("Geometry class not initialized. \n");
+			delete pGeometry;
+			delete xml;
+			return;
+		}
+		delete xml;
+
+		// If data is specified, check dimensions
+		if (nrhs >= 4 && !mex_is_scalar(prhs[3])) {
+			get3DMatrixDims(prhs[3], dims);
+			if (pGeometry->getDetectorColCount() != dims[0] || pGeometry->getProjectionCount() != dims[1] || pGeometry->getDetectorRowCount() != dims[2]) {
+				mexErrMsgTxt("The dimensions of the data do not match those specified in the geometry. \n");
+				delete pGeometry;
+				return;
+			}
+		}
+
+		// Initialize data object
+		pDataObject3D = new CFloat32ProjectionData3DMemory(pGeometry);		
+	}
+
+	else if (sDataType == "-sinocone") {
+		// Read geometry
+		if (!mxIsStruct(prhs[2])) {
+			mexErrMsgTxt("Argument 3 is not a valid MATLAB struct.\n");
+		}
+		XMLDocument* xml = struct2XML("ProjectionGeometry", prhs[2]);
+		if (!xml)
+			return;
+		Config cfg;
+		cfg.self = xml->getRootNode();
+		CConeProjectionGeometry3D* pGeometry = new CConeProjectionGeometry3D();
+		if (!pGeometry->initialize(cfg)) {
+			mexErrMsgTxt("Geometry class not initialized. \n");
+			delete xml;
+			delete pGeometry;
+			return;
+		}
+		delete xml;
+		// If data is specified, check dimensions
+		if (nrhs >= 4 && !mex_is_scalar(prhs[3])) {
+			get3DMatrixDims(prhs[3], dims);
+			if (pGeometry->getDetectorRowCount() != dims[2] || pGeometry->getProjectionCount() != dims[1] || pGeometry->getDetectorColCount() != dims[0]) {
+				mexErrMsgTxt("The dimensions of the data do not match those specified in the geometry. \n");
+				delete pGeometry;
+				return;
+			}
+		}
+		// Initialize data object
+		pDataObject3D = new CFloat32ProjectionData3DMemory(pGeometry);		
+		delete pGeometry;
+	}
+	else {
+		mexErrMsgTxt("Invalid datatype.  Please specify '-vol' or '-proj3d'. \n");
+		return;
+	}
+
+	// Check initialization
+	if (!pDataObject3D->isInitialized()) {
+		mexErrMsgTxt("Couldn't initialize data object.\n");
+		delete pDataObject3D;
+		return;
+	}
+
+	// Store data
+
+	// fill with scalar value
+	if (nrhs < 4 || mex_is_scalar(prhs[3])) {
+		float32 fValue = 0.0f;
+		if (nrhs >= 4)
+			fValue = (float32)mxGetScalar(prhs[3]);
+		for (int i = 0; i < pDataObject3D->getSize(); ++i) {
+			pDataObject3D->getData()[i] = fValue;
+		}
+	}
+	// fill with array value
+	else if (mxIsDouble(prhs[3])) {
+		double* pdMatlabData = mxGetPr(prhs[3]);
+		int i = 0;
+		int col, row, slice;
+		for (slice = 0; slice < dims[2]; ++slice) {
+			for (row = 0; row < dims[1]; ++row) {
+				for (col = 0; col < dims[0]; ++col) {
+					// TODO: Benchmark and remove triple indexing?
+					pDataObject3D->getData3D()[slice][row][col] = pdMatlabData[i];
+					++i;
+				}
+			}
+		}
+	}
+	else if (mxIsSingle(prhs[3])) {
+		const float* pfMatlabData = (const float*)mxGetData(prhs[3]);
+		int i = 0;
+		int col, row, slice;
+		for (slice = 0; slice < dims[2]; ++slice) {
+			for (row = 0; row < dims[1]; ++row) {
+				for (col = 0; col < dims[0]; ++col) {
+					// TODO: Benchmark and remove triple indexing?
+					pDataObject3D->getData3D()[slice][row][col] = pfMatlabData[i];
+					++i;
+				}
+			}
+		}
+	}
+	pDataObject3D->updateStatistics();
+
+	// step4: store data object
+	int iIndex = CData3DManager::getSingleton().store(pDataObject3D);
+
+	// step5: return data id
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(iIndex);
+	}
+
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * [id] = astra_mex_io_data('create_cache', config);
+ */
+void astra_mex_data3d_create_cache(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+//	if (nrhs < 2) {
+//		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+//		return;
+//	}
+//
+//	if (!mxIsStruct(prhs[1])) {
+//		mexErrMsgTxt("Argument 1 not a valid MATLAB struct. \n");
+//	}
+//
+//	// turn MATLAB struct to an XML-based Config object
+//	XMLDocument* xml = struct2XML("Data3D", prhs[1]);
+//	Config cfg;
+//	cfg.self = xml->getRootNode();
+//
+//	// create dataobject
+//	string sType = cfg.self->getAttribute("type");
+//	int iIndex;
+//	if (sType == "ProjectionCached") {
+//		CFloat32ProjectionData3DCached* pData = new CFloat32ProjectionData3DCached(cfg);
+//		iIndex = CData3DManager::getSingleton().store(pData);
+//	}
+////	else if (sType == "VolumeCached") {
+////		CFloat32VolumeData3DCached* pData = new CFloat32VolumeData3DCached(cfg);
+////		pData->initialize(cfg);
+////		iIndex = CData3DManager::getSingleton().store(pData);
+////	}
+//
+//	// step4: set output
+//	if (1 <= nlhs) {
+//		plhs[0] = mxCreateDoubleScalar(iIndex);
+//	}
+
+}
+
+
+//-----------------------------------------------------------------------------------------
+/**
+ * data = astra_mex_data3d('get', id);
+ * 
+ * Fetch data from the astra-library to a MATLAB matrix.
+ * id: identifier of the 3d data object as stored in the astra-library.
+ * data: MATLAB data
+
+ */
+void astra_mex_data3d_get(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get data object
+	CFloat32Data3DMemory* pDataObject = dynamic_cast<CFloat32Data3DMemory*>(astra::CData3DManager::getSingleton().get(iDataID));
+	if (!pDataObject || !pDataObject->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+
+	// create output
+	if (1 <= nlhs) {
+		mwSize dims[3];
+		dims[0] = pDataObject->getWidth();
+		dims[1] = pDataObject->getHeight();
+		dims[2] = pDataObject->getDepth();
+
+		plhs[0] = mxCreateNumericArray(3, dims, mxDOUBLE_CLASS, mxREAL);
+		double* out = mxGetPr(plhs[0]);
+
+		int i = 0;
+		for (int slice = 0; slice < pDataObject->getDepth(); slice++) {
+			for (int row = 0; row < pDataObject->getHeight(); row++) {
+				for (int col = 0; col < pDataObject->getWidth(); col++) {
+					// TODO: Benchmark and remove triple indexing?
+					out[i] = pDataObject->getData3D()[slice][row][col];
+					++i;
+				}
+			}
+		}	
+	}
+	
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * data = astra_mex_data3d('get_single', id);
+ * 
+ * Fetch data from the astra-library to a MATLAB matrix.
+ * id: identifier of the 3d data object as stored in the astra-library.
+ * data: MATLAB data
+
+ */
+void astra_mex_data3d_get_single(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get data object
+	CFloat32Data3DMemory* pDataObject = dynamic_cast<CFloat32Data3DMemory*>(astra::CData3DManager::getSingleton().get(iDataID));
+	if (!pDataObject || !pDataObject->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+
+	// create output
+	if (1 <= nlhs) {
+		mwSize dims[3];
+		dims[0] = pDataObject->getWidth();
+		dims[1] = pDataObject->getHeight();
+		dims[2] = pDataObject->getDepth();
+
+		plhs[0] = mxCreateNumericArray(3, dims, mxSINGLE_CLASS, mxREAL);
+		float* out = (float *)mxGetData(plhs[0]);
+
+		int i = 0;
+		for (int slice = 0; slice < pDataObject->getDepth(); slice++) {
+			for (int row = 0; row < pDataObject->getHeight(); row++) {
+				for (int col = 0; col < pDataObject->getWidth(); col++) {
+					// TODO: Benchmark and remove triple indexing?
+					out[i] = pDataObject->getData3D()[slice][row][col];
+					++i;
+				}
+			}
+		}	
+	}
+	
+}
+
+
+//-----------------------------------------------------------------------------------------
+/**
+ * astra_mex_data3d('store', id, data);
+ * 
+ * Store MATLAB matrix data in the astra-library.
+ * id: identifier of the 3d data object as stored in the astra-library.
+ * data: MATLAB data
+
+ */
+void astra_mex_data3d_store(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: input
+	if (nrhs < 3) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get data object
+	CFloat32Data3DMemory* pDataObject = dynamic_cast<CFloat32Data3DMemory*>(astra::CData3DManager::getSingleton().get(iDataID));
+	if (!pDataObject || !pDataObject->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+
+	if (!(mex_is_scalar(prhs[2]) || mxIsDouble(prhs[2]) || mxIsSingle(prhs[2]))) {
+		mexErrMsgTxt("Data must be single or double.");
+		return;
+	}
+
+	// fill with scalar value
+	if (mex_is_scalar(prhs[2])) {
+		float32 fValue = (float32)mxGetScalar(prhs[2]);
+		for (int i = 0; i < pDataObject->getSize(); ++i) {
+			pDataObject->getData()[i] = fValue;
+		}
+	}
+	// fill with array value
+	else if (mxIsDouble(prhs[2])) {
+		mwSize dims[3];
+		get3DMatrixDims(prhs[2], dims);
+		if (dims[0] != pDataObject->getWidth() || dims[1] != pDataObject->getHeight() || dims[2] != pDataObject->getDepth()) {
+			mexErrMsgTxt("Data object dimensions don't match.\n");
+			return;
+
+		}
+		double* pdMatlabData = mxGetPr(prhs[2]);
+		int i = 0;
+		int col, row, slice;
+		for (slice = 0; slice < dims[2]; ++slice) {
+			for (row = 0; row < dims[1]; ++row) {
+				for (col = 0; col < dims[0]; ++col) {
+					// TODO: Benchmark and remove triple indexing?
+					pDataObject->getData3D()[slice][row][col] = pdMatlabData[i];
+					++i;
+				}
+			}
+		}
+	}
+	else if (mxIsSingle(prhs[2])) {
+		mwSize dims[3];
+		get3DMatrixDims(prhs[2], dims);
+		if (dims[0] != pDataObject->getWidth() || dims[1] != pDataObject->getHeight() || dims[2] != pDataObject->getDepth()) {
+			mexErrMsgTxt("Data object dimensions don't match.\n");
+			return;
+
+		}
+		const float* pfMatlabData = (const float *)mxGetData(prhs[2]);
+		int i = 0;
+		int col, row, slice;
+		for (slice = 0; slice < dims[2]; ++slice) {
+			for (row = 0; row < dims[1]; ++row) {
+				for (col = 0; col < dims[0]; ++col) {
+					// TODO: Benchmark and remove triple indexing?
+					pDataObject->getData3D()[slice][row][col] = pfMatlabData[i];
+					++i;
+				}
+			}
+		}
+	}
+	pDataObject->updateStatistics();
+}
+
+
+//-----------------------------------------------------------------------------------------
+/**
+ * [id] = astra_mex_io_data('fetch_slice', id, slicenr);
+ */
+void astra_mex_data3d_fetch_slice_z(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+//	// step1: get input
+//	if (nrhs < 3) {
+//		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+//		return;
+//	}
+//	int iDid = (int)(mxGetScalar(prhs[1]));
+//	int iSliceNr = (int)(mxGetScalar(prhs[2]));
+//
+//	// Get data object
+//	CFloat32Data3D* pData = CData3DManager::getSingleton().get(iDid);
+//	if (!pData) {
+//		mexErrMsgTxt("DataObject not valid. \n");
+//		return;
+//	}
+//
+//	CFloat32Data2D* res = NULL;
+//	// Projection Data
+//	if (pData->getType() == CFloat32Data3D::PROJECTION) {
+//		CFloat32ProjectionData3D* pData2 = dynamic_cast<CFloat32ProjectionData3D*>(pData);
+////		res = pData2->fetchSlice(iSliceNr);
+//	} 
+//	// Volume Data
+//	else if (pData->getType() == CFloat32Data3D::VOLUME) {
+//		CFloat32VolumeData3D* pData2 = dynamic_cast<CFloat32VolumeData3D*>(pData);
+////		res = pData2->fetchSliceZ(iSliceNr);
+//	} 
+//	// Error
+//	else {
+//		mexErrMsgTxt("DataObject not valid. \n");
+//		return;	
+//	}
+//	
+//	// store data
+//	int iIndex = CData2DManager::getSingleton().store(res);
+//
+//	// step4: set output
+//	if (1 <= nlhs) {
+//		plhs[0] = mxCreateDoubleScalar(iIndex);
+//	}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * astra_mex_io_data('returnSlice', id, slicenr);
+ */
+void astra_mex_data3d_return_slice_z(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+//	// step1: get input
+//	if (nrhs < 3) {
+//		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+//		return;
+//	}
+//	int iDid = (int)(mxGetScalar(prhs[1]));
+//	int iSliceNr = (int)(mxGetScalar(prhs[2]));
+//
+//	// Get data object
+//	CFloat32Data3D* pData = CData3DManager::getSingleton().get(iDid);
+//	if (!pData) {
+//		mexErrMsgTxt("DataObject not valid. \n");
+//		return;
+//	}
+//
+//	// Projection Data
+//	if (pData->getType() == CFloat32Data3D::PROJECTION) {
+//		CFloat32ProjectionData3D* pData2 = dynamic_cast<CFloat32ProjectionData3D*>(pData);
+//// TODO: think about returning slices
+////		pData2->returnSlice(iSliceNr);
+//	} 
+//	// Volume Data
+//	else if (pData->getType() == CFloat32Data3D::VOLUME) {
+//		CFloat32VolumeData3D* pData2 = dynamic_cast<CFloat32VolumeData3D*>(pData);
+//// TODO: think about returning slices
+////      	pData2->returnSliceZ(iSliceNr);
+//	} 
+//	// Error
+//	else {
+//		mexErrMsgTxt("DataObject not valid. \n");
+//		return;	
+//	}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * [id] = astra_mex_io_data('fetch_projection', id, slicenr);
+ */
+void astra_mex_data3d_fetch_projection(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	//// step1: get input
+	//if (nrhs < 3) {
+	//	mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+	//	return;
+	//}
+	//int iDid = (int)(mxGetScalar(prhs[1]));
+	//int iProjectionNr = (int)(mxGetScalar(prhs[2]));
+
+	//// Get data object
+	//CFloat32Data3D* pData = CData3DManager::getSingleton().get(iDid);
+	//if (!pData) {
+	//	mexErrMsgTxt("DataObject not valid. \n");
+	//	return;
+	//}
+
+	//CFloat32Data2D* res = NULL;
+	//// Projection Data
+	//if (pData->getType() == CFloat32Data3D::PROJECTION) {
+	//	CFloat32ProjectionData3D* pData2 = dynamic_cast<CFloat32ProjectionData3D*>(pData);
+	//	res = pData2->fetchProjection(iProjectionNr);
+	//} 
+	//// Error
+	//else {
+	//	mexErrMsgTxt("DataObject not valid. \n");
+	//	return;	
+	//}
+	//
+	//// store data
+	//int iIndex = CData2DManager::getSingleton().store(res);
+
+	//// step4: set output
+	//if (1 <= nlhs) {
+	//	plhs[0] = mxCreateDoubleScalar(iIndex);
+	//}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * astra_mex_io_data('return_projection', id, slicenr);
+ */
+void astra_mex_data3d_return_projection(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	//// step1: get input
+	//if (nrhs < 3) {
+	//	mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+	//	return;
+	//}
+	//int iDid = (int)(mxGetScalar(prhs[1]));
+	//int iProjectionNr = (int)(mxGetScalar(prhs[2]));
+
+	//// Get data object
+	//CFloat32Data3D* pData = CData3DManager::getSingleton().get(iDid);
+	//if (!pData) {
+	//	mexErrMsgTxt("DataObject not valid. \n");
+	//	return;
+	//}
+
+	//// Projection Data
+	//if (pData->getType() == CFloat32Data3D::PROJECTION) {
+	//	CFloat32ProjectionData3D* pData2 = dynamic_cast<CFloat32ProjectionData3D*>(pData);
+	////	pData2->returnProjection(iProjectionNr);
+	//} 
+	//// Error
+	//else {
+	//	mexErrMsgTxt("DataObject not valid. \n");
+	//	return;	
+	//}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * [id] = astra_mex_io_data('fetch_projection', id, slicenr);
+ */
+void astra_mex_data3d_fetch_slice_x(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	//// step1: get input
+	//if (nrhs < 3) {
+	//	mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+	//	return;
+	//}
+	//int iDid = (int)(mxGetScalar(prhs[1]));
+	//int iSliceNr = (int)(mxGetScalar(prhs[2]));
+
+	//// Get data object
+	//CFloat32Data3D* pData = CData3DManager::getSingleton().get(iDid);
+	//if (!pData) {
+	//	mexErrMsgTxt("DataObject not valid. \n");
+	//	return;
+	//}
+
+	//CFloat32Data2D* res = NULL;
+	//// Projection Data
+	//if (pData->getType() == CFloat32Data3D::VOLUME) {
+	//	CFloat32VolumeData3D* pData2 = dynamic_cast<CFloat32VolumeData3D*>(pData);
+	//	res = pData2->fetchSliceX(iSliceNr);
+	//} 
+	//// Error
+	//else {
+	//	mexErrMsgTxt("DataObject not valid. \n");
+	//	return;	
+	//}
+	//
+	//// store data
+	//int iIndex = CData2DManager::getSingleton().store(res);
+
+	//// step4: set output
+	//if (1 <= nlhs) {
+	//	plhs[0] = mxCreateDoubleScalar(iIndex);
+	//}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * astra_mex_io_data('return_slice_x', id, slicenr);
+ */
+void astra_mex_data3d_return_slice_x(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+//	// step1: get input
+//	if (nrhs < 3) {
+//		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+//		return;
+//	}
+//	int iDid = (int)(mxGetScalar(prhs[1]));
+//	int iSliceNr = (int)(mxGetScalar(prhs[2]));
+//
+//	// Get data object
+//	CFloat32Data3D* pData = CData3DManager::getSingleton().get(iDid);
+//	if (!pData) {
+//		mexErrMsgTxt("DataObject not valid. \n");
+//		return;
+//	}
+//
+//	// Projection Data
+//	if (pData->getType() == CFloat32Data3D::VOLUME) {
+//		CFloat32VolumeData3D* pData2 = dynamic_cast<CFloat32VolumeData3D*>(pData);
+//// TODO: think about returning slices
+////		pData2->returnSliceX(iSliceNr);
+//	} 
+//	// Error
+//	else {
+//		mexErrMsgTxt("DataObject not valid. \n");
+//		return;	
+//	}
+}
+
+
+//-----------------------------------------------------------------------------------------
+/**
+ * [id] = astra_mex_io_data('fetch_slice_y', id, slicenr);
+ */
+void astra_mex_data3d_fetch_slice_y(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	//// step1: get input
+	//if (nrhs < 3) {
+	//	mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+	//	return;
+	//}
+	//int iDid = (int)(mxGetScalar(prhs[1]));
+	//int iSliceNr = (int)(mxGetScalar(prhs[2]));
+
+	//// Get data object
+	//CFloat32Data3D* pData = CData3DManager::getSingleton().get(iDid);
+	//if (!pData) {
+	//	mexErrMsgTxt("DataObject not valid. \n");
+	//	return;
+	//}
+
+	//CFloat32Data2D* res = NULL;
+	//// Projection Data
+	//if (pData->getType() == CFloat32Data3D::VOLUME) {
+	//	CFloat32VolumeData3D* pData2 = dynamic_cast<CFloat32VolumeData3D*>(pData);
+	//	res = pData2->fetchSliceY(iSliceNr);
+	//} 
+	//// Error
+	//else {
+	//	mexErrMsgTxt("DataObject not valid. \n");
+	//	return;	
+	//}
+	//
+	//// store data
+	//int iIndex = CData2DManager::getSingleton().store(res);
+
+	//// step4: set output
+	//if (1 <= nlhs) {
+	//	plhs[0] = mxCreateDoubleScalar(iIndex);
+	//}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * astra_mex_io_data('return_slice_y', id, slicenr);
+ */
+void astra_mex_data3d_return_slice_y(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+//	// step1: get input
+//	if (nrhs < 3) {
+//		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+//		return;
+//	}
+//	int iDid = (int)(mxGetScalar(prhs[1]));
+//	int iSliceNr = (int)(mxGetScalar(prhs[2]));
+//
+//	// Get data object
+//	CFloat32Data3D* pData = CData3DManager::getSingleton().get(iDid);
+//	if (!pData) {
+//		mexErrMsgTxt("DataObject not valid. \n");
+//		return;
+//	}
+//
+//	// Projection Data
+//	if (pData->getType() == CFloat32Data3D::VOLUME) {
+//		CFloat32VolumeData3D* pData2 = dynamic_cast<CFloat32VolumeData3D*>(pData);
+//// TODO: think about returning slices
+////		pData2->returnSliceY(iSliceNr);
+//	} 
+//	// Error
+//	else {
+//		mexErrMsgTxt("DataObject not valid. \n");
+//		return;	
+//	}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * [dim_x dim_y dim_z] = astra_mex_io_data('dimensions', id);
+ */
+void astra_mex_data3d_dimensions(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	// step1: get input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iDid = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get data object
+	CFloat32Data3D* pData;
+	if (!(pData = CData3DManager::getSingleton().get(iDid))) {
+		mexErrMsgTxt("DataObject not valid. \n");
+		return;
+	}
+
+	// step3: output
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(pData->getWidth());
+	}	
+	if (2 <= nlhs) {
+		plhs[1] = mxCreateDoubleScalar(pData->getHeight());
+	}	
+	if (3 <= nlhs) {
+		plhs[2] = mxCreateDoubleScalar(pData->getDepth());
+	}	
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * [geom] = astra_mex_data3d('geometry', id);
+ */
+void astra_mex_data3d_geometry(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	//// Get input
+	//if (nrhs < 2) {
+	//	mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+	//	return;
+	//}
+	//int iDid = (int)(mxGetScalar(prhs[1]));
+
+	//// Get data object
+	//CFloat32Data3D* pData = CData3DManager::getSingleton().get(iDid);
+	//if (!pData) {
+	//	mexErrMsgTxt("DataObject not valid. \n");
+	//	return;
+	//}
+
+	//// Projection Data
+	//if (pData->getType() == CFloat32Data3D::PROJECTION) {
+	//	CFloat32ProjectionData3D* pData2 = dynamic_cast<CFloat32ProjectionData3D*>(pData);
+	//	CProjectionGeometry3D* pProjGeom = pData2->getGeometry();
+	//	XMLDocument* config = pProjGeom->toXML();
+
+	//	if (1 <= nlhs) {
+	//		plhs[0] = XML2struct(config);
+	//	}
+	//} 
+	//// Volume Data
+	//else if (pData->getType() == CFloat32Data3D::VOLUME) {
+	////	CFloat32VolumeData3D* pData2 = dynamic_cast<CFloat32VolumeData3D*>(pData);
+	////	CVolumeGeometry2D* pVolGeom = pData2->getGeometry2D(iSliceNr);
+	////	if (1 <= nlhs) {
+	////		plhs[0] = createVolumeGeometryStruct(pVolGeom);
+	////	}
+	//} 
+	//// Error
+	//else {
+	//	mexErrMsgTxt("Type not valid. \n");
+	//	return;	
+	//}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * [geom_xml] = astra_mex_data3d('geometry_xml', id);
+ */
+void astra_mex_data3d_geometry_xml(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	//// Get input
+	//if (nrhs < 2) {
+	//	mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+	//	return;
+	//}
+	//int iDid = (int)(mxGetScalar(prhs[1]));
+
+	//// Get data object
+	//CFloat32Data3D* pData = CData3DManager::getSingleton().get(iDid);
+	//if (!pData) {
+	//	mexErrMsgTxt("DataObject not valid. \n");
+	//	return;
+	//}
+
+	//// Projection Data
+	//if (pData->getType() == CFloat32Data3D::PROJECTION) {
+	//	CFloat32ProjectionData3D* pData2 = dynamic_cast<CFloat32ProjectionData3D*>(pData);
+	//	CProjectionGeometry3D* pProjGeom = pData2->getGeometry();
+	//	XMLDocument* config = pProjGeom->toXML();
+
+	//	if (1 <= nlhs) {
+	//		plhs[0] = mxCreateString(config->getRootNode()->toString().c_str());
+	//	}
+	//} 
+	//// Volume Data
+	//else if (pData->getType() == CFloat32Data3D::VOLUME) {
+	////	CFloat32VolumeData3D* pData2 = dynamic_cast<CFloat32VolumeData3D*>(pData);
+	////	CVolumeGeometry2D* pVolGeom = pData2->getGeometry2D(iSliceNr);
+	////	if (1 <= nlhs) {
+	////		plhs[0] = createVolumeGeometryStruct(pVolGeom);
+	////	}
+	//} 
+	//// Error
+	//else {
+	//	mexErrMsgTxt("Type not valid. \n");
+	//	return;	
+	//}
+}
+//-----------------------------------------------------------------------------------------
+/**
+ * astra_mex_data3d('delete', did1, did2, ...);
+ */
+void astra_mex_data3d_delete(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: read input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	for (int i = 1; i < nrhs; i++) {
+		int iDataID = (int)(mxGetScalar(prhs[i]));
+		CData3DManager::getSingleton().remove(iDataID);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * astra_mex_data3d('clear');
+ */
+void astra_mex_data3d_clear(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	CData3DManager::getSingleton().clear();
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * astra_mex_data3d('info');
+ */
+void astra_mex_data3d_info(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	mexPrintf("%s", astra::CData3DManager::getSingleton().info().c_str());
+}
+
+//-----------------------------------------------------------------------------------------
+
+static void printHelp()
+{
+	mexPrintf("Please specify a mode of operation.\n");
+	mexPrintf("Valid modes: create, create_cache, get, get_single, delete, clear, info\n");
+	mexPrintf("             fetch_projection, return_projection, fetch_slice[_z],\n");
+	mexPrintf("             return_slice[_z], fetch_slice_x, return slice_x\n");
+	mexPrintf("             fetch_slice_y, return slice_y, dimensions, geometry\n");
+	mexPrintf("             geometry_xml\n");
+}
+
+
+//-----------------------------------------------------------------------------------------
+/**
+ * ... = astra_mex_io_data(mode,...);
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+				 int nrhs, const mxArray* prhs[])
+{
+
+	// INPUT: Mode
+	string sMode = "";
+	if (1 <= nrhs) {
+		sMode = mex_util_get_string(prhs[0]);	
+	} else {
+		printHelp();
+		return;
+	}
+
+	// 3D data
+	if (sMode ==  std::string("create")) { 
+		astra_mex_data3d_create(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("create_cache")) { 
+		astra_mex_data3d_create_cache(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("get")) { 
+		astra_mex_data3d_get(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("get_single")) { 
+		astra_mex_data3d_get_single(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("store") ||
+	           sMode ==  std::string("set")) { 
+		astra_mex_data3d_store(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("delete")) { 
+		astra_mex_data3d_delete(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == "clear") {
+		astra_mex_data3d_clear(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "info") {
+		astra_mex_data3d_info(nlhs, plhs, nrhs, prhs);
+	} else if (sMode ==  std::string("fetch_projection")) { 
+		astra_mex_data3d_fetch_projection(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("return_projection")) { 
+		astra_mex_data3d_return_projection(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("fetch_slice") || sMode ==  std::string("fetch_slice_z")) { 
+		astra_mex_data3d_fetch_slice_z(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("return_slice")  || sMode ==  std::string("return_slice_z")) { 
+		astra_mex_data3d_return_slice_z(nlhs, plhs, nrhs, prhs);
+	} else if (sMode ==  std::string("fetch_slice_x")) { 
+		astra_mex_data3d_fetch_slice_x(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("return_slice_x")) { 
+		astra_mex_data3d_return_slice_x(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("fetch_slice_y")) { 
+		astra_mex_data3d_fetch_slice_y(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("return_slice_y")) { 
+		astra_mex_data3d_return_slice_y(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("dimensions")) { 
+		astra_mex_data3d_dimensions(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == std::string("geometry")) {
+		astra_mex_data3d_geometry(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == std::string("geometry_xml")) {
+		astra_mex_data3d_geometry_xml(nlhs, plhs, nrhs, prhs);
+	} else {
+		printHelp();
+	}
+
+	return;
+}
+
+
diff --git a/matlab/mex/astra_mex_data3d_vc08.vcproj b/matlab/mex/astra_mex_data3d_vc08.vcproj
new file mode 100644
index 0000000..2e69c16
--- /dev/null
+++ b/matlab/mex/astra_mex_data3d_vc08.vcproj
@@ -0,0 +1,588 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="astra_mex_data3d"
+	ProjectGUID="{0BEC029B-0929-4BF9-BD8B-9C9806A52065}"
+	RootNamespace="astraMatlab"
+	TargetFrameworkVersion="131072"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<File
+			RelativePath=".\astra_mex_data3d_c.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.h"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/matlab/mex/astra_mex_matrix_c.cpp b/matlab/mex/astra_mex_matrix_c.cpp
new file mode 100644
index 0000000..accaab5
--- /dev/null
+++ b/matlab/mex/astra_mex_matrix_c.cpp
@@ -0,0 +1,437 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+/** \file astra_mex_matrix_c.cpp
+ *
+ *  \brief Create sparse (projection) matrices in the ASTRA workspace
+ */
+#include <mex.h>
+#include "mexHelpFunctions.h"
+
+#include <list>
+
+#include "astra/Globals.h"
+
+#include "astra/AstraObjectManager.h"
+
+#include "astra/SparseMatrix.h"
+
+using namespace std;
+using namespace astra;
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_matrix('delete', id1, id2, ...);
+ *
+ * Delete one or more data objects currently stored in the astra-library.
+ * id1, id2, ... : identifiers of the 2d data objects as stored in the astra-library.
+ */
+void astra_mex_matrix_delete(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: read input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	// step2: delete all specified data objects
+	for (int i = 1; i < nrhs; i++) {
+		int iDataID = (int)(mxGetScalar(prhs[i]));
+		CMatrixManager::getSingleton().remove(iDataID);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_matrix('clear');
+ *
+ * Delete all data objects currently stored in the astra-library.
+ */
+void astra_mex_matrix_clear(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	CMatrixManager::getSingleton().clear();
+}
+
+
+
+static bool matlab_to_astra(const mxArray* _rhs, CSparseMatrix* _pMatrix)
+{
+	// Check input
+	if (!mxIsSparse (_rhs)) {
+		mexErrMsgTxt("Argument is not a valid MATLAB sparse matrix.\n");
+		return false;
+	}
+	if (!_pMatrix->isInitialized()) {
+		mexErrMsgTxt("Couldn't initialize data object.\n");
+		return false;
+	}
+
+	unsigned int iHeight = mxGetM(_rhs);
+	unsigned int iWidth = mxGetN(_rhs);
+	unsigned long lSize = mxGetNzmax(_rhs);
+
+	if (_pMatrix->m_lSize < lSize || _pMatrix->m_iHeight < iHeight) {
+		// TODO: support resizing?
+		mexErrMsgTxt("Matrix too large to store in this object.\n");
+		return false;
+	}
+
+	// Transpose matrix, as matlab stores a matrix column-by-column
+	// but we want it row-by-row.
+	// 1. Compute sizes of rows. We store these in _pMatrix->m_plRowStarts.
+	// 2. Fill data structure
+	// Complexity: O( #rows + #entries )
+
+	for (unsigned int i = 0; i <= iHeight; ++i)
+		_pMatrix->m_plRowStarts[i] = 0;
+
+	mwIndex *colStarts = mxGetJc(_rhs);
+	mwIndex *rowIndices = mxGetIr(_rhs);
+	double *floatValues = 0;
+	bool *boolValues = 0;
+	bool bLogical = mxIsLogical(_rhs);
+	if (bLogical)
+		boolValues = mxGetLogicals(_rhs);
+	else
+		floatValues = mxGetPr(_rhs);
+
+	for (mwIndex i = 0; i < colStarts[iWidth]; ++i) {
+		unsigned int iRow = rowIndices[i];
+		assert(iRow < iHeight);
+		_pMatrix->m_plRowStarts[iRow+1]++;
+	}
+
+	// Now _pMatrix->m_plRowStarts[i+1] is the number of entries in row i
+
+	for (unsigned int i = 1; i <= iHeight; ++i)
+		_pMatrix->m_plRowStarts[i] += _pMatrix->m_plRowStarts[i-1];
+
+	// Now _pMatrix->m_plRowStarts[i+1] is the number of entries in rows <= i,
+	// so the intended start of row i+1
+
+	int iCol = 0;
+	for (mwIndex i = 0; i < colStarts[iWidth]; ++i) {
+		while (i >= colStarts[iCol+1])
+			iCol++;
+
+		unsigned int iRow = rowIndices[i];
+		assert(iRow < iHeight);
+		float32 fVal;
+		if (bLogical)
+			fVal = (float32)boolValues[i];
+		else
+			fVal = (float32)floatValues[i];
+
+		unsigned long lIndex = _pMatrix->m_plRowStarts[iRow]++;
+		_pMatrix->m_pfValues[lIndex] = fVal;
+		_pMatrix->m_piColIndices[lIndex] = iCol;
+	}
+
+	// Now _pMatrix->m_plRowStarts[i] is the start of row i+1
+
+	for (unsigned int i = iHeight; i > 0; --i)
+		_pMatrix->m_plRowStarts[i] = _pMatrix->m_plRowStarts[i-1];
+	_pMatrix->m_plRowStarts[0] = 0;
+
+#if 0
+	// Debugging: dump matrix
+	for (unsigned int i = 0; i < iHeight; ++i) {
+		printf("Row %d: %ld-%ld\n", i, _pMatrix->m_plRowStarts[i], _pMatrix->m_plRowStarts[i+1]);
+		for (unsigned long j = _pMatrix->m_plRowStarts[i]; j < _pMatrix->m_plRowStarts[i+1]; ++j) {
+			printf("(%d,%d) = %f\n", i, _pMatrix->m_piColIndices[j], _pMatrix->m_pfValues[j]);
+		}
+	}
+#endif
+
+	return true;
+}
+
+static bool astra_to_matlab(const CSparseMatrix* _pMatrix, mxArray*& _lhs)
+{
+	if (!_pMatrix->isInitialized()) {
+		mexErrMsgTxt("Uninitialized data object.\n");
+		return false;
+	}
+
+	unsigned int iHeight = _pMatrix->m_iHeight;
+	unsigned int iWidth = _pMatrix->m_iWidth;
+	unsigned long lSize = _pMatrix->m_lSize;
+
+	_lhs = mxCreateSparse(iHeight, iWidth, lSize, mxREAL);
+	if (!mxIsSparse (_lhs)) {
+		mexErrMsgTxt("Couldn't initialize matlab sparse matrix.\n");
+		return false;
+	}
+	
+	mwIndex *colStarts = mxGetJc(_lhs);
+	mwIndex *rowIndices = mxGetIr(_lhs);
+	double *floatValues = mxGetPr(_lhs);
+
+	for (unsigned int i = 0; i <= iWidth; ++i)
+		colStarts[i] = 0;
+
+	for (unsigned int i = 0; i < _pMatrix->m_plRowStarts[iHeight]; ++i) {
+		unsigned int iCol = _pMatrix->m_piColIndices[i];
+		assert(iCol < iWidth);
+		colStarts[iCol+1]++;
+	}
+	// Now _pMatrix->m_plRowStarts[i+1] is the number of entries in row i
+
+	for (unsigned int i = 1; i <= iWidth; ++i)
+		colStarts[i] += colStarts[i-1];
+	// Now _pMatrix->m_plRowStarts[i+1] is the number of entries in rows <= i,
+	// so the intended start of row i+1
+
+	unsigned int iRow = 0;
+	for (unsigned int i = 0; i < _pMatrix->m_plRowStarts[iHeight]; ++i) {
+		while (i >= _pMatrix->m_plRowStarts[iRow+1])
+			iRow++;
+
+		unsigned int iCol = _pMatrix->m_piColIndices[i];
+		assert(iCol < iWidth);
+		double fVal = _pMatrix->m_pfValues[i];
+		unsigned long lIndex = colStarts[iCol]++;
+		floatValues[lIndex] = fVal;
+		rowIndices[lIndex] = iRow;
+	}
+	// Now _pMatrix->m_plRowStarts[i] is the start of row i+1
+
+	for (unsigned int i = iWidth; i > 0; --i)
+		colStarts[i] = colStarts[i-1];
+	colStarts[0] = 0;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------------------
+/** id = astra_mex_matrix('create', data);
+ *   
+ * Create a new matrix object in the astra-library.
+ * data: a sparse MATLAB matrix containing the data.
+ * id: identifier of the matrix object as it is now stored in the astra-library.
+ */
+void astra_mex_matrix_create(int& nlhs, mxArray* plhs[], int& nrhs, const mxArray* prhs[])
+{ 
+	// step1: get datatype
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	if (!mxIsSparse (prhs[1])) {
+		mexErrMsgTxt("Argument is not a valid MATLAB sparse matrix.\n");
+		return;
+	}
+
+	unsigned int iHeight = mxGetM(prhs[1]);
+	unsigned int iWidth = mxGetN(prhs[1]);
+	unsigned long lSize = mxGetNzmax(prhs[1]);
+
+	CSparseMatrix* pMatrix = new CSparseMatrix(iHeight, iWidth, lSize);
+
+	// Check initialization
+	if (!pMatrix->isInitialized()) {
+		mexErrMsgTxt("Couldn't initialize data object.\n");
+		delete pMatrix;
+		return;
+	}
+
+	bool bResult = matlab_to_astra(prhs[1], pMatrix);
+
+	if (!bResult) {
+		mexErrMsgTxt("Failed to create data object.\n");
+		delete pMatrix;
+		return;
+	}
+
+	// store data object
+	int iIndex = CMatrixManager::getSingleton().store(pMatrix);
+
+	// return data id
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(iIndex);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_matrix('store', id, data);
+ *
+ * Store a sparse MATLAB matrix in an existing astra matrix dataobject. 
+ * id: identifier of the 2d data object as stored in the astra-library.
+ * data: a sparse MATLAB matrix.
+ */
+void astra_mex_matrix_store(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	// step1: input
+	if (nrhs < 3) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	if (!mxIsDouble(prhs[1])) {
+		mexErrMsgTxt("Identifier should be a scalar value. \n");
+		return;
+	}
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get data object
+	CSparseMatrix* pMatrix = astra::CMatrixManager::getSingleton().get(iDataID);
+	if (!pMatrix || !pMatrix->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+
+	bool bResult = matlab_to_astra(prhs[2], pMatrix);
+	if (!bResult) {
+		mexErrMsgTxt("Failed to store matrix.\n");
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** geom = astra_mex_matrix('get_size', id);
+ * 
+ * Fetch the dimensions and size of a matrix stored in the astra-library.
+ * id: identifier of the 2d data object as stored in the astra-library.
+ * geom: a 1x2 matrix containing [rows, columns]
+ */
+void astra_mex_matrix_get_size(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	if (!mxIsDouble(prhs[1])) {
+		mexErrMsgTxt("Identifier should be a scalar value. \n");
+		return;
+	}
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get data object
+	CSparseMatrix* pMatrix = astra::CMatrixManager::getSingleton().get(iDataID);
+	if (!pMatrix || !pMatrix->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+
+	// create output
+	// TODO
+}
+
+//-----------------------------------------------------------------------------------------
+/** data = astra_mex_matrix('get', id);
+ *
+ * Fetch data from the astra-library to a MATLAB matrix.
+ * id: identifier of the matrix data object as stored in the astra-library.
+ * data: MATLAB
+ */
+void astra_mex_matrix_get(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: check input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	if (!mxIsDouble(prhs[1])) {
+		mexErrMsgTxt("Identifier should be a scalar value. \n");
+		return;
+	}
+	int iDataID = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get data object
+	CSparseMatrix* pMatrix = astra::CMatrixManager::getSingleton().get(iDataID);
+	if (!pMatrix || !pMatrix->isInitialized()) {
+		mexErrMsgTxt("Data object not found or not initialized properly.\n");
+		return;
+	}
+
+	// create output
+	if (1 <= nlhs) {
+		bool bResult = astra_to_matlab(pMatrix, plhs[0]);
+		if (!bResult) {
+			mexErrMsgTxt("Failed to get matrix.\n");
+		}
+	}
+	
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_matrix('info');
+ * 
+ * Print information about all the matrix objects currently stored in the astra-library.
+ */
+void astra_mex_matrix_info(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	mexPrintf("%s", astra::CMatrixManager::getSingleton().info().c_str());
+}
+
+//-----------------------------------------------------------------------------------------
+
+static void printHelp()
+{
+	mexPrintf("Please specify a mode of operation.\n");
+	mexPrintf("Valid modes: get, delete, clear, store, create, get_size, info\n");
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * ... = astra_mex_matrix(type,...);
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+				 int nrhs, const mxArray* prhs[])
+{
+
+	// INPUT0: Mode
+	string sMode = "";
+	if (1 <= nrhs) {
+		sMode = mex_util_get_string(prhs[0]);	
+	} else {
+		printHelp();
+		return;
+	}
+
+	// SWITCH (MODE)
+	if (sMode ==  std::string("get")) { 
+		astra_mex_matrix_get(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode ==  std::string("delete")) {	
+		astra_mex_matrix_delete(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == "clear") {
+		astra_mex_matrix_clear(nlhs, plhs, nrhs, prhs);
+	} else if (sMode ==  std::string("store")) {	
+		astra_mex_matrix_store(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == std::string("create")) { 
+		astra_mex_matrix_create(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == std::string("get_size")) { 
+		astra_mex_matrix_get_size(nlhs, plhs, nrhs, prhs); 
+	} else if (sMode == std::string("info")) { 
+		astra_mex_matrix_info(nlhs, plhs, nrhs, prhs); 
+	} else {
+		printHelp();
+	}
+
+	return;
+}
+
+
diff --git a/matlab/mex/astra_mex_matrix_vc08.vcproj b/matlab/mex/astra_mex_matrix_vc08.vcproj
new file mode 100644
index 0000000..47509f6
--- /dev/null
+++ b/matlab/mex/astra_mex_matrix_vc08.vcproj
@@ -0,0 +1,591 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="astra_mex_matrix"
+	ProjectGUID="{9D041710-2119-4230-BCF2-5FBE753FDE49}"
+	RootNamespace="astraMatlab"
+	TargetFrameworkVersion="131072"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;&quot;$(CUDA_INC_PATH)&quot;;..\..\lib\include;..\..\lib\include\cuda;..\..\include\;"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="&quot;$(CUDA_INC_PATH)&quot;;$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				BrowseInformation="1"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<File
+			RelativePath=".\astra_mex_matrix_c.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.h"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/matlab/mex/astra_mex_projector3d_c.cpp b/matlab/mex/astra_mex_projector3d_c.cpp
new file mode 100644
index 0000000..1385863
--- /dev/null
+++ b/matlab/mex/astra_mex_projector3d_c.cpp
@@ -0,0 +1,433 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+/** \file astra_mex_projector3d_c.cpp
+ *
+ *  \brief Create and manage 3d projectors in the ASTRA workspace
+ */
+
+#include <mex.h>
+#include "mexHelpFunctions.h"
+
+#include "astra/Globals.h"
+
+#include "astra/Projector3D.h"
+#include "astra/AstraObjectManager.h"
+#include "astra/AstraObjectFactory.h"
+
+#include "astra/ProjectionGeometry3D.h"
+#include "astra/VolumeGeometry3D.h"
+
+#include <map>
+#include <vector>
+
+using namespace std;
+using namespace astra;
+
+//-----------------------------------------------------------------------------------------
+/**
+* [pid] = astra_mex_projector('create', cfgstruct);
+*/
+void astra_mex_projector3d_create(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	if (!mxIsStruct(prhs[1])) {
+		mexErrMsgTxt("Argument 1 not a valid MATLAB struct. \n");
+	}
+
+	// turn MATLAB struct to an XML-based Config object
+	XMLDocument* xml = struct2XML("Projector3D", prhs[1]);
+	Config cfg;
+	cfg.self = xml->getRootNode();
+
+	// create algorithm
+	CProjector3D* pProj = CProjector3DFactory::getSingleton().create(cfg);
+	if (pProj == NULL) {
+		mexErrMsgTxt("Error creating Projector3D. \n");
+		return;
+	}
+
+	// store projector
+	int iIndex = CProjector3DManager::getSingleton().store(pProj);
+
+	// step4: set output
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(iIndex);
+	}
+
+	}
+
+//-----------------------------------------------------------------------------------------
+/**
+* astra_mex_projector3d('destroy', pid1, pid2, ...);
+*/
+void astra_mex_projector3d_destroy(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	// step1: read input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	for (int i = 1; i < nrhs; i++) {
+		int iPid = (int)(mxGetScalar(prhs[i]));
+		CProjector3DManager::getSingleton().remove(iPid);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * astra_mex_projector3d('clear');
+ */
+void astra_mex_projector3d_clear(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	CProjector3DManager::getSingleton().clear();
+}
+
+
+//-----------------------------------------------------------------------------------------
+/**
+* [proj_geom] = astra_mex_projector3d('get_projection_geometry', pid);
+*/
+void astra_mex_projector3d_get_projection_geometry(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	// step1: read input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iPid = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get projector
+	CProjector3D* pProjector;
+	if (!(pProjector = CProjector3DManager::getSingleton().get(iPid))) {
+		mexErrMsgTxt("Projector not found.\n");
+		return;
+	}
+
+	// step3: get projection_geometry and turn it into a MATLAB struct
+	//if (1 <= nlhs) {
+	//	plhs[0] = createProjectionGeometryStruct(pProjector->getProjectionGeometry());
+	//}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+* [recon_geom] = astra_mex_projector3d('get_volume_geometry', pid);
+*/
+void astra_mex_projector3d_get_reconstruction_geometry(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	// step1: read input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iPid = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get projector
+	CProjector3D* pProjector;
+	if (!(pProjector = CProjector3DManager::getSingleton().get(iPid))) {
+		mexErrMsgTxt("Projector not found.\n");
+		return;
+	}
+
+	// step3: get projection_geometry and turn it into a MATLAB struct
+	//if (1 <= nlhs) {
+	//	plhs[0] = createVolumeGeometryStruct(pProjector->getVolumeGeometry());
+	//}
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+* [weights] = astra_mex_projector3d('weights_single_ray', pid, projection_index, detector_index);
+*/
+void astra_mex_projector_weights_single_ray(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	//// step1: get input
+	//if (nrhs < 4) {
+	//	mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+	//	return;
+	//}
+	//int iPid = (int)(mxGetScalar(prhs[1]));
+	//int iProjectionIndex = (int)(mxGetScalar(prhs[2]));
+	//int iDetectorIndex = (int)(mxGetScalar(prhs[3]));
+
+	//// step2: get projector
+	//CProjector3D* pProjector;
+	//if (!(pProjector = CProjector3DManager::getSingleton().get(iPid))) {
+	//	mexErrMsgTxt("Projector not found.\n");
+	//	return;
+	//}
+	//
+	//// step3: create output vars
+	//int iStoredPixelCount;
+	//int iMaxPixelCount = pProjector->getProjectionWeightsCount(iProjectionIndex);
+	//SWeightedPixel* pPixelsWeights = new SWeightedPixel3D[iMaxPixelCount];
+	//
+	//// step4: perform operation
+	//pProjector->computeSingleRayWeights(iProjectionIndex, 
+	//									iDetectorIndex, 
+	//									pPixelsWeights, 
+	//									iMaxPixelCount, 
+	//									iStoredPixelCount);
+
+	//// step5: return output
+	//if (1 <= nlhs) {
+	//	mwSize dims[2];
+	//	dims[0] = iStoredPixelCount;
+	//	dims[1] = 2;
+
+	//	plhs[0] = mxCreateNumericArray(2, dims, mxDOUBLE_CLASS, mxREAL);
+	//	double* out = mxGetPr(plhs[0]);
+
+	//	for (int col = 0; col < iStoredPixelCount; col++) {
+	//		out[col] = pPixelsWeights[col].m_iIndex;
+	//		out[iStoredPixelCount+col] = pPixelsWeights[col].m_fWeight;
+	//		//cout << pPixelsWeights[col].m_iIndex << " " << pPixelsWeights[col].m_fWeight <<endl;
+	//	}	
+	//}
+	//
+	//// garbage collection
+	//delete[] pPixelsWeights;
+}
+
+////-----------------------------------------------------------------------------------------
+///**
+//* [weights] = astra_mex_projector('weights_projection', pid, projection_index);
+//*/
+//void astra_mex_projector_weights_projection(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+//{ 
+//	// step1: get input
+//	if (nrhs < 3) {
+//		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+//		return;
+//	}
+//	int iPid = (int)(mxGetScalar(prhs[1]));
+//	int iProjectionIndex = (int)(mxGetScalar(prhs[2]));
+//
+//	// step2: get projector
+//	CProjector2D* pProjector;
+//	if (!(pProjector = CProjectorManager::getSingleton().get(iPid))) {
+//		mexErrMsgTxt("Projector not found.\n");
+//		return;
+//	}
+//
+//	// step3: create output vars
+//	SWeightedPixel2D* pPixelsWheights = new SWeightedPixel2D[pProjector->getProjectionWeightsCount(iProjectionIndex)];
+//	int* piRayStoredPixelCount = new int[pProjector->getProjectionGeometry()->getDetectorCount()];
+//
+//	// step4: perform operation
+//	pProjector->computeProjectionRayWeights(iProjectionIndex, pPixelsWheights, piRayStoredPixelCount);
+//
+//	// step5: return output
+//	if (1 <= nlhs) {
+//		// get basic values
+//		int iMatrixSize = pProjector->getVolumeGeometry()->getWindowLengthX() *
+//						  pProjector->getVolumeGeometry()->getWindowLengthY();
+//		int iDetectorCount = pProjector->getProjectionGeometry()->getDetectorCount();
+//		int iTotalStoredPixelCount = 0;
+//		for (int i = 0; i < iDetectorCount; i++) {
+//			iTotalStoredPixelCount += piRayStoredPixelCount[i];
+//		}
+//
+//		// create matlab sparse matrix
+//		plhs[0] = mxCreateSparse(iMatrixSize,				// number of rows (#pixels)
+//							     iDetectorCount,			// number of columns (#detectors)
+//								 iTotalStoredPixelCount,	// number of non-zero elements
+//								 mxREAL);					// element type
+//		double* values = mxGetPr(plhs[0]);
+//		mwIndex* rows = mxGetIr(plhs[0]);
+//		mwIndex* cols = mxGetJc(plhs[0]);
+//		
+//		int currentBase = 0;
+//		int currentIndex = 0;
+//		for (int i = 0; i < iDetectorCount; i++) {
+//			for (int j = 0; j < piRayStoredPixelCount[i]; j++) {
+//				values[currentIndex + j] = pPixelsWheights[currentBase + j].m_fWeight;
+//				rows[currentIndex + j] = pPixelsWheights[currentBase + j].m_iIndex;
+//			}
+//					
+//			currentBase += pProjector->getProjectionWeightsCount(iProjectionIndex) / pProjector->getProjectionGeometry()->getDetectorCount();
+//			currentIndex += piRayStoredPixelCount[i];
+//		}
+//		cols[0] = piRayStoredPixelCount[0];
+//		for (int j = 1; j < iDetectorCount; j++) {
+//			cols[j] = cols[j-1] + piRayStoredPixelCount[j];
+//		}
+//		cols[iDetectorCount] = iTotalStoredPixelCount;
+//	}
+//	
+//}
+//
+////-----------------------------------------------------------------------------------------
+///**
+//* output = astra_mex_projector('splat', pid, x, y);
+//*/
+//void astra_mex_projector_splat(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+//{ 
+//	// step1: get input
+//	if (nrhs < 4) {
+//		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+//		return;
+//	}
+//	int iPid = (int)(mxGetScalar(prhs[1]));
+//	int iX = (int)(mxGetScalar(prhs[2]));
+//	int iY = (int)(mxGetScalar(prhs[3]));
+//
+//	// step2: get projector
+//	CProjector2D* pProjector;
+//	if (!(pProjector = CProjectorManager::getSingleton().get(iPid))) {
+//		mexErrMsgTxt("Projector not found.\n");
+//		return;
+//	}
+//
+//	// step3: perform action
+//	vector<SDetector2D> detinfo = pProjector->projectPoint(iX, iY);
+//
+//	// step4: output
+//	if (nlhs <= 1) {
+//		plhs[0] = mxCreateDoubleMatrix(detinfo.size(),	// # rows
+//									   2,				// # cols
+//									   mxREAL);			// datatype 32-bits
+//		double* out = mxGetPr(plhs[0]);
+//
+//		// fill up output
+//		int i = 0;
+//		for (int x = 0; x < detinfo.size() ; x++) {
+//			out[i] = detinfo[x].m_iAngleIndex;
+//			i++;
+//		}
+//		for (int x = 0; x < detinfo.size() ; x++) {
+//			out[i] = detinfo[x].m_iDetectorIndex;
+//			i++;
+//		}
+//	}
+//
+//
+//}
+
+//-----------------------------------------------------------------------------------------
+/** result = astra_mex_projector3d('is_cuda', id);
+ *
+ * Return is the specified projector is a cuda projector.
+ * id: identifier of the projector object as stored in the astra-library.
+ */
+void astra_mex_projector3d_is_cuda(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: get input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iPid = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get projector
+	CProjector3D* pProjector = CProjector3DManager::getSingleton().get(iPid);
+	if (!pProjector || !pProjector->isInitialized()) {
+		mexErrMsgTxt("Projector not initialized.\n");
+		return;
+	}
+
+#ifdef ASTRA_CUDA
+	CCudaProjector3D* pCP = dynamic_cast<CCudaProjector3D*>(pProjector);
+	plhs[0] = mxCreateLogicalScalar(pCP ? 1 : 0);
+#else
+	plhs[0] = mxCreateLogicalScalar(0);
+#endif
+}
+
+
+//-----------------------------------------------------------------------------------------
+/**
+ * astra_mex_projector3d('help');
+ */
+void astra_mex_projector3d_help(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	cout << "astra_mex_projector3d help:" <<endl;
+	cout << "---------------------------" <<endl;
+}
+
+
+//-----------------------------------------------------------------------------------------
+
+static void printHelp()
+{
+	mexPrintf("Please specify a mode of operation.\n");
+	mexPrintf("Valid modes: create, delete, clear, get_projection_geometry,\n");
+	mexPrintf("             get_volume_geometry, weights_single_ray, weights_projection\n");
+	mexPrintf("				splat, is_cuda\n");
+}
+
+//-----------------------------------------------------------------------------------------
+/**
+ * [pid] = astra_mex_projector('read', projection_geometry, reconstruction_geometry);
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+				 int nrhs, const mxArray* prhs[])
+{
+	// INPUT: Mode
+	string sMode = "";
+	if (1 <= nrhs) {
+		sMode = mex_util_get_string(prhs[0]);	
+	} else {
+		printHelp();
+		return;
+	}
+
+	// SWITCH (MODE)
+	if (sMode == "create") {
+		astra_mex_projector3d_create(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "delete") {
+		astra_mex_projector3d_destroy(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "clear") {
+		astra_mex_projector3d_clear(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "get_projection_geometry") {
+		astra_mex_projector3d_get_projection_geometry(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "get_volume_geometry") {
+		astra_mex_projector3d_get_reconstruction_geometry(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "weights_single_ray") {
+		astra_mex_projector_weights_single_ray(nlhs, plhs, nrhs, prhs);
+	//} else if (sMode == "weights_projection") {
+	//	astra_mex_projector_weights_projection(nlhs, plhs, nrhs, prhs);
+	//} else if (sMode == "splat") {
+	//	astra_mex_projector_splat(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "is_cuda") {
+		astra_mex_projector3d_is_cuda(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "help") {
+		astra_mex_projector3d_help(nlhs, plhs, nrhs, prhs);
+	} else {
+		printHelp();
+	}
+	return;
+}
+
+
diff --git a/matlab/mex/astra_mex_projector3d_vc08.vcproj b/matlab/mex/astra_mex_projector3d_vc08.vcproj
new file mode 100644
index 0000000..bedc53b
--- /dev/null
+++ b/matlab/mex/astra_mex_projector3d_vc08.vcproj
@@ -0,0 +1,588 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="astra_mex_projector3d"
+	ProjectGUID="{F94CCD79-AA11-42DF-AC8A-6C9D2238A883}"
+	RootNamespace="astraMatlab"
+	TargetFrameworkVersion="131072"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;&quot;$(CUDA_INC_PATH)&quot;;..\..\lib\include;..\..\lib\include\cuda;..\..\include\;"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;&quot;$(CUDA_INC_PATH)&quot;;..\..\lib\include;..\..\lib\include\cuda;..\..\include\;"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;&quot;$(CUDA_INC_PATH)&quot;;..\..\lib\include;..\..\lib\include\cuda;..\..\include\;"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<File
+			RelativePath=".\astra_mex_projector3d_c.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.h"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/matlab/mex/astra_mex_projector_c.cpp b/matlab/mex/astra_mex_projector_c.cpp
new file mode 100644
index 0000000..5cbe502
--- /dev/null
+++ b/matlab/mex/astra_mex_projector_c.cpp
@@ -0,0 +1,510 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+/** \file astra_mex_projector_c.cpp
+ *
+ *  \brief Create and manage 2d projectors in the ASTRA workspace
+ */
+#include "astra/Globals.h"
+
+#include <mex.h>
+#include "mexHelpFunctions.h"
+
+#include "astra/AstraObjectManager.h"
+#include "astra/Projector2D.h"
+#include "astra/AstraObjectFactory.h"
+
+#include "astra/Float32VolumeData2D.h"
+
+#include "astra/ProjectionGeometry2D.h"
+#include "astra/ParallelProjectionGeometry2D.h"
+#include "astra/VolumeGeometry2D.h"
+
+
+#include <map>
+#include <vector>
+
+using namespace std;
+using namespace astra;
+
+//-----------------------------------------------------------------------------------------
+/** id = astra_mex_projector('create', cfg);
+ *
+ * Create and configure a new projector object.
+ * cfg: MATLAB struct containing the configuration parameters, see doxygen documentation for details.
+ * id: identifier of the projector object as it is now stored in the astra-library.
+ */
+void astra_mex_projector_create(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	int iIndex = 0;
+
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	if (!mxIsStruct(prhs[1])) {
+		mexErrMsgTxt("Argument 1 not a valid MATLAB struct. \n");
+	}
+
+
+	// turn MATLAB struct to an XML-based Config object
+	XMLDocument* xml = struct2XML("Projector2D", prhs[1]);
+	Config cfg;
+	cfg.self = xml->getRootNode();
+
+	// create algorithm
+	CProjector2D* pProj = CProjector2DFactory::getSingleton().create(cfg);
+	if (pProj == NULL) {
+		delete xml;
+		mexErrMsgTxt("Error creating projector. \n");
+		return;
+	}
+
+	delete xml;
+
+	// store projector
+	iIndex = CProjector2DManager::getSingleton().store(pProj);
+
+	// step4: set output
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(iIndex);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_projector('delete', id1, id2, ...);
+ *
+ * Delete one or more projector objects currently stored in the astra-library. 
+ * id1, id2, ... : identifiers of the projector objects as stored in the astra-library.
+ */
+void astra_mex_projector_delete(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	// step1: read input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+
+	for (int i = 1; i < nrhs; i++) {
+		int iPid = (int)(mxGetScalar(prhs[i]));
+		CProjector2DManager::getSingleton().remove(iPid);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_projector('clear');
+ *
+ * Delete all projector objects currently stored in the astra-library.
+ */
+void astra_mex_projector_clear(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	CProjector2DManager::getSingleton().clear();
+}
+
+//-----------------------------------------------------------------------------------------
+/** astra_mex_projector('info');
+ *
+ * Print information about all the projector objects currently stored in the astra-library.
+ */
+void astra_mex_projector_info(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	mexPrintf("%s", astra::CProjector2DManager::getSingleton().info().c_str());
+}
+
+//-----------------------------------------------------------------------------------------
+/** proj_geom = astra_mex_projector('projection_geometry', id);
+ *
+ * Fetch the projection geometry of a certain projector.
+ * id: identifier of the projector object as stored in the astra-library.
+ * proj_geom: MATLAB struct containing all information about the projection geometry
+*/
+void astra_mex_projector_projection_geometry(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	// step1: read input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iPid = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get projector
+	CProjector2D* pProjector = CProjector2DManager::getSingleton().get(iPid);
+	if (!pProjector || !pProjector->isInitialized()) {
+		mexErrMsgTxt("Projector not initialized.\n");
+		return;
+	}
+
+	// step3: get projection_geometry and turn it into a MATLAB struct
+	if (1 <= nlhs) {
+		plhs[0] = createProjectionGeometryStruct(pProjector->getProjectionGeometry());
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** vol_geom = astra_mex_projector('volume_geometry', id);
+ *
+ * Fetch the volume geometry of a certain projector.
+ * id: identifier of the projector object as stored in the astra-library.
+ * vol_geom: MATLAB struct containing all information about the volume geometry
+ */
+void astra_mex_projector_volume_geometry(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	// step1: read input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iPid = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get projector
+	CProjector2D* pProjector = CProjector2DManager::getSingleton().get(iPid);
+	if (!pProjector || !pProjector->isInitialized()) {
+		mexErrMsgTxt("Projector not initialized.\n");
+		return;
+	}
+
+	// step3: get projection_geometry and turn it into a MATLAB struct
+	if (1 <= nlhs) {
+		plhs[0] = createVolumeGeometryStruct(pProjector->getVolumeGeometry());
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** weights = astra_mex_projector('weights_single_ray', id, projection_index, detector_index);
+ *
+ * Calculate the nonzero weights of a certain projection ray.
+ * id: identifier of the projector object as stored in the astra-library.
+ * projection_index: index of the projection angle
+ * detector_index: index of the detector
+ * weights: list of computed weights [pixel_index, weight]
+ */
+void astra_mex_projector_weights_single_ray(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: get input
+	if (nrhs < 4) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iPid = (int)(mxGetScalar(prhs[1]));
+	int iProjectionIndex = (int)(mxGetScalar(prhs[2]));
+	int iDetectorIndex = (int)(mxGetScalar(prhs[3]));
+
+	// step2: get projector
+	CProjector2D* pProjector = CProjector2DManager::getSingleton().get(iPid);
+	if (!pProjector || !pProjector->isInitialized()) {
+		mexErrMsgTxt("Projector not initialized.\n");
+		return;
+	}
+	
+	// step3: create output vars
+	int iStoredPixelCount;
+	int iMaxPixelCount = pProjector->getProjectionWeightsCount(iProjectionIndex);
+	SPixelWeight* pPixelsWeights = new SPixelWeight[iMaxPixelCount];
+	
+	// step4: perform operation
+	pProjector->computeSingleRayWeights(iProjectionIndex, 
+										iDetectorIndex, 
+										pPixelsWeights, 
+										iMaxPixelCount, 
+										iStoredPixelCount);
+
+	// step5: return output
+	if (1 <= nlhs) {
+		mwSize dims[2];
+		dims[0] = iStoredPixelCount;
+		dims[1] = 2;
+
+		plhs[0] = mxCreateNumericArray(2, dims, mxDOUBLE_CLASS, mxREAL);
+		double* out = mxGetPr(plhs[0]);
+
+		for (int col = 0; col < iStoredPixelCount; col++) {
+			out[col] = pPixelsWeights[col].m_iIndex;
+			out[iStoredPixelCount+col] = pPixelsWeights[col].m_fWeight;
+		}	
+	}
+	
+	// garbage collection
+	delete[] pPixelsWeights;
+}
+
+//-----------------------------------------------------------------------------------------
+/** weights = astra_mex_projector('weights_projection', id, projection_index);
+ *
+ * Calculate the nonzero weights of all rays in a certain projection.
+ * id: identifier of the projector object as stored in the astra-library.
+ * projection_index: index of the projection angle
+ * weights: sparse matrix containing the rows of the projection matric belonging to the requested projection angle.
+ */
+void astra_mex_projector_weights_projection(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: get input
+	if (nrhs < 3) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iPid = (int)(mxGetScalar(prhs[1]));
+	int iProjectionIndex = (int)(mxGetScalar(prhs[2]));
+
+	// step2: get projector
+	CProjector2D* pProjector = CProjector2DManager::getSingleton().get(iPid);
+	if (!pProjector || !pProjector->isInitialized()) {
+		mexErrMsgTxt("Projector not initialized.\n");
+		return;
+	}
+
+	// step3: create output vars
+	SPixelWeight* pPixelsWheights = new SPixelWeight[pProjector->getProjectionWeightsCount(iProjectionIndex)];
+	int* piRayStoredPixelCount = new int[pProjector->getProjectionGeometry()->getDetectorCount()];
+
+	// step4: perform operation
+	pProjector->computeProjectionRayWeights(iProjectionIndex, pPixelsWheights, piRayStoredPixelCount);
+
+	// step5: return output
+	if (1 <= nlhs) {
+		// get basic values
+		int iMatrixSize = pProjector->getVolumeGeometry()->getWindowLengthX() *
+						  pProjector->getVolumeGeometry()->getWindowLengthY();
+		int iDetectorCount = pProjector->getProjectionGeometry()->getDetectorCount();
+		int iTotalStoredPixelCount = 0;
+		for (int i = 0; i < iDetectorCount; i++) {
+			iTotalStoredPixelCount += piRayStoredPixelCount[i];
+		}
+
+		// create matlab sparse matrix
+		plhs[0] = mxCreateSparse(iMatrixSize,				// number of rows (#pixels)
+							     iDetectorCount,			// number of columns (#detectors)
+								 iTotalStoredPixelCount,	// number of non-zero elements
+								 mxREAL);					// element type
+		double* values = mxGetPr(plhs[0]);
+		mwIndex* rows = mxGetIr(plhs[0]);
+		mwIndex* cols = mxGetJc(plhs[0]);
+		
+		int currentBase = 0;
+		int currentIndex = 0;
+		for (int i = 0; i < iDetectorCount; i++) {
+			for (int j = 0; j < piRayStoredPixelCount[i]; j++) {
+				values[currentIndex + j] = pPixelsWheights[currentBase + j].m_fWeight;
+				rows[currentIndex + j] = pPixelsWheights[currentBase + j].m_iIndex;
+			}
+					
+			currentBase += pProjector->getProjectionWeightsCount(iProjectionIndex) / pProjector->getProjectionGeometry()->getDetectorCount();
+			currentIndex += piRayStoredPixelCount[i];
+		}
+		cols[0] = piRayStoredPixelCount[0];
+		for (int j = 1; j < iDetectorCount; j++) {
+			cols[j] = cols[j-1] + piRayStoredPixelCount[j];
+		}
+		cols[iDetectorCount] = iTotalStoredPixelCount;
+	}
+	
+	delete[] pPixelsWheights;
+	delete[] piRayStoredPixelCount;
+}
+
+//-----------------------------------------------------------------------------------------
+/** hit_detectors = astra_mex_projector('splat', id, col, row);
+ *
+ * Create a list of detector indices which have a nonzero contribution to the projection matrix for a pixel [row,col].
+ * id: identifier of the projector object as stored in the astra-library.
+ * col: column of the pixel
+ * row: row of the pixel
+ * hit_detectors: list of detector indices [angle_index, det_index] that are hit
+ */
+void astra_mex_projector_splat(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: get input
+	if (nrhs < 4) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iPid = (int)(mxGetScalar(prhs[1]));
+	int iX = (int)(mxGetScalar(prhs[2]));
+	int iY = (int)(mxGetScalar(prhs[3]));
+
+	// step2: get projector
+	CProjector2D* pProjector = CProjector2DManager::getSingleton().get(iPid);
+	if (!pProjector || !pProjector->isInitialized()) {
+		mexErrMsgTxt("Projector not initialized.\n");
+		return;
+	}
+
+	// step3: perform action
+	vector<SDetector2D> detinfo = pProjector->projectPoint(iX, iY);
+
+	// step4: output
+	if (nlhs <= 1) {
+		plhs[0] = mxCreateDoubleMatrix(detinfo.size(),	// # rows
+									   2,				// # cols
+									   mxREAL);			// datatype 32-bits
+		double* out = mxGetPr(plhs[0]);
+
+		// fill up output
+		int i = 0;
+		int x;
+		for (x = 0; x < detinfo.size(); ++x) {
+			out[i] = detinfo[x].m_iAngleIndex;
+			++i;
+		}
+		for (x = 0; x < detinfo.size(); ++x) {
+			out[i] = detinfo[x].m_iDetectorIndex;
+			++i;
+		}
+	}
+
+
+}
+
+//-----------------------------------------------------------------------------------------
+/** matrix_id = astra_mex_projector('matrix', id);
+ *
+ * Create an explicit projection matrix for this projector.
+ * It returns an ID usable with astra_mex_matrix().
+ * id: identifier of the projector object as stored in the astra-library.
+ */
+void astra_mex_projector_matrix(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: get input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iPid = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get projector
+	CProjector2D* pProjector = CProjector2DManager::getSingleton().get(iPid);
+	if (!pProjector || !pProjector->isInitialized()) {
+		mexErrMsgTxt("Projector not initialized.\n");
+		return;
+	}
+
+	CSparseMatrix* pMatrix = pProjector->getMatrix();
+	if (!pMatrix || !pMatrix->isInitialized()) {
+		mexErrMsgTxt("Couldn't initialize data object.\n");
+		delete pMatrix;
+		return;
+	}
+
+	// store data object
+	int iIndex = CMatrixManager::getSingleton().store(pMatrix);
+
+	// return data id
+	if (1 <= nlhs) {
+		plhs[0] = mxCreateDoubleScalar(iIndex);
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+/** result = astra_mex_projector('is_cuda', id);
+ *
+ * Return is the specified projector is a cuda projector.
+ * id: identifier of the projector object as stored in the astra-library.
+ */
+void astra_mex_projector_is_cuda(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{ 
+	// step1: get input
+	if (nrhs < 2) {
+		mexErrMsgTxt("Not enough arguments.  See the help document for a detailed argument list. \n");
+		return;
+	}
+	int iPid = (int)(mxGetScalar(prhs[1]));
+
+	// step2: get projector
+	CProjector2D* pProjector = CProjector2DManager::getSingleton().get(iPid);
+	if (!pProjector || !pProjector->isInitialized()) {
+		mexErrMsgTxt("Projector not initialized.\n");
+		return;
+	}
+
+#ifdef ASTRA_CUDA
+	CCudaProjector2D* pCP = dynamic_cast<CCudaProjector2D*>(pProjector);
+	plhs[0] = mxCreateLogicalScalar(pCP ? 1 : 0);
+#else
+	plhs[0] = mxCreateLogicalScalar(0);
+#endif
+}
+
+
+
+//-----------------------------------------------------------------------------------------
+
+static void printHelp()
+{
+	mexPrintf("Please specify a mode of operation.\n");
+	mexPrintf("Valid modes: create, delete, clear, info, projection_geometry,\n");
+	mexPrintf("             volume_geometry, weights_single_ray, weights_projection\n");
+	mexPrintf("             splat, matrix, is_cuda\n");
+}
+
+
+//-----------------------------------------------------------------------------------------
+/**
+ * ... = astra_mex_projector(mode, ...);
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+				 int nrhs, const mxArray* prhs[])
+{
+	// INPUT: Mode
+	string sMode = "";
+	if (1 <= nrhs) {
+		sMode = mex_util_get_string(prhs[0]);	
+	} else {
+		printHelp();
+		return;
+	}
+
+	// SWITCH (MODE)
+	if (sMode == "create") {
+		astra_mex_projector_create(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "delete") {
+		astra_mex_projector_delete(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "clear") {
+		astra_mex_projector_clear(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "info") {
+		astra_mex_projector_info(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "projection_geometry") {
+		astra_mex_projector_projection_geometry(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "volume_geometry") {
+		astra_mex_projector_volume_geometry(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "weights_single_ray") {
+		astra_mex_projector_weights_single_ray(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "weights_projection") {
+		astra_mex_projector_weights_projection(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "splat") {
+		astra_mex_projector_splat(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "matrix") {
+		astra_mex_projector_matrix(nlhs, plhs, nrhs, prhs);
+	} else if (sMode == "is_cuda") {
+		astra_mex_projector_is_cuda(nlhs, plhs, nrhs, prhs);
+	} else {
+		printHelp();
+	}
+	return;
+}
+
+
diff --git a/matlab/mex/astra_mex_projector_vc08.vcproj b/matlab/mex/astra_mex_projector_vc08.vcproj
new file mode 100644
index 0000000..1380061
--- /dev/null
+++ b/matlab/mex/astra_mex_projector_vc08.vcproj
@@ -0,0 +1,591 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="astra_mex_projector"
+	ProjectGUID="{4DD6056F-8EEE-4C9A-B2A9-923F01A32E97}"
+	RootNamespace="astraMatlab"
+	TargetFrameworkVersion="131072"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="&quot;$(MATLAB_ROOT)\extern\include\&quot;;&quot;$(CUDA_INC_PATH)&quot;;..\..\lib\include;..\..\lib\include\cuda;..\..\include\"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;&quot;$(CUDA_INC_PATH)&quot;;..\..\lib\include;..\..\lib\include\cuda;..\..\include\;"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				BrowseInformation="1"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<File
+			RelativePath=".\astra_mex_projector_c.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.h"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/matlab/mex/astra_mex_vc08.vcproj b/matlab/mex/astra_mex_vc08.vcproj
new file mode 100644
index 0000000..58c1e0a
--- /dev/null
+++ b/matlab/mex/astra_mex_vc08.vcproj
@@ -0,0 +1,591 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="astra_mex"
+	ProjectGUID="{3FDA35E0-0D54-4663-A3E6-5ABA96F32221}"
+	RootNamespace="astraMatlab"
+	TargetFrameworkVersion="131072"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;&quot;$(CUDA_INC_PATH)&quot;;..\..\lib\include;..\..\lib\include\cuda;..\..\include\;"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="&quot;$(CUDA_INC_PATH)&quot;;$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				PreprocessorDefinitions="ASTRA_CUDA"
+				RuntimeLibrary="3"
+				BrowseInformation="1"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64D.lib libmex.lib libmx.lib libut.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw32"
+				AdditionalLibraryDirectories="..\..\bin\win32;$(MATLAB_ROOT)\extern\lib\win32\microsoft"
+				ModuleDefinitionFile="mex.def"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(SolutionDir)bin\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\$(ProjectName)"
+			ConfigurationType="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(MATLAB_ROOT)\extern\include\;..\..\lib\include;..\..\include"
+				RuntimeLibrary="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64D.lib libmex.lib libmx.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_c.mexw64"
+				AdditionalLibraryDirectories="..\..\bin\x64;$(MATLAB_ROOT)\extern\lib\win64\microsoft"
+				ModuleDefinitionFile="mex.def"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<File
+			RelativePath=".\astra_mex_c.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.cpp"
+			>
+		</File>
+		<File
+			RelativePath=".\mexHelpFunctions.h"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/matlab/mex/mex.def b/matlab/mex/mex.def
new file mode 100644
index 0000000..c54c4e0
--- /dev/null
+++ b/matlab/mex/mex.def
@@ -0,0 +1 @@
+EXPORTS mexFunction
\ No newline at end of file
diff --git a/matlab/mex/mexHelpFunctions.cpp b/matlab/mex/mexHelpFunctions.cpp
new file mode 100644
index 0000000..4105ee1
--- /dev/null
+++ b/matlab/mex/mexHelpFunctions.cpp
@@ -0,0 +1,642 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+/** \file mexHelpFunctions.cpp
+ *
+ *  \brief Contains some functions for interfacing matlab with c data structures
+ */
+#include "mexHelpFunctions.h"
+
+#include "astra/SparseMatrixProjectionGeometry2D.h"
+#include "astra/FanFlatVecProjectionGeometry2D.h"
+#include "astra/AstraObjectManager.h"
+
+using namespace std;
+using namespace astra;
+
+
+//-----------------------------------------------------------------------------------------
+// get string from matlab 
+std::string mex_util_get_string(const mxArray* pInput)
+{
+	if (!mxIsChar(pInput)) {
+		return "";
+	}
+	mwSize iLength = mxGetNumberOfElements(pInput) + 1;
+	char* buf = new char[iLength]; 
+	mxGetString(pInput, buf, iLength);
+	std::string res = std::string(buf);
+	delete[] buf;
+	return res;
+}
+
+//-----------------------------------------------------------------------------------------
+// is option
+bool isOption(std::list<std::string> lOptions, std::string sOption) 
+{
+	return std::find(lOptions.begin(), lOptions.end(), sOption) != lOptions.end();
+}
+
+//-----------------------------------------------------------------------------------------
+// turn a matlab struct into a c++ map
+std::map<std::string, mxArray*> parseStruct(const mxArray* pInput) 
+{
+	std::map<std::string, mxArray*> res;
+
+	// check type
+	if (!mxIsStruct(pInput)) {
+      mexErrMsgTxt("Input must be a struct.");
+	  return res;
+	}
+
+	// get field names
+	int nfields = mxGetNumberOfFields(pInput);
+	for (int i = 0; i < nfields; i++) {
+		std::string sFieldName = std::string(mxGetFieldNameByNumber(pInput, i));
+		res[sFieldName] = mxGetFieldByNumber(pInput,0,i);
+	}
+	return res;
+}
+
+//-----------------------------------------------------------------------------------------
+// turn a c++ map into a matlab struct
+mxArray* buildStruct(std::map<std::string, mxArray*> mInput) 
+{
+	mwSize dims[2] = {1, 1};
+	mxArray* res = mxCreateStructArray(2,dims,0,0);
+	
+	for (std::map<std::string, mxArray*>::iterator it = mInput.begin(); it != mInput.end(); it++) {
+		mxAddField(res, (*it).first.c_str());
+		mxSetField(res, 0, (*it).first.c_str(), (*it).second);
+	}
+	return res;
+}
+
+//-----------------------------------------------------------------------------------------
+// parse projection geometry data
+astra::CProjectionGeometry2D* parseProjectionGeometryStruct(const mxArray* prhs)
+{
+	// parse struct	
+	std::map<string, mxArray*> mStruct = parseStruct(prhs);
+
+	// create projection geometry object
+	string type = mex_util_get_string(mStruct["type"]);
+	if (type == "parallel") {
+
+		// detector_width
+		float32 fDetWidth = 1.0f;
+		mxArray* tmp = mStruct["detector_width"];
+		if (tmp != NULL) {
+			fDetWidth = (float32)(mxGetScalar(tmp));
+		}
+
+		// detector_count
+		int iDetCount = 100;
+		tmp = mStruct["detector_count"];
+		if (tmp != NULL) {
+			iDetCount = (int)(mxGetScalar(tmp));
+		}
+
+		// angles
+		float32* pfAngles;
+		int iAngleCount;
+		tmp = mStruct["projection_angles"];
+		if (tmp != NULL) {
+			double* angleValues = mxGetPr(tmp);
+			iAngleCount = mxGetN(tmp) * mxGetM(tmp);
+			pfAngles = new float32[iAngleCount];
+			for (int i = 0; i < iAngleCount; i++) {
+				pfAngles[i] = angleValues[i];
+			}
+		} else {
+			mexErrMsgTxt("'angles' not specified, error.");
+			return NULL;
+		}
+
+		// create projection geometry
+		return new astra::CParallelProjectionGeometry2D(iAngleCount,	// number of projections
+														iDetCount,		// number of detectors
+														fDetWidth,		// width of the detectors
+														pfAngles);		// angles array
+	} 
+	
+	else if (type == "fanflat") {
+
+		// detector_width
+		float32 fDetWidth = 1.0f;
+		mxArray* tmp = mStruct["detector_width"];
+		if (tmp != NULL) {
+			fDetWidth = (float32)(mxGetScalar(tmp));
+		}
+
+		// detector_count
+		int iDetCount = 100;
+		tmp = mStruct["detector_count"];
+		if (tmp != NULL) {
+			iDetCount = (int)(mxGetScalar(tmp));
+		}
+
+		// angles
+		float32* pfAngles;
+		int iAngleCount;
+		tmp = mStruct["projection_angles"];
+		if (tmp != NULL) {
+			double* angleValues = mxGetPr(tmp);
+			iAngleCount = mxGetN(tmp) * mxGetM(tmp);
+			pfAngles = new float32[iAngleCount];
+			for (int i = 0; i < iAngleCount; i++) {
+				pfAngles[i] = angleValues[i];
+			}
+		} else {
+			mexErrMsgTxt("'angles' not specified, error.");
+			return NULL;
+		}
+
+		// origin_source_dist
+		int iDistOriginSource = 100;
+		tmp = mStruct["origin_source_dist"];
+		if (tmp != NULL) {
+			iDistOriginSource = (int)(mxGetScalar(tmp));
+		}
+
+		// origin_det_dist
+		int iDistOriginDet = 100;
+		tmp = mStruct["origin_det_dist"];
+		if (tmp != NULL) {
+			iDistOriginDet = (int)(mxGetScalar(tmp));
+		}
+
+		// create projection geometry
+		return new astra::CFanFlatProjectionGeometry2D(iAngleCount,			// number of projections
+													   iDetCount,			// number of detectors
+													   fDetWidth,			// width of the detectors
+													   pfAngles,			// angles array
+													   iDistOriginSource,	// distance origin source
+													   iDistOriginDet);		// distance origin detector
+	}
+
+	else {
+		mexPrintf("Only parallel and fanflat projection geometry implemented.");
+		return NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------------------
+// create projection geometry data
+mxArray* createProjectionGeometryStruct(astra::CProjectionGeometry2D* _pProjGeom)
+{
+	// temporary map to store the data for the MATLAB struct
+	std::map<std::string, mxArray*> mGeometryInfo;
+
+	// detectorCount
+	mGeometryInfo["DetectorCount"] = mxCreateDoubleScalar(_pProjGeom->getDetectorCount());
+	
+	if (!_pProjGeom->isOfType("fanflat_vec")) {
+		// detectorWidth
+		mGeometryInfo["DetectorWidth"] = mxCreateDoubleScalar(_pProjGeom->getDetectorWidth());
+
+		// pfProjectionAngles
+		mxArray* pAngles = mxCreateDoubleMatrix(1, _pProjGeom->getProjectionAngleCount(), mxREAL);
+		double* out = mxGetPr(pAngles);
+		for (int i = 0; i < _pProjGeom->getProjectionAngleCount(); i++) {
+			out[i] = _pProjGeom->getProjectionAngle(i);
+		}
+		mGeometryInfo["ProjectionAngles"] = pAngles;
+	}
+	else {
+		astra::CFanFlatVecProjectionGeometry2D* pVecGeom = dynamic_cast<astra::CFanFlatVecProjectionGeometry2D*>(_pProjGeom);
+		mxArray* pVectors = mxCreateDoubleMatrix(1, pVecGeom->getProjectionAngleCount()*6, mxREAL);
+		double* out = mxGetPr(pVectors);
+		int iDetCount = pVecGeom->getDetectorCount();
+		for (int i = 0; i < pVecGeom->getProjectionAngleCount(); i++) {
+			const SFanProjection* p = &pVecGeom->getProjectionVectors()[i];
+			out[6*i + 0] = p->fSrcX;
+			out[6*i + 1] = p->fSrcY;
+			out[6*i + 2] = p->fDetSX + 0.5f*iDetCount*p->fDetUX;
+			out[6*i + 3] = p->fDetSY + 0.5f*iDetCount*p->fDetUY;
+			out[6*i + 4] = p->fDetUX;
+			out[6*i + 5] = p->fDetUY;
+		}
+		mGeometryInfo["Vectors"] = pVectors;
+	}
+
+	// parallel specific options
+	if (_pProjGeom->isOfType("parallel")) {
+		// type
+		mGeometryInfo["type"] = mxCreateString("parallel");
+	}
+	// fanflat specific options
+	else if (_pProjGeom->isOfType("fanflat")) {
+		astra::CFanFlatProjectionGeometry2D* pFanFlatGeom = dynamic_cast<astra::CFanFlatProjectionGeometry2D*>(_pProjGeom);
+		// detectorCount
+		mGeometryInfo["DistanceOriginSource"] = mxCreateDoubleScalar(pFanFlatGeom->getOriginSourceDistance());
+		// detectorWidth
+		mGeometryInfo["DistanceOriginDetector"] = mxCreateDoubleScalar(pFanFlatGeom->getOriginDetectorDistance());
+		// type
+		mGeometryInfo["type"] = mxCreateString("fanflat");
+	}
+	else if (_pProjGeom->isOfType("sparse_matrix")) {
+		astra::CSparseMatrixProjectionGeometry2D* pSparseMatrixGeom = dynamic_cast<astra::CSparseMatrixProjectionGeometry2D*>(_pProjGeom);
+		mGeometryInfo["type"] = mxCreateString("sparse_matrix");
+		mGeometryInfo["MatrixID"] = mxCreateDoubleScalar(CMatrixManager::getSingleton().getIndex(pSparseMatrixGeom->getMatrix()));
+	}
+	else if(_pProjGeom->isOfType("fanflat_vec")) {
+		mGeometryInfo["type"] = mxCreateString("fanflat_vec");
+	}
+
+	// build and return the MATLAB struct
+	return buildStruct(mGeometryInfo);
+}
+
+//-----------------------------------------------------------------------------------------
+// parse reconstruction geometry data
+astra::CVolumeGeometry2D* parseVolumeGeometryStruct(const mxArray* prhs)
+{
+	// parse struct	
+	std::map<string, mxArray*> mStruct = parseStruct(prhs);
+
+	std::map<string, mxArray*> mOptions = parseStruct(mStruct["option"]);
+
+	// GridColCount
+	int iWindowColCount = 128;
+	mxArray* tmp = mStruct["GridColCount"];
+	if (tmp != NULL) {
+		iWindowColCount = (int)(mxGetScalar(tmp));
+	} 
+
+	// GridRowCount
+	int iWindowRowCount = 128;
+	tmp = mStruct["GridRowCount"];
+	if (tmp != NULL) {
+		iWindowRowCount = (int)(mxGetScalar(tmp));
+	}
+
+	// WindowMinX
+	float32 fWindowMinX = - iWindowColCount / 2;
+	tmp = mOptions["WindowMinX"];
+	if (tmp != NULL) {
+		fWindowMinX = (float32)(mxGetScalar(tmp));
+	} 
+
+	// WindowMaxX
+	float32 fWindowMaxX = iWindowColCount / 2;
+	tmp = mOptions["WindowMaxX"];
+	if (tmp != NULL) {
+		fWindowMaxX = (float32)(mxGetScalar(tmp));
+	} 
+
+	// WindowMinY
+	float32 fWindowMinY = - iWindowRowCount / 2;
+	tmp = mOptions["WindowMinY"];
+	if (tmp != NULL) {
+		fWindowMinY = (float32)(mxGetScalar(tmp));
+	} 
+
+	// WindowMaxX
+	float32 fWindowMaxY = iWindowRowCount / 2;
+	tmp = mOptions["WindowMaxY"];
+	if (tmp != NULL) {
+		fWindowMaxY = (float32)(mxGetScalar(tmp));
+	} 
+	
+	// create and return reconstruction geometry
+	return new astra::CVolumeGeometry2D(iWindowColCount, iWindowRowCount, 
+										fWindowMinX, fWindowMinY, 
+										fWindowMaxX, fWindowMaxY);
+}
+
+//-----------------------------------------------------------------------------------------
+// create reconstruction geometry data
+mxArray* createVolumeGeometryStruct(astra::CVolumeGeometry2D* _pReconGeom)
+{
+	// temporary map to store the data for the MATLAB struct
+	std::map<std::string, mxArray*> mGeometryInfo;
+
+	// fill up map
+	mGeometryInfo["GridColCount"] = mxCreateDoubleScalar(_pReconGeom->getGridColCount());
+	mGeometryInfo["GridRowCount"] = mxCreateDoubleScalar(_pReconGeom->getGridRowCount());
+
+	std::map<std::string, mxArray*> mGeometryOptions;
+	mGeometryOptions["WindowMinX"] = mxCreateDoubleScalar(_pReconGeom->getWindowMinX());
+	mGeometryOptions["WindowMaxX"] = mxCreateDoubleScalar(_pReconGeom->getWindowMaxX());
+	mGeometryOptions["WindowMinY"] = mxCreateDoubleScalar(_pReconGeom->getWindowMinY());
+	mGeometryOptions["WindowMaxY"] = mxCreateDoubleScalar(_pReconGeom->getWindowMaxY());
+
+	mGeometryInfo["option"] = buildStruct(mGeometryOptions);
+
+	// build and return the MATLAB struct
+	return buildStruct(mGeometryInfo);
+}
+
+
+//-----------------------------------------------------------------------------------------
+string matlab2string(const mxArray* pField)
+{
+	// is string?
+	if (mxIsChar(pField)) {
+		return mex_util_get_string(pField);
+	}
+
+	// is scalar?
+	if (mxIsNumeric(pField) && mxGetM(pField)*mxGetN(pField) == 1) {
+		return boost::lexical_cast<string>(mxGetScalar(pField));
+	}
+
+	return "";
+}
+
+//-----------------------------------------------------------------------------------------
+// Options struct to xml node
+bool readOptions(XMLNode* node, const mxArray* pOptionStruct)
+{
+	// loop all fields
+	int nfields = mxGetNumberOfFields(pOptionStruct);
+	for (int i = 0; i < nfields; i++) {
+		std::string sFieldName = std::string(mxGetFieldNameByNumber(pOptionStruct, i));
+		const mxArray* pField = mxGetFieldByNumber(pOptionStruct, 0, i);
+
+		if (node->hasOption(sFieldName)) {
+			mexErrMsgTxt("Duplicate option");
+			return false;
+		}
+	
+		// string or scalar
+		if (mxIsChar(pField) || mex_is_scalar(pField)) {
+			string sValue = matlab2string(pField);
+			node->addOption(sFieldName, sValue);
+		} else
+		// numerical array
+		if (mxIsNumeric(pField) && mxGetM(pField)*mxGetN(pField) > 1) {
+			if (!mxIsDouble(pField)) {
+				mexErrMsgTxt("Numeric input must be double.");
+				return false;
+			}
+
+			XMLNode* listbase = node->addChildNode("Option");
+			listbase->addAttribute("key", sFieldName);
+			listbase->addAttribute("listsize", mxGetM(pField)*mxGetN(pField));
+			double* pdValues = mxGetPr(pField);
+			int index = 0;
+			for (unsigned int row = 0; row < mxGetM(pField); row++) {
+				for (unsigned int col = 0; col < mxGetN(pField); col++) {
+					XMLNode* item = listbase->addChildNode("ListItem");
+					item->addAttribute("index", index);
+					item->addAttribute("value", pdValues[col*mxGetM(pField)+row]);
+					index++;
+					delete item;
+				}
+			}
+			delete listbase;
+		} else {
+			mexErrMsgTxt("Unsupported option type");
+			return false;
+		}
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------------------
+// struct to xml node
+bool readStruct(XMLNode* root, const mxArray* pStruct)
+{
+	// loop all fields
+	int nfields = mxGetNumberOfFields(pStruct);
+	for (int i = 0; i < nfields; i++) {
+
+		// field and fieldname
+		std::string sFieldName = std::string(mxGetFieldNameByNumber(pStruct, i));
+		const mxArray* pField = mxGetFieldByNumber(pStruct, 0, i);
+
+		// string
+		if (mxIsChar(pField)) {
+			string sValue = matlab2string(pField);
+			if (sFieldName == "type") {
+				root->addAttribute("type", sValue);
+			} else {
+				delete root->addChildNode(sFieldName, sValue);
+			}
+		}
+
+		// scalar
+		if (mex_is_scalar(pField)) {
+			string sValue = matlab2string(pField);
+			delete root->addChildNode(sFieldName, sValue);
+		}
+
+		// numerical array
+		if (mxIsNumeric(pField) && mxGetM(pField)*mxGetN(pField) > 1) {
+			if (!mxIsDouble(pField)) {
+				mexErrMsgTxt("Numeric input must be double.");
+				return false;
+			}
+			XMLNode* listbase = root->addChildNode(sFieldName);
+			listbase->addAttribute("listsize", mxGetM(pField)*mxGetN(pField));
+			double* pdValues = mxGetPr(pField);
+			int index = 0;
+			for (unsigned int row = 0; row < mxGetM(pField); row++) {
+				for (unsigned int col = 0; col < mxGetN(pField); col++) {
+					XMLNode* item = listbase->addChildNode("ListItem");
+					item->addAttribute("index", index);
+					item->addAttribute("value", pdValues[col*mxGetM(pField)+row]);
+					index++;
+					delete item;
+				}
+			}
+			delete listbase;
+		}
+
+
+		// not castable to a single string
+		if (mxIsStruct(pField)) {
+			if (sFieldName == "options" || sFieldName == "option" || sFieldName == "Options" || sFieldName == "Option") {
+				bool ret = readOptions(root, pField);
+				if (!ret)
+					return false;
+			} else {
+				XMLNode* newNode = root->addChildNode(sFieldName);
+				bool ret = readStruct(newNode, pField);
+				delete newNode;
+				if (!ret)
+					return false;
+			}
+		}
+
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------------------
+// turn a MATLAB struct into an XML Document
+XMLDocument* struct2XML(string rootname, const mxArray* pStruct)
+{
+	if (!mxIsStruct(pStruct)) {
+      mexErrMsgTxt("Input must be a struct.");
+	  return NULL;
+	}
+
+	// create the document
+	XMLDocument* doc = XMLDocument::createDocument(rootname);
+	XMLNode* rootnode = doc->getRootNode();
+
+	// read the struct
+	bool ret = readStruct(rootnode, pStruct);
+	//doc->getRootNode()->print();
+	delete rootnode;
+
+	if (!ret) {
+		delete doc;
+		doc = 0;
+	}
+
+	return doc;
+}
+
+
+
+
+
+//-----------------------------------------------------------------------------------------
+// turn an std vector<float32> object to an mxArray
+mxArray* vectorToMxArray(std::vector<astra::float32> mInput)
+{
+	mxArray* res = mxCreateDoubleMatrix(1, mInput.size(), mxREAL);
+	double* pdData = mxGetPr(res);
+	for (unsigned int i = 0; i < mInput.size(); i++) {
+		pdData[i] = mInput[i];
+	}
+	return res;
+}
+
+//-----------------------------------------------------------------------------------------
+// turn a vector<vector<float32>> object to an mxArray
+mxArray* vector2DToMxArray(std::vector<std::vector<astra::float32> > mInput)
+{
+	unsigned int sizex = mInput.size();
+	if (sizex == 0) return mxCreateString("empty");
+	unsigned int sizey = mInput[0].size();
+
+	mxArray* res = mxCreateDoubleMatrix(sizex, sizey, mxREAL);
+	double* pdData = mxGetPr(res);
+	for (unsigned int i = 0; i < sizex; i++) {
+		for (unsigned int j = 0; j < sizey && j < mInput[i].size(); j++) {
+			pdData[j*sizex+i] = mInput[i][j];
+		}
+	}
+	return res;
+}
+
+//-----------------------------------------------------------------------------------------
+// turn a boost::any object to an mxArray
+mxArray* anyToMxArray(boost::any _any) 
+{
+	if (_any.type() == typeid(std::string)) {
+		std::string str = boost::any_cast<std::string>(_any);
+		return mxCreateString(str.c_str());     
+	}
+	if (_any.type() == typeid(int)) {
+		return mxCreateDoubleScalar(boost::any_cast<int>(_any));
+	}
+	if (_any.type() == typeid(float32)) {
+		return mxCreateDoubleScalar(boost::any_cast<float32>(_any));
+	}
+	if (_any.type() == typeid(std::vector<astra::float32>)) {
+		return vectorToMxArray(boost::any_cast<std::vector<float32> >(_any));
+	}
+	if (_any.type() == typeid(std::vector<std::vector<astra::float32> >)) {
+		return vector2DToMxArray(boost::any_cast<std::vector<std::vector<float32> > >(_any));
+	}
+	return NULL;
+}
+//-----------------------------------------------------------------------------------------
+// return true ig the argument is a scalar
+bool mex_is_scalar(const mxArray* pInput)
+{
+	return (mxIsNumeric(pInput) && mxGetM(pInput)*mxGetN(pInput) == 1);
+}
+
+//-----------------------------------------------------------------------------------------
+mxArray* XML2struct(astra::XMLDocument* xml)
+{
+	XMLNode* node = xml->getRootNode();
+	mxArray* str = XMLNode2struct(xml->getRootNode());
+	delete node;
+	return str;
+}
+
+//-----------------------------------------------------------------------------------------
+mxArray* XMLNode2struct(astra::XMLNode* node)
+{
+	std::map<std::string, mxArray*> mList; 
+
+	// type_attribute
+	if (node->hasAttribute("type")) {
+		mList["type"] = mxCreateString(node->getAttribute("type").c_str());
+	}
+
+	list<XMLNode*> nodes = node->getNodes();
+	for (list<XMLNode*>::iterator it = nodes.begin(); it != nodes.end(); it++) {
+		XMLNode* subnode = (*it);
+		// list
+		if (subnode->hasAttribute("listsize")) {
+			cout << "lkmdsqldqsjkl" << endl;
+			cout << " " << node->getContentNumericalArray().size() << endl;
+			mList[subnode->getName()] = vectorToMxArray(node->getContentNumericalArray());
+		}
+		// string
+		else {
+			mList[subnode->getName()] =  mxCreateString(subnode->getContent().c_str());
+		}
+		delete subnode;
+	}
+
+	return buildStruct(mList);
+}
+
+void get3DMatrixDims(const mxArray* x, mwSize *dims)
+{
+	const mwSize* mdims = mxGetDimensions(x);
+	mwSize dimCount = mxGetNumberOfDimensions(x);
+	if (dimCount == 1) {
+		dims[0] = mdims[0];
+		dims[1] = 1;
+		dims[2] = 1;
+	} else if (dimCount == 2) {
+		dims[0] = mdims[0];
+		dims[1] = mdims[1];
+		dims[2] = 1;
+	} else if (dimCount == 3) {
+		dims[0] = mdims[0];
+		dims[1] = mdims[1];
+		dims[2] = mdims[2];
+	} else {
+		dims[0] = 0;
+		dims[1] = 0;
+		dims[2] = 0;
+	}
+} 
diff --git a/matlab/mex/mexHelpFunctions.h b/matlab/mex/mexHelpFunctions.h
new file mode 100644
index 0000000..425b4ef
--- /dev/null
+++ b/matlab/mex/mexHelpFunctions.h
@@ -0,0 +1,76 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+#ifndef _INC_ASTRA_MEX_HELPFUNCTIONS
+#define _INC_ASTRA_MEX_HELPFUNCTIONS
+
+#include <string>
+#include <list>
+#include <iostream>
+#include <sstream>
+#include <map>
+#include <algorithm>
+#include <mex.h>
+
+#include <boost/lexical_cast.hpp>
+#include <boost/any.hpp>
+
+#include "astra/Globals.h"
+#include "astra/Utilities.h"
+
+#include "astra/ParallelProjectionGeometry2D.h"
+#include "astra/FanFlatProjectionGeometry2D.h"
+#include "astra/VolumeGeometry2D.h"
+
+#include "astra/XMLDocument.h"
+#include "astra/XMLNode.h"
+
+std::string mex_util_get_string(const mxArray* pInput);
+bool isOption(std::list<std::string> lOptions, std::string sOption);
+
+bool mex_is_scalar(const mxArray* pInput);
+
+std::map<std::string, mxArray*> parseStruct(const mxArray* pInput);
+mxArray* buildStruct(std::map<std::string, mxArray*> mInput);
+mxArray* vectorToMxArray(std::vector<astra::float32> mInput);
+
+mxArray* anyToMxArray(boost::any _any);
+
+astra::CProjectionGeometry2D* parseProjectionGeometryStruct(const mxArray*);
+mxArray* createProjectionGeometryStruct(astra::CProjectionGeometry2D*);
+astra::CVolumeGeometry2D* parseVolumeGeometryStruct(const mxArray*);
+mxArray* createVolumeGeometryStruct(astra::CVolumeGeometry2D* _pReconGeom);
+
+astra::XMLDocument* struct2XML(string rootname, const mxArray* pStruct);
+
+mxArray* XML2struct(astra::XMLDocument* xml);
+mxArray* XMLNode2struct(astra::XMLNode* xml);
+
+void get3DMatrixDims(const mxArray* x, mwSize *dims);
+
+#endif
diff --git a/matlab/tools/ROIselectfull.m b/matlab/tools/ROIselectfull.m
new file mode 100644
index 0000000..a50c979
--- /dev/null
+++ b/matlab/tools/ROIselectfull.m
@@ -0,0 +1,18 @@
+function V_out = ROIselectfull(input, ROI)
+
+	s1 = size(input,1);
+	s2 = size(input,2);
+	[x y] = meshgrid(-(s2-1)/2:(s2-1)/2,(s1-1)/2:-1:-(s1-1)/2);
+	A = Afstand(x,y,0,0);
+
+	V_out = zeros(size(input));
+	for slice = 1:size(input,3);
+		V = input(:,:,slice);
+		V(A > ROI/2) = 0;
+		V_out(:,:,slice) = V; 
+	end
+end
+
+function A = Afstand(x1,y1,x2,y2)
+	A = sqrt((x1-x2).^2+(y1-y2).^2);
+end
\ No newline at end of file
diff --git a/matlab/tools/astra_add_noise_to_sino.m b/matlab/tools/astra_add_noise_to_sino.m
new file mode 100644
index 0000000..a262f49
--- /dev/null
+++ b/matlab/tools/astra_add_noise_to_sino.m
@@ -0,0 +1,47 @@
+function sinogram_out = astra_add_noise_to_sino(sinogram_in,I0)
+
+%--------------------------------------------------------------------------
+% sinogram_out = astra_add_noise_to_sino(sinogram_in,I0)
+%
+% Add poisson noise to a sinogram.
+%
+% sinogram_in: input sinogram, can be either MATLAB-data or an
+% astra-identifier.  In the latter case, this operation is inplace and the
+% result will also be stored in this data object.
+% I0: background intensity, used to set noise level, lower equals more
+% noise
+% sinogram_out: output sinogram in MATLAB-data.
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+if numel(sinogram_in) == 1
+	sinogramRaw = astra_mex_data2d('get', sinogram_in);
+else
+	sinogramRaw = sinogram_in;
+end
+
+% scale to [0,1]
+max_sinogramRaw = max(sinogramRaw(:));
+sinogramRawScaled = sinogramRaw ./ max_sinogramRaw;
+% to detector count
+sinogramCT = I0 * exp(-sinogramRawScaled);
+% add poison noise
+sinogramCT_A = sinogramCT * 1e-12;
+sinogramCT_B = double(imnoise(sinogramCT_A, 'poisson'));
+sinogramCT_C = sinogramCT_B * 1e12;
+% to density
+sinogramCT_D = sinogramCT_C / I0;
+sinogram_out = -max_sinogramRaw * log(sinogramCT_D);
+
+if numel(sinogram_in) == 1
+	astra_mex_data2d('store', sinogram_in, sinogram_out);
+end
diff --git a/matlab/tools/astra_clear.m b/matlab/tools/astra_clear.m
new file mode 100644
index 0000000..d42e395
--- /dev/null
+++ b/matlab/tools/astra_clear.m
@@ -0,0 +1,19 @@
+%--------------------------------------------------------------------------
+% Clears and frees memory of all objects (data, projectors, algorithms) 
+% currently in the astra-library.
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+astra_mex_data2d('clear');
+astra_mex_data3d('clear');
+astra_mex_algorithm('clear');
+astra_mex_projector('clear');
diff --git a/matlab/tools/astra_create_backprojection.m b/matlab/tools/astra_create_backprojection.m
new file mode 100644
index 0000000..7f0b02f
--- /dev/null
+++ b/matlab/tools/astra_create_backprojection.m
@@ -0,0 +1,63 @@
+function [vol_id, vol] = astra_create_backprojection(data, proj_id)
+
+%--------------------------------------------------------------------------
+% [vol_id, vol] = astra_create_backprojection(data, proj_id)
+% 
+% Create a CPU based back projection.
+%
+% data: input sinogram, can be either MATLAB-data or an astra-identifier.
+% proj_id: identifier of the projector as it is stored in the astra-library
+% vol_id: identifier of the volume data object as it is now stored in the astra-library.
+% vol: MATLAB data version of the volume
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+% get projection geometry
+proj_geom = astra_mex_projector('projection_geometry', proj_id);
+vol_geom = astra_mex_projector('volume_geometry', proj_id);
+
+% store sinogram
+if (numel(data) > 1)
+	sino_id = astra_mex_data2d('create','-sino', proj_geom, data);
+else
+	sino_id = data;
+end
+
+% store volume
+vol_id = astra_mex_data2d('create','-vol', vol_geom, 0);
+
+if astra_mex_projector('is_cuda', proj_id)
+	cfg = astra_struct('BP_CUDA');
+else
+	cfg = astra_struct('BP');
+end
+
+cfg.ProjectorId = proj_id;
+cfg.ProjectionDataId = sino_id;
+cfg.ReconstructionDataId = vol_id;
+
+% create backprojection
+alg_id = astra_mex_algorithm('create', cfg);
+astra_mex_algorithm('iterate', alg_id);
+astra_mex_algorithm('delete', alg_id);
+
+if (numel(data) > 1)
+	astra_mex_data2d('delete', sino_id);
+end
+
+if nargout >= 2
+	vol = astra_mex_data2d('get',vol_id);
+end
+
+
+
diff --git a/matlab/tools/astra_create_backprojection3d_cuda.m b/matlab/tools/astra_create_backprojection3d_cuda.m
new file mode 100644
index 0000000..afa41db
--- /dev/null
+++ b/matlab/tools/astra_create_backprojection3d_cuda.m
@@ -0,0 +1,54 @@
+function [vol_id, vol] = astra_create_backprojection3d_cuda(data, proj_geom, vol_geom)
+
+%--------------------------------------------------------------------------
+% [vol_id, vol] = astra_create_backprojection3d_cuda(data, proj_geom, vol_geom)
+% 
+% Create a GPU based backprojection.
+%
+% data: input projection data, can be either MATLAB-data or an astra-identifier.
+% proj_geom: MATLAB struct containing the projection geometry.
+% vol_geom: MATLAB struct containing the volume geometry.
+% vol_id: identifier of the volume data object as it is now stored in
+% the astra-library. 
+% vol: MATLAB data version of the volume.
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+% store projection data
+if (numel(data) > 1)
+	sino_id = astra_mex_data3d('create','-proj3d', proj_geom, data);
+else
+	sino_id = data;
+end
+
+% store volume
+vol_id = astra_mex_data3d('create','-vol', vol_geom, 0);
+
+% create sinogram
+cfg = astra_struct('BP3D_CUDA');
+cfg.ProjectionDataId = sino_id;
+cfg.ReconstructionDataId = vol_id;
+alg_id = astra_mex_algorithm('create', cfg);
+astra_mex_algorithm('iterate', alg_id);
+astra_mex_algorithm('delete', alg_id);
+
+if (numel(data) > 1)
+	astra_mex_data3d('delete', sino_id);
+end
+
+if nargout >= 2
+	vol = astra_mex_data3d('get',vol_id);
+end
+
+
+
diff --git a/matlab/tools/astra_create_backprojection_cuda.m b/matlab/tools/astra_create_backprojection_cuda.m
new file mode 100644
index 0000000..cef7864
--- /dev/null
+++ b/matlab/tools/astra_create_backprojection_cuda.m
@@ -0,0 +1,39 @@
+function backProj = astra_create_backprojection_cuda(sinogramData, proj_geom, vol_geom)
+    %--------------------------------------------------------------------------
+    % backProj = astra_create_backprojection_cuda(sinogramData, proj_geom, vol_geom)
+    % 
+    % Creates a CUDA-based simple backprojection
+    %
+    % sinogramData: 2D matrix with projections stored row-based
+    % theta: projection angles, length should be equal to the number of rows in
+    % sinogramData
+    % reconstructionSize: vector with length 2 with the row and column count of
+    % the reconstruction image
+    % backProj: 2D back projection from sinogram data
+    %--------------------------------------------------------------------------
+    %------------------------------------------------------------------------
+    % This file is part of the
+    % All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+    %
+    % Copyright: iMinds-Vision Lab, University of Antwerp
+    % License: Open Source under GPLv3
+    % Contact: mailto:astra@ua.ac.be
+    % Website: http://astra.ua.ac.be
+    %------------------------------------------------------------------------
+    % $Id$
+
+    recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
+    sinogram_id = astra_mex_data2d('create', '-sino', proj_geom, sinogramData);
+
+    cfg = astra_struct('BP_CUDA');
+    cfg.ProjectionDataId = sinogram_id;
+    cfg.ReconstructionDataId = recon_id;
+
+    alg_id = astra_mex_algorithm('create', cfg);
+    astra_mex_algorithm('run', alg_id);
+    backProj = astra_mex_data2d('get', recon_id);
+
+    astra_mex_data2d('delete', sinogram_id);
+    astra_mex_data2d('delete', recon_id);
+    astra_mex_algorithm('delete', alg_id);
+end
diff --git a/matlab/tools/astra_create_fbp_reconstruction.m b/matlab/tools/astra_create_fbp_reconstruction.m
new file mode 100644
index 0000000..4456f9c
--- /dev/null
+++ b/matlab/tools/astra_create_fbp_reconstruction.m
@@ -0,0 +1,23 @@
+function [FBP_id, FBP] = astra_create_fbp_reconstruction(sinogram, proj_id)
+
+proj_geom = astra_mex_projector('projection_geometry', proj_id);
+vol_geom = astra_mex_projector('volume_geometry', proj_id);
+
+if numel(sinogram) == 1
+	sinogram_id = sinogram;
+else
+	sinogram_id = astra_mex_data2d('create', '-sino', proj_geom, sinogram);
+end
+
+FBP_id = astra_mex_data2d('create','-vol',vol_geom, 0);
+
+cfg = astra_struct('FBP_CUDA');
+cfg.ProjectionDataId = sinogram_id;
+cfg.ReconstructionDataId = FBP_id;
+cfg.FilterType = 'Ram-Lak';
+cfg.ProjectorId = proj_id;
+cfg.Options.GPUindex = 0;
+alg_id = astra_mex_algorithm('create', cfg);
+astra_mex_algorithm('run', alg_id);
+
+FBP = astra_mex_data2d('get', FBP_id);
diff --git a/matlab/tools/astra_create_proj_geom.m b/matlab/tools/astra_create_proj_geom.m
new file mode 100644
index 0000000..dbf0464
--- /dev/null
+++ b/matlab/tools/astra_create_proj_geom.m
@@ -0,0 +1,204 @@
+function proj_geom = astra_create_proj_geom(type, varargin)
+
+%--------------------------------------------------------------------------
+% proj_geom = astra_create_proj_geom('parallel', det_width, det_count, angles)
+%
+% Create a 2D parallel beam geometry.  See the API for more information.
+% det_width: distance between two adjacent detectors
+% det_count: number of detectors in a single projection
+% angles: projection angles in radians, should be between -pi/4 and 7pi/4
+% proj_geom: MATLAB struct containing all information of the geometry
+%--------------------------------------------------------------------------
+% proj_geom = astra_create_proj_geom('parallel3d', det_spacing_x, det_spacing_y, det_row_count, det_col_count, angles)
+%
+% Create a 3D parallel beam geometry.  See the API for more information.
+% det_spacing_x: distance between two horizontally adjacent detectors
+% det_spacing_y: distance between two vertically adjacent detectors
+% det_row_count: number of detector rows in a single projection
+% det_col_count: number of detector columns in a single projection
+% angles: projection angles in radians, should be between -pi/4 and 7pi/4
+% proj_geom: MATLAB struct containing all information of the geometry
+%--------------------------------------------------------------------------
+% proj_geom = astra_create_proj_geom('fanflat', det_width, det_count, angles, source_origin, origin_det)
+%
+% Create a 2D flat fan beam geometry.  See the API for more information.
+% det_width: distance between two adjacent detectors
+% det_count: number of detectors in a single projection
+% angles: projection angles in radians, should be between -pi/4 and 7pi/4
+% source_origin: distance between the source and the center of rotation
+% origin_det: distance between the center of rotation and the detector array
+% proj_geom: MATLAB struct containing all information of the geometry
+%--------------------------------------------------------------------------
+% proj_geom = astra_create_proj_geom('fanflat_vec', det_count, vectors)
+%
+% Create a 2D flat fan beam geometry specified by 2D vectors.
+%   See the API for more information.
+% det_count: number of detectors in a single projection
+% vectors: a matrix containing the actual geometry. Each row corresponds
+%          to a single projection, and consists of:
+%          ( srcX, srcY, dX, dY, uX, uY )
+%          src: the ray source
+%          d  : the center of the detector
+%          u  : the vector from detector pixel 0 to 1
+% proj_geom: MATLAB struct containing all information of the geometry
+%--------------------------------------------------------------------------
+% proj_geom = astra_create_proj_geom('cone',  det_spacing_x, det_spacing_y, det_row_count, det_col_count, angles, source_origin, origin_det)
+%
+% Create a 3D cone beam geometry.  See the API for more information.
+% det_spacing_x: distance between two horizontally adjacent detectors
+% det_spacing_y: distance between two vertically adjacent detectors
+% det_row_count: number of detector rows in a single projection
+% det_col_count: number of detector columns in a single projection
+% angles: projection angles in radians, should be between -pi/4 and 7pi/4
+% source_origin: distance between the source and the center of rotation
+% origin_det: distance between the center of rotation and the detector array
+% proj_geom: MATLAB struct containing all information of the geometry
+%--------------------------------------------------------------------------
+% proj_geom = astra_create_proj_geom('cone_vec',  det_row_count, det_col_count, vectors)
+%
+% Create a 3D cone beam geometry specified by 3D vectors.
+%   See the API for more information.
+% det_row_count: number of detector rows in a single projection
+% det_col_count: number of detector columns in a single projection
+% vectors: a matrix containing the actual geometry. Each row corresponds
+%          to a single projection, and consists of:
+%          ( srcX, srcY, srcZ, dX, dY, dZ, uX, uY, uZ, vX, vY, vZ )
+%          src: the ray source
+%          d  : the center of the detector
+%          u  : the vector from detector pixel (0,0) to (0,1)
+%          v  : the vector from detector pixel (0,0) to (1,0)
+% proj_geom: MATLAB struct containing all information of the geometry
+%--------------------------------------------------------------------------
+% proj_geom = astra_create_proj_geom('parallel3d_vec',  det_row_count, det_col_count, vectors)
+%
+% Create a 3D parallel beam geometry specified by 3D vectors.
+%   See the API for more information.
+% det_row_count: number of detector rows in a single projection
+% det_col_count: number of detector columns in a single projection
+% vectors: a matrix containing the actual geometry. Each row corresponds
+%          to a single projection, and consists of:
+%          ( rayX, rayY, rayZ, dX, dY, dZ, uX, uY, uZ, vX, vY, vZ )
+%          ray: the ray direction
+%          d  : the center of the detector
+%          u  : the vector from detector pixel (0,0) to (0,1)
+%          v  : the vector from detector pixel (0,0) to (1,0)
+% proj_geom: MATLAB struct containing all information of the geometry
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+if strcmp(type,'parallel')
+	if numel(varargin) < 3
+		error('not enough variables: astra_create_proj_geom(parallel, detector_spacing, det_count, angles)');
+	end
+	proj_geom = struct( ...
+		'type',					'parallel', ...
+		'DetectorWidth',		varargin{1}, ...
+		'DetectorCount',		varargin{2}, ...
+		'ProjectionAngles',		varargin{3}  ...
+	);
+
+elseif strcmp(type,'fanflat')
+	if numel(varargin) < 5
+		error('not enough variables: astra_create_proj_geom(fanflat, det_width, det_count, angles, source_origin, source_det)');
+	end	
+	proj_geom = struct( ...
+		'type',						'fanflat', ...
+		'DetectorWidth',			varargin{1}, ...
+		'DetectorCount',			varargin{2}, ...
+		'ProjectionAngles',			varargin{3},  ...
+		'DistanceOriginSource',		varargin{4},  ...		
+		'DistanceOriginDetector',	varargin{5}  ...
+	);
+
+elseif strcmp(type,'fanflat_vec')
+	if numel(varargin) < 2
+		error('not enough variables: astra_create_proj_geom(fanflat_vec, det_count, V')
+	end
+	if size(varargin{2}, 2) ~= 6
+		error('V should be a Nx6 matrix, with N the number of projections')
+	end
+	proj_geom = struct( ...
+		'type',					'fanflat_vec',  ...
+		'DetectorCount',		varargin{1}, ...
+		'Vectors',				varargin{2}  ...
+	);
+
+elseif strcmp(type,'parallel3d')
+	if numel(varargin) < 5
+		error('not enough variables: astra_create_proj_geom(parallel3d, detector_spacing_x, detector_spacing_y, det_row_count, det_col_count, angles)');
+	end
+	proj_geom = struct( ...
+		'type',					'parallel3d', ...
+		'DetectorSpacingX',		varargin{1}, ...
+		'DetectorSpacingY',		varargin{2}, ...
+		'DetectorRowCount',		varargin{3}, ...
+		'DetectorColCount',		varargin{4}, ...
+		'ProjectionAngles',		varargin{5}  ...
+	);
+elseif strcmp(type,'cone')
+	if numel(varargin) < 7
+		error('not enough variables: astra_create_proj_geom(cone, detector_spacing_x, detector_spacing_y, det_row_count, det_col_count, angles, source_origin, source_det)');
+	end
+	proj_geom = struct( ...
+		'type',					'cone', ...
+		'DetectorSpacingX',		varargin{1}, ...
+		'DetectorSpacingY',		varargin{2}, ...
+		'DetectorRowCount',		varargin{3}, ...
+		'DetectorColCount',		varargin{4}, ...
+		'ProjectionAngles',		varargin{5}, ...
+		'DistanceOriginSource',	varargin{6},  ...		
+		'DistanceOriginDetector',varargin{7}  ...		
+	);
+elseif strcmp(type,'cone_vec')
+	if numel(varargin) < 3
+		error('not enough variables: astra_create_proj_geom(cone_vec, det_row_count, det_col_count, V')
+	end
+	if size(varargin{3}, 2) ~= 12
+		error('V should be a Nx12 matrix, with N the number of projections')
+	end
+	proj_geom = struct( ...
+		'type',					'cone_vec',  ...
+		'DetectorRowCount',		varargin{1}, ...
+		'DetectorColCount',		varargin{2}, ...
+		'Vectors',				varargin{3}  ...
+	);
+elseif strcmp(type,'parallel3d_vec')
+	if numel(varargin) < 3
+		error('not enough variables: astra_create_proj_geom(parallel3d_vec, det_row_count, det_col_count, V')
+	end
+	if size(varargin{3}, 2) ~= 12
+		error('V should be a Nx12 matrix, with N the number of projections')
+	end
+	proj_geom = struct( ...
+		'type',					'parallel3d_vec',  ...
+		'DetectorRowCount',		varargin{1}, ...
+		'DetectorColCount',		varargin{2}, ...
+		'Vectors',				varargin{3}  ...
+	);
+elseif strcmp(type,'sparse_matrix')
+	if numel(varargin) < 3
+		error('not enough variables: astra_create_proj_geom(sparse_matrix, det_width, det_count, angles, matrix_id)')
+	end
+	proj_geom = struct( ...
+		'type',					'sparse_matrix', ...
+		'DetectorWidth',		varargin{1}, ...
+		'DetectorCount',		varargin{2}, ...
+		'ProjectionAngles',		varargin{3}, ...
+		'MatrixID',				varargin{4} ...
+	);
+
+else
+	disp(['Error: unknown type ' type]);
+	proj_geom = struct();
+end
+
diff --git a/matlab/tools/astra_create_projector.m b/matlab/tools/astra_create_projector.m
new file mode 100644
index 0000000..f773d0d
--- /dev/null
+++ b/matlab/tools/astra_create_projector.m
@@ -0,0 +1,50 @@
+function proj_id = astra_create_projector(type, proj_geom, vol_geom)
+
+%--------------------------------------------------------------------------
+% proj_id = astra_create_projector(type, proj_geom, vol_geom)
+% 
+% Create a new projector object based on projection and volume geometry.  
+% Used when the default values of each projector are sufficient.  
+%
+% type: type of the projector.  'blob', 'line', 'linear' 'strip', ... See API for more information.
+% proj_geom: MATLAB struct containing the projection geometry.
+% vol_geom: MATLAB struct containing the volume geometry.
+% proj_id: identifier of the projector as it is now stored in the astra-library.
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+cfg_proj = astra_struct(type);
+cfg_proj.ProjectionGeometry = proj_geom;
+cfg_proj.VolumeGeometry = vol_geom;
+
+if strcmp(type,'blob')
+	% Blob options
+	blob_size = 2;
+	blob_sample_rate = 0.01;
+	blob_values = kaiserBessel(2, 10.4, blob_size, 0:blob_sample_rate:blob_size);
+	cfg_proj.Kernel.KernelSize = blob_size;
+	cfg_proj.Kernel.SampleRate = blob_sample_rate;
+	cfg_proj.Kernel.SampleCount = length(blob_values);
+	cfg_proj.Kernel.KernelValues = blob_values;
+end
+
+if strcmp(type,'linear3d') || strcmp(type,'linearcone') || strcmp(type,'cuda3d')
+	proj_id = astra_mex_projector3d('create', cfg_proj);
+else
+	proj_id = astra_mex_projector('create', cfg_proj);
+end
+
+
+
+
+
diff --git a/matlab/tools/astra_create_reconstruction.m b/matlab/tools/astra_create_reconstruction.m
new file mode 100644
index 0000000..15e452c
--- /dev/null
+++ b/matlab/tools/astra_create_reconstruction.m
@@ -0,0 +1,97 @@
+function [recon_id, recon] = astra_create_reconstruction(rec_type, proj_id, sinogram, iterations, use_mask, mask, use_minc, minc, use_maxc, maxc)
+
+%--------------------------------------------------------------------------
+% [recon_id, recon] = astra_create_reconstruction(rec_type, proj_id, sinogram, iterations, use_mask, mask, use_minc, minc, use_maxc, maxc)
+%
+% Create a CPU based iterative reconstruction.
+%
+% rec_type: reconstruction type, 'ART', 'SART' 'SIRT' or 'CGLS', not all options are adjustable
+% proj_id: identifier of the projector as it is stored in the astra-library
+% sinogram: sinogram data OR sinogram identifier
+% iterations: number of iterations to perform
+% use_mask: use a reconstrucionmask? 'yes' or 'no'
+% mask: mask data OR mask identifier.
+% use_minc: use a minimum constraint? 'yes' or 'no'
+% minc: minimum constraint value
+% use_maxc: use a maximum constraint? 'yes' or 'no'
+% maxc: maximum constraint value
+% recon_id: identifier of the reconstruction data object as it is now stored in the astra-library
+% recon: MATLAB data version of the reconstruction
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+if nargin <= 4
+	use_mask = 'no';
+	mask = [];
+	use_minc = 'no';
+	minc = 0;
+	use_maxc = 'no';
+	maxc = 255;
+end
+
+if nargin <= 6
+	use_minc = 'no';
+	minc = 0;
+	use_maxc = 'no';
+	maxc = 255;
+end
+
+if numel(sinogram) == 1
+	sinogram_id = sinogram;
+else
+	proj_geom = astra_mex_projector('projection_geometry', proj_id);
+	sinogram_id = astra_mex_data2d('create', '-sino', proj_geom, sinogram);
+end
+
+% create reconstruction object
+vol_geom = astra_mex_projector('volume_geometry', proj_id);
+recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
+
+% configure
+cfg = astra_struct(rec_type);
+cfg.ProjectorId = proj_id;
+cfg.ProjectionDataId = sinogram_id;
+cfg.ReconstructionDataId = recon_id;
+if strcmp(use_mask,'yes')
+	if numel(mask) == 1
+		mask_id = mask;
+	else
+		mask_id = astra_mex_data2d('create', '-vol', vol_geom, mask);
+	end
+	cfg.options.ReconstructionMaskId = mask_id;	
+end
+cfg.options.UseMinConstraint = use_minc;
+cfg.options.MinConstraintValue = minc;
+cfg.options.UseMaxConstraint = use_maxc;
+cfg.options.MaxConstraintValue = maxc;
+cfg.options.ProjectionOrder = 'random';
+alg_id = astra_mex_algorithm('create', cfg);
+
+% iterate
+astra_mex_algorithm('iterate', alg_id, iterations);
+
+% return object
+recon = astra_mex_data2d('get', recon_id);
+
+% garbage collection
+astra_mex_algorithm('delete', alg_id);
+if numel(sinogram) ~= 1
+	astra_mex_data2d('delete', sinogram_id);
+end
+
+if strcmp(use_mask,'yes')
+	if numel(mask) ~= 1
+		astra_mex_data2d('delete', mask_id);
+	end
+end
+
diff --git a/matlab/tools/astra_create_reconstruction_cuda.m b/matlab/tools/astra_create_reconstruction_cuda.m
new file mode 100644
index 0000000..b428eb5
--- /dev/null
+++ b/matlab/tools/astra_create_reconstruction_cuda.m
@@ -0,0 +1,80 @@
+function [recon_id, recon] = astra_create_reconstruction_cuda(rec_type, proj_geom, vol_geom, sinogram, iterations, use_mask, mask, use_minc, minc, use_maxc, maxc)
+
+%--------------------------------------------------------------------------
+% [recon_id, recon] = astra_create_reconstruction_cuda(rec_type, proj_geom, vol_geom, sinogram, iterations, use_mask, mask, use_minc, minc, use_maxc, maxc)
+%
+% Create a GPU based iterative reconstruction.
+%
+% rec_type: reconstruction type, only 'SIRT_CUDA' for now
+% proj_geom: projection geometry struct
+% vol_geom: volume geometry struct
+% sinogram: sinogram data OR sinogram identifier
+% iterations: number of iterations to perform
+% use_mask: use a reconstrucionmask? 'yes' or 'no'
+% mask: mask data OR mask identifier.
+% use_minc: use a minimum constraint? 'yes' or 'no'
+% minc: minimum constraint value
+% use_maxc: use a maximum constraint? 'yes' or 'no'
+% maxc: maximum constraint value
+% recon_id: identifier of the reconstruction data object as it is now stored in the astra-library
+% recon: MATLAB data version of the reconstruction
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+if numel(sinogram) == 1
+	sinogram_id = sinogram;
+else
+	sinogram_id = astra_mex_data2d('create', '-sino', proj_geom, sinogram);
+end
+
+% create reconstruction object
+recon_id = astra_mex_data2d('create', '-vol', vol_geom, 0);
+
+% configure
+cfg = astra_struct('SIRT_CUDA');
+cfg.ProjectionGeometry = proj_geom;
+cfg.ReconstructionGeometry = vol_geom;
+cfg.ProjectionDataId = sinogram_id;
+cfg.ReconstructionDataId = recon_id;
+if strcmp(use_mask,'yes')
+	if numel(mask) == 1
+		mask_id = mask;
+	else
+		mask_id = astra_mex_data2d('create', '-vol', vol_geom, mask);
+	end
+	cfg.options.ReconstructionMaskId = mask_id;	
+end
+cfg.options.UseMinConstraint = use_minc;
+cfg.options.MinConstraintValue = minc;
+cfg.options.UseMaxConstraint = use_maxc;
+cfg.options.MaxConstraintValue = maxc;
+alg_id = astra_mex_algorithm('create', cfg);
+
+% iterate
+astra_mex_algorithm('iterate', alg_id, iterations);
+
+% return object
+recon = astra_mex_data2d('get', recon_id);
+
+% garbage collection
+astra_mex_algorithm('delete', alg_id);
+if numel(sinogram) ~= 1
+	astra_mex_data2d('delete', sinogram_id);
+end
+
+if strcmp(use_mask,'yes')
+	if numel(mask) ~= 1
+		astra_mex_data2d('delete', mask_id);
+	end
+end
+
diff --git a/matlab/tools/astra_create_sino.m b/matlab/tools/astra_create_sino.m
new file mode 100644
index 0000000..4771bd6
--- /dev/null
+++ b/matlab/tools/astra_create_sino.m
@@ -0,0 +1,63 @@
+function [sino_id, sino] = astra_create_sino(data, proj_id)
+
+%--------------------------------------------------------------------------
+% [sino_id, sino] = astra_create_sino(data, proj_id)
+% 
+% Create a CPU based forward projection.
+%
+% data: input volume, can be either MATLAB-data or an astra-identifier.
+% proj_id: identifier of the projector as it is stored in the astra-library
+% sino_id: identifier of the sinogram data object as it is now stored in the astra-library.
+% sino: MATLAB data version of the sinogram
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+% get projection geometry
+proj_geom = astra_mex_projector('projection_geometry', proj_id);
+vol_geom = astra_mex_projector('volume_geometry', proj_id);
+
+% store volume
+if (numel(data) > 1)
+	volume_id = astra_mex_data2d('create','-vol', vol_geom, data);
+else
+	volume_id = data;
+end
+
+% store sino
+sino_id = astra_mex_data2d('create','-sino', proj_geom, 0);
+
+if astra_mex_projector('is_cuda', proj_id)
+	cfg = astra_struct('FP_CUDA');
+else
+	cfg = astra_struct('FP');
+end
+
+cfg.ProjectorId = proj_id;
+cfg.ProjectionDataId = sino_id;
+cfg.VolumeDataId = volume_id;
+
+% create sinogram
+alg_id = astra_mex_algorithm('create', cfg);
+astra_mex_algorithm('iterate', alg_id);
+astra_mex_algorithm('delete', alg_id);
+
+if (numel(data) > 1)
+	astra_mex_data2d('delete', volume_id);
+end
+
+if nargout >= 2
+	sino = astra_mex_data2d('get',sino_id);
+end
+
+
+
diff --git a/matlab/tools/astra_create_sino3d_cuda.m b/matlab/tools/astra_create_sino3d_cuda.m
new file mode 100644
index 0000000..ef22ebe
--- /dev/null
+++ b/matlab/tools/astra_create_sino3d_cuda.m
@@ -0,0 +1,54 @@
+function [sino_id, sino] = astra_create_sino3d_cuda(data, proj_geom, vol_geom)
+
+%--------------------------------------------------------------------------
+% [sino_id, sino] = astra_create_sino3d_cuda(data, proj_geom, vol_geom)
+% 
+% Create a GPU based forward projection.
+%
+% data: input volume, can be either MATLAB-data or an astra-identifier.
+% proj_geom: MATLAB struct containing the projection geometry.
+% vol_geom: MATLAB struct containing the volume geometry.
+% sino_id: identifier of the sinogram data object as it is now stored in
+% the astra-library. 
+% sino: MATLAB data version of the sinogram.
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+% store volume
+if (numel(data) > 1)
+	volume_id = astra_mex_data3d('create','-vol', vol_geom, data);
+else
+	volume_id = data;
+end
+
+% store sino
+sino_id = astra_mex_data3d('create','-sino', proj_geom, 0);
+
+% create sinogram
+cfg = astra_struct('FP3D_CUDA');
+cfg.ProjectionDataId = sino_id;
+cfg.VolumeDataId = volume_id;
+alg_id = astra_mex_algorithm('create', cfg);
+astra_mex_algorithm('iterate', alg_id);
+astra_mex_algorithm('delete', alg_id);
+
+if (numel(data) > 1)
+	astra_mex_data3d('delete', volume_id);
+end
+
+if nargout >= 2
+	sino = astra_mex_data3d('get',sino_id);
+end
+
+
+
diff --git a/matlab/tools/astra_create_sino_cuda.m b/matlab/tools/astra_create_sino_cuda.m
new file mode 100644
index 0000000..82bda7c
--- /dev/null
+++ b/matlab/tools/astra_create_sino_cuda.m
@@ -0,0 +1,58 @@
+function [sino_id, sino] = astra_create_sino_cuda(data, proj_geom, vol_geom, gpu_index)
+
+%--------------------------------------------------------------------------
+% [sino_id, sino] = astra_create_sino_cuda(data, proj_geom, vol_geom, gpu_index)
+% 
+% Create a GPU based forward projection.
+%
+% data: input volume, can be either MATLAB-data or an astra-identifier.
+% proj_geom: MATLAB struct containing the projection geometry.
+% vol_geom: MATLAB struct containing the volume geometry.
+% gpu_index: the index of the GPU to use (optional).
+% sino_id: identifier of the sinogram data object as it is now stored in
+% the astra-library. 
+% sino: MATLAB data version of the sinogram.
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+% store volume
+if (numel(data) > 1)
+	volume_id = astra_mex_data2d('create','-vol', vol_geom, data);
+else
+	volume_id = data;
+end
+
+% store sino
+sino_id = astra_mex_data2d('create','-sino', proj_geom, 0);
+
+% create sinogram
+cfg = astra_struct('FP_CUDA');
+cfg.ProjectionDataId = sino_id;
+cfg.VolumeDataId = volume_id;
+if nargin > 3
+  cfg.option.GPUindex = gpu_index;
+end
+alg_id = astra_mex_algorithm('create', cfg);
+astra_mex_algorithm('iterate', alg_id);
+astra_mex_algorithm('delete', alg_id);
+
+if (numel(data) > 1)
+	astra_mex_data2d('delete', volume_id);
+end
+
+if nargout >= 2
+	sino = astra_mex_data2d('get',sino_id);
+end
+
+
+
diff --git a/matlab/tools/astra_create_sino_gpu.m b/matlab/tools/astra_create_sino_gpu.m
new file mode 100644
index 0000000..95a3b09
--- /dev/null
+++ b/matlab/tools/astra_create_sino_gpu.m
@@ -0,0 +1,58 @@
+function [sino_id, sino] = astra_create_sino_gpu(data, proj_geom, vol_geom, gpu_index)
+
+%--------------------------------------------------------------------------
+% [sino_id, sino] = astra_create_sino_gpu(data, proj_geom, vol_geom, gpu_index)
+% 
+% Create a GPU based forward projection.
+%
+% data: input volume, can be either MATLAB-data or an astra-identifier.
+% proj_geom: MATLAB struct containing the projection geometry.
+% vol_geom: MATLAB struct containing the volume geometry.
+% gpu_index: the index of the GPU to use (optional).
+% sino_id: identifier of the sinogram data object as it is now stored in
+% the astra-library. 
+% sino: MATLAB data version of the sinogram.
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+% store volume
+if (numel(data) > 1)
+	volume_id = astra_mex_data2d('create','-vol', vol_geom, data);
+else
+	volume_id = data;
+end
+
+% store sino
+sino_id = astra_mex_data2d('create','-sino', proj_geom, 0);
+
+% create sinogram
+cfg = astra_struct('FP_CUDA');
+cfg.ProjectionDataId = sino_id;
+cfg.VolumeDataId = volume_id;
+if nargin > 3
+  cfg.option.GPUindex = gpu_index;
+end
+alg_id = astra_mex_algorithm('create', cfg);
+astra_mex_algorithm('iterate', alg_id);
+astra_mex_algorithm('delete', alg_id);
+
+if (numel(data) > 1)
+	astra_mex_data2d('delete', volume_id);
+end
+
+if nargout >= 2
+	sino = astra_mex_data2d('get',sino_id);
+end
+
+
+
diff --git a/matlab/tools/astra_create_sino_sampling.m b/matlab/tools/astra_create_sino_sampling.m
new file mode 100644
index 0000000..6b86d61
--- /dev/null
+++ b/matlab/tools/astra_create_sino_sampling.m
@@ -0,0 +1,59 @@
+function [sino_id, sino] = astra_create_sino_sampling(data, proj_geom, vol_geom, gpu_index, sampling)
+
+%--------------------------------------------------------------------------
+% [sino_id, sino] = astra_create_sino_cuda(data, proj_geom, vol_geom, gpu_index)
+% 
+% Create a GPU based forward projection.
+%
+% data: input volume, can be either MATLAB-data or an astra-identifier.
+% proj_geom: MATLAB struct containing the projection geometry.
+% vol_geom: MATLAB struct containing the volume geometry.
+% gpu_index: the index of the GPU to use (optional).
+% sino_id: identifier of the sinogram data object as it is now stored in
+% the astra-library. 
+% sino: MATLAB data version of the sinogram.
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+
+% store volume
+if (numel(data) > 1)
+	volume_id = astra_mex_data2d('create','-vol', vol_geom, data);
+else
+	volume_id = data;
+end
+
+% store sino
+sino_id = astra_mex_data2d('create','-sino', proj_geom, 0);
+
+% create sinogram
+cfg = astra_struct('FP_CUDA');
+cfg.ProjectionDataId = sino_id;
+cfg.VolumeDataId = volume_id;
+cfg.option.DetectorSuperSampling = sampling;
+if nargin > 3
+  cfg.option.GPUindex = gpu_index;
+end
+alg_id = astra_mex_algorithm('create', cfg);
+astra_mex_algorithm('iterate', alg_id);
+astra_mex_algorithm('delete', alg_id);
+
+if (numel(data) > 1)
+	astra_mex_data2d('delete', volume_id);
+end
+
+if nargout >= 2
+	sino = astra_mex_data2d('get',sino_id);
+end
+
+
+
diff --git a/matlab/tools/astra_create_vol_geom.m b/matlab/tools/astra_create_vol_geom.m
new file mode 100644
index 0000000..61db8fb
--- /dev/null
+++ b/matlab/tools/astra_create_vol_geom.m
@@ -0,0 +1,96 @@
+function vol_geom = astra_create_vol_geom(varargin)
+
+%--------------------------------------------------------------------------
+% vol_geom = astra_create_vol_geom([row_count col_count]);
+% vol_geom = astra_create_vol_geom(row_count, col_count);
+% vol_geom = astra_create_vol_geom(row_count, col_count, min_x, max_x, min_y, max_y);
+%
+% Create a 2D volume geometry.  See the API for more information.
+% row_count: number of rows.
+% col_count: number of columns.
+% min_x: minimum value on the x-axis.
+% max_x: maximum value on the x-axis.
+% min_y: minimum value on the y-axis.
+% max_y: maximum value on the y-axis.
+% vol_geom: MATLAB struct containing all information of the geometry.
+%--------------------------------------------------------------------------
+% vol_geom = astra_create_vol_geom(row_count, col_count, slice_count);
+%
+% Create a 3D volume geometry.  See the API for more information.
+% row_count: number of rows.
+% col_count: number of columns.
+% slice_count: number of slices.
+% vol_geom: MATLAB struct containing all information of the geometry.
+%--------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+% astra_create_vol_geom([row_and_col_count ])
+if numel(varargin) == 1 && numel(varargin{1}) == 1
+	vol_geom = struct();
+	vol_geom.GridRowCount = varargin{1}(1);
+	vol_geom.GridColCount =	varargin{1}(1);
+	vol_geom.option.WindowMinX = -varargin{1}(1) / 2;
+	vol_geom.option.WindowMaxX = varargin{1}(1) / 2;
+	vol_geom.option.WindowMinY = -varargin{1}(1) / 2;
+	vol_geom.option.WindowMaxY = varargin{1}(1) / 2;
+
+
+% astra_create_vol_geom([row_count col_count])
+elseif numel(varargin) == 1 && numel(varargin{1}) == 2
+	vol_geom = struct();
+	vol_geom.GridRowCount = varargin{1}(1);
+	vol_geom.GridColCount =	varargin{1}(2);
+	vol_geom.option.WindowMinX = -varargin{1}(2) / 2;
+	vol_geom.option.WindowMaxX = varargin{1}(2) / 2;
+	vol_geom.option.WindowMinY = -varargin{1}(1) / 2;
+	vol_geom.option.WindowMaxY = varargin{1}(1) / 2;
+
+% astra_create_vol_geom([row_count col_count slice_count])
+elseif numel(varargin) == 1 && numel(varargin{1}) == 3
+	vol_geom = struct();
+	vol_geom.GridRowCount = varargin{1}(1);
+	vol_geom.GridColCount =	varargin{1}(2);
+	vol_geom.GridSliceCount = varargin{1}(3);	
+	vol_geom.option.WindowMinX = -varargin{1}(2) / 2;
+	vol_geom.option.WindowMaxX = varargin{1}(2) / 2;
+	vol_geom.option.WindowMinY = -varargin{1}(1) / 2;
+	vol_geom.option.WindowMaxY = varargin{1}(1) / 2;
+	vol_geom.option.WindowMinZ = -varargin{1}(3) / 2;
+	vol_geom.option.WindowMaxZ = varargin{1}(3) / 2;	
+	
+% astra_create_vol_geom(row_count, col_count)
+elseif numel(varargin) == 2
+	vol_geom = struct();
+	vol_geom.GridRowCount = varargin{1};
+	vol_geom.GridColCount =	varargin{2};
+	vol_geom.option.WindowMinX = -varargin{2} / 2;
+	vol_geom.option.WindowMaxX = varargin{2} / 2;
+	vol_geom.option.WindowMinY = -varargin{1} / 2;
+	vol_geom.option.WindowMaxY = varargin{1} / 2;
+
+% astra_create_vol_geom(row_count, col_count, min_x, max_x, min_y, max_y)
+elseif numel(varargin) == 6
+	vol_geom = struct();
+	vol_geom.GridRowCount = varargin{1};
+	vol_geom.GridColCount = varargin{2};
+	vol_geom.option.WindowMinX = varargin{3};
+	vol_geom.option.WindowMaxX = varargin{4};
+	vol_geom.option.WindowMinY = varargin{5};
+	vol_geom.option.WindowMaxY = varargin{6};
+
+% astra_create_vol_geom(row_count, col_count, slice_count)
+elseif numel(varargin) == 3
+	vol_geom = struct();
+	vol_geom.GridRowCount =	varargin{1};
+	vol_geom.GridColCount = varargin{2};
+	vol_geom.GridSliceCount = varargin{3};
+end
diff --git a/matlab/tools/astra_data_gui.fig b/matlab/tools/astra_data_gui.fig
new file mode 100644
index 0000000..d73e430
--- /dev/null
+++ b/matlab/tools/astra_data_gui.fig
diff --git a/matlab/tools/astra_data_gui.m b/matlab/tools/astra_data_gui.m
new file mode 100644
index 0000000..337a5d4
--- /dev/null
+++ b/matlab/tools/astra_data_gui.m
@@ -0,0 +1,396 @@
+function varargout = astra_data_gui(varargin)
+% ASTRA_DATA_GUI M-file for ASTRA_DATA_GUI.fig
+%      ASTRA_DATA_GUI, by itself, creates a new ASTRA_DATA_GUI or raises the existing
+%      singleton*.
+%
+%      H = ASTRA_DATA_GUI returns the handle to a new ASTRA_DATA_GUI or the handle to
+%      the existing singleton*.
+%
+%      ASTRA_DATA_GUI('CALLBACK',hObject,eventData,handles,...) calls the local
+%      function named CALLBACK in ASTRA_DATA_GUI.M with the given input arguments.
+%
+%      ASTRA_DATA_GUI('Property','Value',...) creates a new ASTRA_DATA_GUI or raises the
+%      existing singleton*.  Starting from the left, property value pairs are
+%      applied to the GUI before ASTRA_DATA_GUI_OpeningFcn gets called.  An
+%      unrecognized property name or invalid value makes property application
+%      stop.  All inputs are passed to ASTRA_DATA_GUI_OpeningFcn via varargin.
+%
+%      *See GUI Options on GUIDE's Tools menu.  Choose "GUI allows only one
+%      instance to run (singleton)".
+%
+% See also: GUIDE, GUIDATA, GUIHANDLES
+
+% Edit the above text to modify the response to help ASTRA_DATA_GUI
+
+% Last Modified by GUIDE v2.5 05-Mar-2012 14:34:03
+
+% Begin initialization code - DO NOT EDIT
+gui_Singleton = 1;
+gui_State = struct('gui_Name',       mfilename, ...
+                   'gui_Singleton',  gui_Singleton, ...
+                   'gui_OpeningFcn', @astra_data_gui_OpeningFcn, ...
+                   'gui_OutputFcn',  @astra_data_gui_OutputFcn, ...
+                   'gui_LayoutFcn',  [] , ...
+                   'gui_Callback',   []);
+if nargin && ischar(varargin{1})
+    gui_State.gui_Callback = str2func(varargin{1});
+end
+
+if nargout
+    [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
+else
+    gui_mainfcn(gui_State, varargin{:});
+end
+% End initialization code - DO NOT EDIT
+
+
+% --- Executes just before astra_data_gui is made visible.
+function astra_data_gui_OpeningFcn(hObject, eventdata, handles, varargin)
+% This function has no output args, see OutputFcn.
+% hObject    handle to figure
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+% varargin   command line arguments to astra_data_gui (see VARARGIN)
+
+% Choose default command line output for astra_data_gui
+handles.output = hObject;
+handles.data = [];
+
+% Update handles structure
+guidata(hObject, handles);
+
+% UIWAIT makes astra_data_gui wait for user response (see UIRESUME)
+% uiwait(handles.figure1);
+
+
+% --- Outputs from this function are returned to the command line.
+function varargout = astra_data_gui_OutputFcn(hObject, eventdata, handles) 
+% varargout  cell array for returning output args (see VARARGOUT);
+% hObject    handle to figure
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+
+% Get default command line output from handles structure
+varargout{1} = handles.output;
+
+
+% Use this function to display a figure using the gui from any m-file
+% example:
+%       Handle = astra_data_gui();
+%       astra_data_gui('loadVolume',guihandles(Handle),'rand(30,30,30)',15);
+function loadVolume(handles,name,figure_number)
+set(handles.txt_var, 'String', name);
+set(handles.figure_number, 'String', num2str(figure_number));
+btn_load_Callback(handles.txt_var, [], handles);
+
+
+
+
+
+function txt_var_Callback(hObject, eventdata, handles) %#ok<*DEFNU>
+% hObject    handle to txt_var (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+
+% Hints: get(hObject,'String') returns contents of txt_var as text
+%        str2double(get(hObject,'String')) returns contents of txt_var as a double
+
+
+% --- Executes during object creation, after setting all properties.
+function txt_var_CreateFcn(hObject, eventdata, handles)
+% hObject    handle to txt_var (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    empty - handles not created until after all CreateFcns called
+
+% Hint: edit controls usually have a white background on Windows.
+%       See ISPC and COMPUTER.
+if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
+    set(hObject,'BackgroundColor','white');
+end
+
+
+% --- Executes on button press in btn_load.
+function btn_load_Callback(hObject, eventdata, handles)
+% hObject    handle to btn_load (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+
+s = get(handles.txt_var, 'String');
+data = evalin('base', s);
+handles.data = data;
+guidata(hObject, handles);
+
+% Set Default Stuff
+set(handles.sld_slice, 'Min',1);
+set(handles.sld_slice, 'Max', size(data,3));
+set(handles.sld_slice, 'SliderStep', [1/(size(data,3)-2) 1/(size(data,3)-2)]);
+set(handles.sld_slice, 'Value', size(data,3)/2);
+
+sliderValue = floor(get(handles.sld_slice, 'Value'));
+set(handles.txt_slice, 'String', num2str(sliderValue));
+set(handles.txt_min, 'String', num2str(1));
+set(handles.txt_max, 'String', num2str(size(data,3)));
+
+set(handles.sld_magnification, 'Min',1);
+set(handles.sld_magnification, 'Max', 400);
+set(handles.sld_magnification, 'SliderStep', [1/(400-2) 1/(400-2)]);
+set(handles.sld_magnification, 'Value', 100);
+
+sliderValue3 = floor(get(handles.sld_magnification, 'Value'));
+set(handles.txt_mag, 'String', num2str(sliderValue3));
+
+
+figure_number = floor(str2double(get(handles.figure_number, 'String')));
+if(isnan(figure_number) || figure_number < 1)
+    set(handles.figure_number, 'String', num2str(10));
+end
+
+showimage(handles);
+
+% --- SHOW IMAGE
+function showimage(handles)
+	sliderValue = floor(get(handles.sld_slice, 'Value'));
+    magnification = floor(get(handles.sld_magnification, 'Value'));
+    figure_number = floor(str2double(get(handles.figure_number, 'String')));
+    image_matrix = handles.data;
+	if get(handles.btn_x, 'Value') == 1
+		figure(figure_number), imshow(sliceExtractor((image_matrix(:,:,:)), 'y', sliderValue),[],'InitialMagnification', magnification);
+        ylabel('y')
+        xlabel('z')
+        set(gcf,'Name','ASTRA DATA GUI')
+	elseif get(handles.btn_y, 'Value') == 1
+		figure(figure_number), imshow(sliceExtractor((image_matrix(:,:,:)), 'x', sliderValue),[],'InitialMagnification', magnification);
+        ylabel('x')
+        xlabel('z')
+        set(gcf,'Name','ASTRA DATA GUI')
+	else
+		figure(figure_number), imshow(sliceExtractor((image_matrix(:,:,:)), 'z', sliderValue),[],'InitialMagnification', magnification);
+        ylabel('x')
+        xlabel('y')
+        set(gcf,'Name','ASTRA DATA GUI')
+    end
+
+
+% --- Executes on slider movement.
+function sld_slice_Callback(hObject, eventdata, handles)
+% hObject    handle to sld_slice (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+	
+sliderValue = floor(get(handles.sld_slice, 'Value'));
+set(handles.txt_slice, 'String', num2str(sliderValue));
+showimage(handles);
+
+% --- Executes during object creation, after setting all properties.
+function sld_slice_CreateFcn(hObject, eventdata, handles)
+% hObject    handle to sld_slice (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    empty - handles not created until after all CreateFcns called
+
+% Hint: slider controls usually have a light gray background.
+if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
+    set(hObject,'BackgroundColor',[.9 .9 .9]);
+end
+
+
+% --- Executes on button press in pushbutton2.
+function pushbutton2_Callback(hObject, eventdata, handles)
+% hObject    handle to pushbutton2 (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+
+
+% --- Executes on button press in pushbutton3.
+function pushbutton3_Callback(hObject, eventdata, handles)
+% hObject    handle to pushbutton3 (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+
+
+% --- Executes on button press in pushbutton4.
+function pushbutton4_Callback(hObject, eventdata, handles)
+% hObject    handle to pushbutton4 (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+
+
+function txt_slice_Callback(hObject, eventdata, handles)
+% hObject    handle to txt_slice (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+slice = str2double(get(handles.txt_slice, 'String'));
+max = str2num(get(handles.txt_max,'String'));
+min = str2num(get(handles.txt_min,'String'));
+if(slice > max)
+    set(handles.txt_slice, 'String', num2str(max));
+    set(handles.sld_slice, 'Value', max);
+elseif(slice < min)
+    set(handles.txt_slice, 'String', num2str(min));
+    set(handles.sld_slice, 'Value', min);
+else
+    set(handles.sld_slice, 'Value', slice);
+end
+showimage(handles);
+	
+% --- Executes during object creation, after setting all properties.
+function txt_slice_CreateFcn(hObject, eventdata, handles)
+% hObject    handle to txt_slice (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    empty - handles not created until after all CreateFcns called
+
+% Hint: edit controls usually have a white background on Windows.
+%       See ISPC and COMPUTER.
+if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
+    set(hObject,'BackgroundColor','white');
+end
+
+% --- Executes on slider movement.
+function sld_magnification_Callback(hObject, eventdata, handles)
+% hObject    handle to sld_slice2 (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+
+% Hints: get(hObject,'Value') returns position of slider
+%        get(hObject,'Min') and get(hObject,'Max') to determine range of slider
+sliderValue3 = floor(get(handles.sld_magnification, 'Value'));
+set(handles.txt_mag, 'String', num2str(sliderValue3));
+
+if(~isempty(handles.data))
+    showimage(handles);
+end
+
+
+
+% --- Executes during object creation, after setting all properties.
+function sld_magnification_CreateFcn(hObject, eventdata, handles)
+% hObject    handle to sld_slice2 (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    empty - handles not created until after all CreateFcns called
+% Hint: slider controls usually have a light gray background.
+if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
+    set(hObject,'BackgroundColor',[.9 .9 .9]);
+end
+
+
+function txt_mag_Callback(hObject, eventdata, handles)
+% hObject    handle to txt_slice2 (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+magnification = str2double(get(handles.txt_mag, 'String'));
+if(magnification > 400)
+    set(handles.txt_mag, 'String', num2str(400));
+    set(handles.sld_magnification, 'Value', 400);
+elseif(magnification < 1)
+    set(handles.txt_mag, 'String', num2str(1));
+    set(handles.sld_magnification, 'Value', 1);
+else
+    set(handles.sld_magnification, 'Value', magnification);
+end
+
+if(~isempty(handles.data))
+    showimage(handles);
+end
+
+% --- Executes during object creation, after setting all properties.
+function txt_mag_CreateFcn(hObject, eventdata, handles)
+% hObject    handle to txt_slice2 (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    empty - handles not created until after all CreateFcns called
+
+% Hint: edit controls usually have a white background on Windows.
+%       See ISPC and COMPUTER.
+if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
+    set(hObject,'BackgroundColor','white');
+end
+
+% --- Executes on slider movement.
+function figure_number_Callback(hObject, eventdata, handles)
+% hObject    handle to sld_slice2 (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    structure with handles and user data (see GUIDATA)
+
+% Hints: get(hObject,'Value') returns position of slider
+%        get(hObject,'Min') and get(hObject,'Max') to determine range of slider
+number = floor(str2double(get(handles.figure_number, 'String')));
+if(number < 1)
+    set(handles.figure_number, 'String', num2str(1));
+else
+    set(handles.figure_number, 'String', num2str(number));
+end
+
+if(~isempty(handles.data))
+    showimage(handles);
+end
+
+
+% --- Executes during object creation, after setting all properties.
+function figure_number_CreateFcn(hObject, eventdata, handles)
+% hObject    handle to sld_slice2 (see GCBO)
+% eventdata  reserved - to be defined in a future version of MATLAB
+% handles    empty - handles not created until after all CreateFcns called
+% Hint: slider controls usually have a light gray background.
+if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
+    set(hObject,'BackgroundColor',[.9 .9 .9]);
+end
+
+
+
+% --- Executes when selected object is changed in btn_dir.
+function btn_dir_SelectionChangeFcn(hObject, eventdata, handles)
+% hObject    handle to the selected object in btn_dir 
+% eventdata  structure with the following fields (see UIBUTTONGROUP)
+%	EventName: string 'SelectionChanged' (read only)
+%	OldValue: handle of the previously selected object or empty if none was selected
+%	NewValue: handle of the currently selected object
+% handles    structure with handles and user data (see GUIDATA)
+
+data = handles.data;
+
+if(hObject == handles.btn_x)
+    set(handles.btn_x, 'Value', 1);
+    set(handles.btn_y, 'Value', 0);
+    set(handles.btn_z, 'Value', 0);
+elseif(hObject == handles.btn_y)
+    set(handles.btn_x, 'Value', 0);
+    set(handles.btn_y, 'Value', 1);
+    set(handles.btn_z, 'Value', 0);
+elseif(hObject == handles.btn_z)
+    set(handles.btn_x, 'Value', 0);
+    set(handles.btn_y, 'Value', 0);
+    set(handles.btn_z, 'Value', 1);
+end
+
+if get(handles.btn_x, 'Value') == 1
+	set(handles.sld_slice, 'Min',1);
+	set(handles.sld_slice, 'Max', size(data,1));
+	set(handles.sld_slice, 'SliderStep', [1/(size(data,1)-2) 1/(size(data,1)-2)]);
+	set(handles.sld_slice, 'Value', size(data,1)/2);
+
+	sliderValue = get(handles.sld_slice, 'Value');
+	set(handles.txt_slice, 'String', num2str(sliderValue));
+	set(handles.txt_min, 'String', num2str(1));
+	set(handles.txt_max, 'String', num2str(size(data,1)));
+	
+elseif get(handles.btn_y, 'Value') == 1
+	set(handles.sld_slice, 'Min',1);
+	set(handles.sld_slice, 'Max', size(data,2));
+	set(handles.sld_slice, 'SliderStep', [1/(size(data,2)-2) 1/(size(data,2)-2)]);
+	set(handles.sld_slice, 'Value', size(data,2)/2);
+
+	sliderValue = get(handles.sld_slice, 'Value');
+	set(handles.txt_slice, 'String', num2str(sliderValue));
+	set(handles.txt_min, 'String', num2str(1));
+	set(handles.txt_max, 'String', num2str(size(data,2)));
+else
+	set(handles.sld_slice, 'Min',1);
+	set(handles.sld_slice, 'Max', size(data,3));
+	set(handles.sld_slice, 'SliderStep', [1/(size(data,3)-2) 1/(size(data,3)-2)]);
+	set(handles.sld_slice, 'Value', size(data,3)/2);
+
+	sliderValue = get(handles.sld_slice, 'Value');
+	set(handles.txt_slice, 'String', num2str(sliderValue));
+	set(handles.txt_min, 'String', num2str(1));
+	set(handles.txt_max, 'String', num2str(size(data,3)));
+end
+
+showimage(handles);
diff --git a/matlab/tools/astra_data_op.m b/matlab/tools/astra_data_op.m
new file mode 100644
index 0000000..b6ef0e2
--- /dev/null
+++ b/matlab/tools/astra_data_op.m
@@ -0,0 +1,11 @@
+function astra_data_op(op, data, scalar, gpu_core)
+
+cfg = astra_struct('DataOperation_CUDA');
+cfg.Operation = op;
+cfg.Scalar = scalar;
+cfg.DataId = data;
+cfg.option.GPUindex = gpu_core;
+
+alg_id = astra_mex_algorithm('create',cfg);
+astra_mex_algorithm('run',alg_id);
+astra_mex_algorithm('delete',alg_id);
\ No newline at end of file
diff --git a/matlab/tools/astra_data_op_mask.m b/matlab/tools/astra_data_op_mask.m
new file mode 100644
index 0000000..d46c925
--- /dev/null
+++ b/matlab/tools/astra_data_op_mask.m
@@ -0,0 +1,12 @@
+function astra_data_op_mask(op, data, scalar, mask, gpu_core)
+
+cfg = astra_struct('DataOperation_CUDA');
+cfg.Operation = op;
+cfg.Scalar = scalar;
+cfg.DataId = data;
+cfg.option.GPUindex = gpu_core;
+cfg.option.MaskId = mask;
+
+alg_id = astra_mex_algorithm('create',cfg);
+astra_mex_algorithm('run',alg_id);
+astra_mex_algorithm('delete',alg_id);
\ No newline at end of file
diff --git a/matlab/tools/astra_downsample_sinogram.m b/matlab/tools/astra_downsample_sinogram.m
new file mode 100644
index 0000000..30c1cdd
--- /dev/null
+++ b/matlab/tools/astra_downsample_sinogram.m
@@ -0,0 +1,36 @@
+function [sinogram_new, proj_geom_new] = astra_downsample_sinogram(sinogram, proj_geom, factor)
+
+%------------------------------------------------------------------------
+% [sinogram_new, proj_geom_new] = astra_downsample_sinogram(sinogram, proj_geom, factor)
+% 
+% Downsample the sinogram with some factor and adjust projection geometry
+% accordingly
+% 
+% sinogram: MATLAB data version of the sinogram.
+% proj_geom: MATLAB struct containing the projection geometry.
+% factor: the factor by which the number of detectors is divided.
+% sinogram_new: MATLAB data version of the resampled sinogram.
+% proj_geom_new: MATLAB struct containing the new projection geometry.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+if mod(size(sinogram,2),factor) ~= 0
+	disp('size of the sinogram must be a divisor of the factor');
+end
+
+sinogram_new = zeros(size(sinogram,1),size(sinogram,2)/factor);
+for i = 1:size(sinogram,2)/factor
+	sinogram_new(:,i) = sum(sinogram(:,(factor*(i-1)+1):factor*i),2);
+end
+
+proj_geom_new = proj_geom;
+proj_geom_new.DetectorCount = proj_geom_new.DetectorCount / factor;
diff --git a/matlab/tools/astra_geom_2vec.m b/matlab/tools/astra_geom_2vec.m
new file mode 100644
index 0000000..0abd07c
--- /dev/null
+++ b/matlab/tools/astra_geom_2vec.m
@@ -0,0 +1,84 @@
+function proj_geom_out = astra_geom_2vec(proj_geom)
+
+	% FANFLAT
+	if strcmp(proj_geom.type,'fanflat')
+
+		vectors = zeros(numel(proj_geom.ProjectionAngles), 6);
+		for i = 1:numel(proj_geom.ProjectionAngles)
+
+			% source
+			vectors(i,1) = sin(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginSource;
+			vectors(i,2) = -cos(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginSource;	
+
+			% center of detector
+			vectors(i,3) = -sin(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginDetector;
+			vectors(i,4) = cos(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginDetector;	
+
+			% vector from detector pixel 0 to 1
+			vectors(i,5) = cos(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorWidth;
+			vectors(i,6) = sin(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorWidth;
+		end
+
+		proj_geom_out = astra_create_proj_geom('fanflat_vec', proj_geom.DetectorCount, vectors);
+
+	% CONE
+	elseif strcmp(proj_geom.type,'cone')
+
+		vectors = zeros(numel(proj_geom.ProjectionAngles), 12);
+		for i = 1:numel(proj_geom.ProjectionAngles)
+
+			% source
+			vectors(i,1) = sin(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginSource;
+			vectors(i,2) = -cos(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginSource;	
+			vectors(i,3) = 0;	
+
+			% center of detector
+			vectors(i,4) = -sin(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginDetector;
+			vectors(i,5) = cos(proj_geom.ProjectionAngles(i)) * proj_geom.DistanceOriginDetector;	
+			vectors(i,6) = 0;	
+
+			% vector from detector pixel (0,0) to (0,1)
+			vectors(i,7) = cos(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorSpacingX;
+			vectors(i,8) = sin(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorSpacingX;
+			vectors(i,9) = 0;
+
+			% vector from detector pixel (0,0) to (1,0)
+			vectors(i,10) = 0;
+			vectors(i,11) = 0;
+			vectors(i,12) = proj_geom.DetectorSpacingY;		
+		end
+
+		proj_geom_out = astra_create_proj_geom('cone_vec', proj_geom.DetectorRowCount, proj_geom.DetectorColCount, vectors);	
+
+	% PARALLEL
+	elseif strcmp(proj_geom.type,'parallel3d')	
+
+		vectors = zeros(numel(proj_geom.ProjectionAngles), 12);
+		for i = 1:numel(proj_geom.ProjectionAngles)
+
+			% ray direction
+			vectors(i,1) = sin(proj_geom.ProjectionAngles(i));
+			vectors(i,2) = -cos(proj_geom.ProjectionAngles(i));
+			vectors(i,3) = 0;	
+
+			% center of detector
+			vectors(i,4) = 0;
+			vectors(i,5) = 0;
+			vectors(i,6) = 0;	
+
+			% vector from detector pixel (0,0) to (0,1)
+			vectors(i,7) = cos(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorSpacingX;
+			vectors(i,8) = sin(proj_geom.ProjectionAngles(i)) * proj_geom.DetectorSpacingX;
+			vectors(i,9) = 0;
+
+			% vector from detector pixel (0,0) to (1,0)
+			vectors(i,10) = 0;
+			vectors(i,11) = 0;
+			vectors(i,12) = proj_geom.DetectorSpacingY;		
+		end
+
+		proj_geom_out = astra_create_proj_geom('parallel3d_vec', proj_geom.DetectorRowCount, proj_geom.DetectorColCount, vectors);		
+
+	else
+		error(['No suitable vector geometry found for type: ' proj_geom.type])
+	end
diff --git a/matlab/tools/astra_geom_postalignment.m b/matlab/tools/astra_geom_postalignment.m
new file mode 100644
index 0000000..4115af2
--- /dev/null
+++ b/matlab/tools/astra_geom_postalignment.m
@@ -0,0 +1,11 @@
+function proj_geom = astra_geom_postalignment(proj_geom, factor)
+
+	if strcmp(proj_geom.type,'fanflat_vec')
+		proj_geom.Vectors(:,3:4) = proj_geom.Vectors(:,3:4) + factor * proj_geom.Vectors(:,5:6);
+		
+	elseif strcmp(proj_geom.type,'cone_vec') || strcmp(proj_geom.type,'parallel3d_vec')
+		proj_geom.Vectors(:,4:6) = proj_geom.Vectors(:,4:6) + factor * proj_geom.Vectors(:,7:9);
+
+	else
+		error('Projection geometry not suited for postalignment correction.')
+	end
diff --git a/matlab/tools/astra_geom_size.m b/matlab/tools/astra_geom_size.m
new file mode 100644
index 0000000..c4956f5
--- /dev/null
+++ b/matlab/tools/astra_geom_size.m
@@ -0,0 +1,28 @@
+function s = astra_geom_size(geom, dim)
+
+	if isfield(geom, 'GridSliceCount')
+		% 3D Volume geometry?
+		s = [ geom.GridColCount, geom.GridRowCount, geom.GridSliceCount ];
+	elseif isfield(geom, 'GridColCount')
+		% 2D Volume geometry?
+		s = [ geom.GridRowCount, geom.GridColCount ];
+	elseif strcmp(geom.type,'parallel') || strcmp(geom.type,'fanflat') 
+		s = [numel(geom.ProjectionAngles), geom.DetectorCount];
+		
+	elseif strcmp(geom.type,'parallel3d') || strcmp(geom.type,'cone') 
+		s =  [geom.DetectorRowCount, numel(geom.ProjectionAngles), geom.DetectorColCount];
+		
+	elseif strcmp(geom.type,'fanflat_vec')
+		s = [size(geom.Vectors,1), geom.DetectorCount];
+		
+	elseif strcmp(geom.type,'parallel3d_vec') || strcmp(geom.type,'cone_vec') 		
+		s = [geom.DetectorColCount, size(geom.Vectors,1), geom.DetectorRowCount];
+		
+	end
+
+	if nargin == 2
+		s = s(dim);
+	end
+	
+end
+
diff --git a/matlab/tools/astra_geom_superresolution.m b/matlab/tools/astra_geom_superresolution.m
new file mode 100644
index 0000000..b2b0ebf
--- /dev/null
+++ b/matlab/tools/astra_geom_superresolution.m
@@ -0,0 +1,14 @@
+function proj_geom = astra_geom_superresolution(proj_geom, factor)
+
+	if  strcmp(proj_geom.type,'parallel')
+			proj_geom.DetectorWidth = proj_geom.DetectorWidth/factor;
+			proj_geom.DetectorCount = proj_geom.DetectorCount * factor;
+	elseif strcmp(proj_geom.type,'fanflat') 
+			proj_geom.DetectorWidth = proj_geom.DetectorWidth/factor;
+			proj_geom.DetectorCount = proj_geom.DetectorCount * factor;
+	elseif strcmp(proj_geom.type,'fanflat_vec')
+			proj_geom.Vectors(:,5:6) = proj_geom.Vectors(:,5:6) / factor; % DetectorSize			
+			proj_geom.DetectorCount = proj_geom.DetectorCount * factor;
+	else
+		error('Projection geometry not suited for super-resolution (or not implemented).')
+	end
diff --git a/matlab/tools/astra_imshow.m b/matlab/tools/astra_imshow.m
new file mode 100644
index 0000000..6069674
--- /dev/null
+++ b/matlab/tools/astra_imshow.m
@@ -0,0 +1,10 @@
+function V = astra_imshow(data, range)
+
+if numel(data) == 1
+	data = astra_mex_data2d('get', data);
+end
+imshow(data,range);
+
+if nargout >= 1
+	V = data;
+end
\ No newline at end of file
diff --git a/matlab/tools/astra_mex.m b/matlab/tools/astra_mex.m
new file mode 100644
index 0000000..e04cfea
--- /dev/null
+++ b/matlab/tools/astra_mex.m
@@ -0,0 +1,24 @@
+function [varargout] = astra_mex(varargin)
+%------------------------------------------------------------------------
+% Reference page in Help browser
+%    <a href="matlab:docsearch('astra_mex' )">astra_mex</a>.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+if nargout == 0
+    astra_mex_c(varargin{:});
+    if exist('ans','var')
+        varargout{1} = ans;
+    end
+else
+    varargout = cell(1,nargout);
+    [varargout{:}] = astra_mex_c(varargin{:});
+end
diff --git a/matlab/tools/astra_mex_algorithm.m b/matlab/tools/astra_mex_algorithm.m
new file mode 100644
index 0000000..138a43c
--- /dev/null
+++ b/matlab/tools/astra_mex_algorithm.m
@@ -0,0 +1,24 @@
+function [varargout] = astra_mex_algorithm(varargin)
+%------------------------------------------------------------------------
+% Reference page in Help browser
+%    <a href="matlab:docsearch('astra_mex_algorithm' )">astra_mex_algorithm</a>.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+if nargout == 0
+    astra_mex_algorithm_c(varargin{:});
+    if exist('ans','var')
+        varargout{1} = ans;
+    end
+else
+    varargout = cell(1,nargout);
+    [varargout{:}] = astra_mex_algorithm_c(varargin{:});
+end
diff --git a/matlab/tools/astra_mex_data2d.m b/matlab/tools/astra_mex_data2d.m
new file mode 100644
index 0000000..eacbcb9
--- /dev/null
+++ b/matlab/tools/astra_mex_data2d.m
@@ -0,0 +1,24 @@
+function [varargout] = astra_mex_data2d(varargin)
+%------------------------------------------------------------------------
+% Reference page in Help browser
+%    <a href="matlab:docsearch('astra_mex_data2d' )">astra_mex_data2d</a>.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+if nargout == 0
+    astra_mex_data2d_c(varargin{:});
+    if exist('ans','var')
+        varargout{1} = ans;
+    end
+else
+    varargout = cell(1,nargout);
+    [varargout{:}] = astra_mex_data2d_c(varargin{:});
+end
diff --git a/matlab/tools/astra_mex_data3d.m b/matlab/tools/astra_mex_data3d.m
new file mode 100644
index 0000000..3bbbd68
--- /dev/null
+++ b/matlab/tools/astra_mex_data3d.m
@@ -0,0 +1,24 @@
+function [varargout] = astra_mex_data3d(varargin)
+%------------------------------------------------------------------------
+% Reference page in Help browser
+%    <a href="matlab:docsearch('astra_mex_data3d' )">astra_mex_data3d</a>.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+if nargout == 0
+    astra_mex_data3d_c(varargin{:});
+    if exist('ans','var')
+        varargout{1} = ans;
+    end
+else
+    varargout = cell(1,nargout);
+    [varargout{:}] = astra_mex_data3d_c(varargin{:});
+end
diff --git a/matlab/tools/astra_mex_matrix.m b/matlab/tools/astra_mex_matrix.m
new file mode 100644
index 0000000..182ab1e
--- /dev/null
+++ b/matlab/tools/astra_mex_matrix.m
@@ -0,0 +1,24 @@
+function [varargout] = astra_mex_matrix(varargin)
+%------------------------------------------------------------------------
+% Reference page in Help browser
+%    <a href="matlab:docsearch('astra_mex_matrix' )">astra_mex_matrix</a>.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+if nargout == 0
+    astra_mex_matrix_c(varargin{:});
+    if exist('ans','var')
+        varargout{1} = ans;
+    end
+else
+    varargout = cell(1,nargout);
+    [varargout{:}] = astra_mex_matrix_c(varargin{:});
+end
diff --git a/matlab/tools/astra_mex_projector.m b/matlab/tools/astra_mex_projector.m
new file mode 100644
index 0000000..487da06
--- /dev/null
+++ b/matlab/tools/astra_mex_projector.m
@@ -0,0 +1,24 @@
+function [varargout] = astra_mex_projector(varargin)
+%------------------------------------------------------------------------
+% Reference page in Help browser
+%    <a href="matlab:docsearch('astra_mex_projector' )">astra_mex_projector</a>.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+if nargout == 0
+    astra_mex_projector_c(varargin{:});
+    if exist('ans','var')
+        varargout{1} = ans;
+    end
+else
+    varargout = cell(1,nargout);
+    [varargout{:}] = astra_mex_projector_c(varargin{:});
+end
diff --git a/matlab/tools/astra_mex_projector3d.m b/matlab/tools/astra_mex_projector3d.m
new file mode 100644
index 0000000..3d21ce9
--- /dev/null
+++ b/matlab/tools/astra_mex_projector3d.m
@@ -0,0 +1,24 @@
+function [varargout] = astra_mex_projector3d(varargin)
+%------------------------------------------------------------------------
+% Reference page in Help browser
+%    <a href="matlab:docsearch('astra_mex_projector3d' )">astra_mex_projector3d</a>.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+if nargout == 0
+    astra_mex_projector3d_c(varargin{:});
+    if exist('ans','var')
+        varargout{1} = ans;
+    end
+else
+    varargout = cell(1,nargout);
+    [varargout{:}] = astra_mex_projector3d_c(varargin{:});
+end
diff --git a/matlab/tools/astra_projector_handle.m b/matlab/tools/astra_projector_handle.m
new file mode 100644
index 0000000..72d4c73
--- /dev/null
+++ b/matlab/tools/astra_projector_handle.m
@@ -0,0 +1,29 @@
+classdef astra_projector_handle < handle
+    %ASTRA_PROJECTOR_HANDLE Handle class around an astra_mex_projector id
+    %   Automatically deletes the projector when deleted.
+
+    %------------------------------------------------------------------------
+    % This file is part of the
+    % All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+    %
+    % Copyright: iMinds-Vision Lab, University of Antwerp
+    % License: Open Source under GPLv3
+    % Contact: mailto:astra@ua.ac.be
+    % Website: http://astra.ua.ac.be
+    %------------------------------------------------------------------------
+
+    properties
+        id
+    end
+
+    methods
+        function obj = astra_projector_handle(proj_id)
+            obj.id = proj_id;
+        end
+        function delete(obj)
+            astra_mex_projector('delete', obj.id);
+        end
+    end
+
+end
+
diff --git a/matlab/tools/astra_set_directory.m b/matlab/tools/astra_set_directory.m
new file mode 100644
index 0000000..1d5a368
--- /dev/null
+++ b/matlab/tools/astra_set_directory.m
@@ -0,0 +1,27 @@
+function in = astra_set_directory(in)
+
+%------------------------------------------------------------------------
+% in = astra_set_directory(in)
+% 
+% Creates the directories present in the input path if they do not exist
+% already
+% 
+% in: input path.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+a = find(in == '/' | in == '\');
+for i = 1:numel(a)
+	if ~isdir(in(1:a(i)))
+		mkdir(in(1:a(i)));
+	end
+end
diff --git a/matlab/tools/astra_struct.m b/matlab/tools/astra_struct.m
new file mode 100644
index 0000000..f65b2ec
--- /dev/null
+++ b/matlab/tools/astra_struct.m
@@ -0,0 +1,37 @@
+function res = astra_struct(type)
+
+%------------------------------------------------------------------------
+% res = astra_struct(type)
+%
+% Create an ASTRA struct
+%
+% type: type of the struct to be generated.
+% res: the generated matlab struct.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+res = struct();
+res.options = struct();
+
+
+if nargin >= 1
+	% For backward compatibility, transparently accept SIRT_CUDA2
+	% for SIRT_CUDA, and FP_CUDA2 for FP_CUDA.
+	if strcmp(type, 'SIRT_CUDA2')
+		type = 'SIRT_CUDA';
+		warning('SIRT_CUDA2 has been deprecated. Use SIRT_CUDA instead.');
+	end
+	if strcmp(type, 'FP_CUDA2')
+		type = 'FP_CUDA';
+		warning('FP_CUDA2 has been deprecated. Use FP_CUDA instead.');
+	end
+	res.type = type;
+end
diff --git a/matlab/tools/compute_rnmp.m b/matlab/tools/compute_rnmp.m
new file mode 100644
index 0000000..6c00a01
--- /dev/null
+++ b/matlab/tools/compute_rnmp.m
@@ -0,0 +1,29 @@
+function [rnmp, nmp] = compute_rnmp(phantom, S)
+
+	phantom = double(phantom == max(phantom(:))); 
+	S = double(S == max(S(:)));
+
+	%u1 = sort(unique(phantom));
+	%u2 = sort(unique(S));
+	%for i = 1:numel(u1)
+	%	phantom_(phantom == u1(i)) = i;
+	%	S_(S == u2(i)) = i;
+	%end
+	%phantom = phantom_;
+	%S = S_;
+	
+	if numel(size(phantom)) == 2
+		S = imresize(S, size(phantom), 'nearest');
+	elseif numel(size(phantom)) == 3
+		S2 = zeros(size(phantom));
+		for slice = 1:size(phantom,3)
+			S2(:,:,slice) = imresize(S(:,:,slice), [size(phantom,1) size(phantom,2)], 'nearest');
+		end
+		S = S2;
+	end
+
+	nmp = sum(abs(phantom(:) ~= S(:)));
+	rnmp = nmp / sum(phantom(:));
+
+end
+
diff --git a/matlab/tools/createOrderART.m b/matlab/tools/createOrderART.m
new file mode 100644
index 0000000..a469d8a
--- /dev/null
+++ b/matlab/tools/createOrderART.m
@@ -0,0 +1,66 @@
+function rayOrder = createOrderART(proj_geom, mode)
+
+%------------------------------------------------------------------------
+% rayOrder = createOrderART(proj_geom, mode)
+% 
+% Creates an array defining the order in which ART will iterate over the
+% projections and projection rays 
+%
+% proj_geom: MATLAB struct containing the projection geometry.
+% mode: string defining the wanted ray order, can be either 'sequential',
+% 'randomray' or 'randomproj'.
+% rayOrder: array of two columns of length angle_count * det_count, with
+% the first column being the index of the projection and the second column 
+% the index of the ray.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+angle_count = length(proj_geom.projection_angles);
+det_count = proj_geom.detector_count;
+
+% create order
+rayOrder = zeros(angle_count * det_count, 2);
+if strcmp(mode,'sequential') == 1
+	index = 1;
+	for i = 1:angle_count
+		for j = 1:det_count
+			rayOrder(index,1) = i;
+			rayOrder(index,2) = j;			
+			index = index + 1;
+		end
+	end
+elseif strcmp(mode,'randomray') == 1
+	index = 1;
+	for i = 1:angle_count
+		for j = 1:det_count
+			rayOrder(index,1) = i;
+			rayOrder(index,2) = j;			
+			index = index + 1;
+		end
+	end
+	r = randperm(angle_count * det_count);
+	rayOrder(:,1) = rayOrder(r,1);
+	rayOrder(:,2) = rayOrder(r,2);	
+elseif strcmp(mode,'randomproj') == 1
+	index = 1;
+	r = randperm(angle_count);
+	for i = 1:angle_count
+		for j = 1:det_count
+			rayOrder(index,1) = r(i);
+			rayOrder(index,2) = j;			
+			index = index + 1;
+		end
+	end
+else
+	disp('mode not known');
+end
+
diff --git a/matlab/tools/downsample_sinogram.m b/matlab/tools/downsample_sinogram.m
new file mode 100644
index 0000000..1fb4ec8
--- /dev/null
+++ b/matlab/tools/downsample_sinogram.m
@@ -0,0 +1,12 @@
+function sinogram_out = downsample_sinogram(sinogram, ds)
+
+	if ds == 1
+		sinogram_out = sinogram;
+		return;
+	end
+
+	sinogram_out = sinogram(:,1:ds:end,:);
+	for i = 2:ds
+		sinogram_out = sinogram_out + sinogram(:,i:ds:end,:);
+	end
+	sinogram_out = sinogram_out / (ds*ds);
\ No newline at end of file
diff --git a/matlab/tools/imreadgs.m b/matlab/tools/imreadgs.m
new file mode 100644
index 0000000..9c27eb4
--- /dev/null
+++ b/matlab/tools/imreadgs.m
@@ -0,0 +1,26 @@
+function Im = imreadgs(filename)
+
+%------------------------------------------------------------------------
+% Im = imreadgs(filename)
+% 
+% Reads an image and transforms it into a grayscale image consisting of
+% doubles.
+%
+% filename: name of the image file.
+% Im: a grayscale image in double.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+Im = double(imread(filename));
+if size(Im,3) > 1
+	Im = Im(:,:,1);
+end	
diff --git a/matlab/tools/imresize3D.m b/matlab/tools/imresize3D.m
new file mode 100644
index 0000000..9032cc3
--- /dev/null
+++ b/matlab/tools/imresize3D.m
@@ -0,0 +1,26 @@
+function out = imresize3D(in, s_out, method)
+
+%------------------------------------------------------------------------
+% out = imresize3D(in, s_out, method)
+% 
+% Resizes a 3-component image
+%
+% in: input image.
+% s_out: 2 element array with the wanted image size, [rows columns].
+% out: the resized 3-component image.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+out = zeros(s_out);
+for i = 1:size(in,3)
+	out(:,:,i) = imresize(in(:,:,i), s_out(1:2), method);
+end
diff --git a/matlab/tools/imscale.m b/matlab/tools/imscale.m
new file mode 100644
index 0000000..957f11f
--- /dev/null
+++ b/matlab/tools/imscale.m
@@ -0,0 +1,28 @@
+function out = imscale(in)
+
+%------------------------------------------------------------------------
+% out = imscale(in)
+% 
+% Rescales the image values between zero and one.
+%
+% in: input image.
+% out: scaled output image.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+mi = min(in(:));
+ma = max(in(:));
+if (ma-mi) == 0
+	out = zeros(size(in));
+else
+	out = (in - mi) / (ma - mi);
+end
diff --git a/matlab/tools/imwritesc.m b/matlab/tools/imwritesc.m
new file mode 100644
index 0000000..2f81dc8
--- /dev/null
+++ b/matlab/tools/imwritesc.m
@@ -0,0 +1,22 @@
+function imwritesc(in, filename)
+
+%------------------------------------------------------------------------
+% imwritesc(in, filename)
+%
+% Rescale between zero and one and write image
+%
+% in: input image.
+% filename: name of output image file.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+imwrite(imscale(in),filename);
diff --git a/matlab/tools/kaiserBessel.m b/matlab/tools/kaiserBessel.m
new file mode 100644
index 0000000..aef7b9d
--- /dev/null
+++ b/matlab/tools/kaiserBessel.m
@@ -0,0 +1,31 @@
+function res = kaiserBessel(m,alpha,a,r)
+
+%------------------------------------------------------------------------
+% res = kaiserBessel(m,alpha,a,r)
+% 
+% Calculates the Kaiser windowing function
+%
+% a: length of the sequence.
+% m: order.
+% alpha: determines shape of window.
+% r: input values for which to compute window value.
+% res: the window values.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+sq = sqrt(1 - (r./a).^2);
+
+res1 = 1 ./ besseli(m, alpha);
+res2 = sq .^ m;
+res3 = besseli(m, alpha .* sq);
+
+res = res1 .* res2 .* res3;
diff --git a/matlab/tools/linspace2.m b/matlab/tools/linspace2.m
new file mode 100644
index 0000000..2787fd9
--- /dev/null
+++ b/matlab/tools/linspace2.m
@@ -0,0 +1,25 @@
+function out = linspace2(a,b,c)
+
+%------------------------------------------------------------------------
+% out = linspace2(a,b,c)
+% 
+% Generates linearly spaced vectors 
+%
+% a: lower limit.
+% b: upper limit (exclusive).
+% c: number of elements.
+% out: linearly spaced vector.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+out = linspace(a,b,c+1);
+out = out(1:end-1);
diff --git a/matlab/tools/overlayImage.m b/matlab/tools/overlayImage.m
new file mode 100644
index 0000000..7c81e55
--- /dev/null
+++ b/matlab/tools/overlayImage.m
@@ -0,0 +1,24 @@
+function im = overlayImage(reconstruction, ground_truth)
+%------------------------------------------------------------------------
+% im = overlayImage(reconstruction, ground_truth)
+% 
+% Produces an overlay image of two images, useful for image comparison.
+%
+% reconstruction: first input image matrix.
+% ground_truth: second input image matrix.
+% im: output 3-component image, third channel is 0.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+im(:,:,1) = reconstruction ./ max(reconstruction(:));
+im(:,:,2) = ground_truth ./ max(ground_truth(:));
+im(:,:,3) = zeros(size(reconstruction));
diff --git a/matlab/tools/rebin_fan2par.m b/matlab/tools/rebin_fan2par.m
new file mode 100644
index 0000000..da20932
--- /dev/null
+++ b/matlab/tools/rebin_fan2par.m
@@ -0,0 +1,82 @@
+function F = rebin_fan2par(RadonData, BetaDeg, D, thetaDeg)
+
+%------------------------------------------------------------------------
+% F = rebin_fan2par(RadonData, BetaDeg, D, thetaDeg)
+%
+% Deze functie zet fan beam data om naar parallelle data, door interpolatie
+% (fast resorting algorithm, zie Kak en Slaney)
+% Radondata zoals altijd: eerste coord gamma , de rijen
+%                          tweede coord beta, de kolommen, beide hoeken in
+%                          radialen
+% PixPProj: aantal pixels per projectie (voor skyscan data typisch 1000)
+% BetaDeg: vector met alle draaihoeken in graden
+% D: afstand bron - rotatiecentrum in pixels, dus afstand
+% bron-rotatiecentrum(um) gedeeld door image pixel size (um).
+% thetaDeg: vector met gewenste sinogramwaarden voor theta in graden
+%       de range van thetaDeg moet steeds kleiner zijn dan die van betadeg
+% D,gamma,beta, theta zoals gebruikt in Kak & Slaney
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+NpixPProj = size(RadonData,1);  % aantal pixels per projectie
+%if mod(size(Radondata,1),2)==0
+%    NpixPProjNew=NpixPProj+1;
+%else
+    NpixPProjNew = NpixPProj;
+%end
+
+%% FAN-BEAM RAYS
+
+% flip sinogram, why?
+RadonData = flipdim(RadonData,2);  %  matlab gebruikt tegengestelde draairichting (denkik) als skyscan, of er is een of andere flipdim geweest die gecorrigeerd moet worden))
+
+% DetPixPos: distance of each detector to the ray through the origin (theta)
+DetPixPos = -(NpixPProj-1)/2:(NpixPProj-1)/2;  % posities detectorpixels
+
+% GammaStralen: alpha's? (result in radians!!)
+GammaStralen = atan(DetPixPos/D); % alle met de detectorpixelposities overeenkomstige gammahoeken
+
+% put beta (theta) and gamma (alpha) for each ray in 2D matrices
+[beta gamma] = meshgrid(BetaDeg,GammaStralen);
+
+% t: minimal distance between each ray and the ray through the origin
+t = D*sin(gamma); % t-waarden overeenkomstig met de verschillende gamma's
+
+theta = gamma*180/pi + beta;  % theta-waarden in graden overeenkomstig met verschillende gamma en beta waarden
+
+%% PARALLEL BEAM RAYS
+
+% DetPixPos: distance of each detector to the ray through the origin (theta)
+DetPixPos = -(NpixPProjNew-1)/2:(NpixPProjNew-1)/2;  % posities detectorpixels
+
+% GammaStralen: alpha's? (result in radians!!)
+GammaStralenNew = atan(DetPixPos/D); % alle met de detectorpixelposities overeenkomstige gammahoeken
+
+% put beta (theta) and gamma (alpha) for each ray in 2D matrices
+[~, gamma] = meshgrid(BetaDeg,GammaStralenNew);
+
+% t: minimal distance between each ray and the ray through the origin
+tnew = D * sin(gamma); % t-waarden overeenkomstig met de verschillende gamma's
+
+% calculate new t
+step = (max(tnew)-min(tnew)) / (NpixPProjNew-1);
+t_para = min(tnew):step:max(tnew);
+
+[thetaNewCoord tNewCoord] = meshgrid(thetaDeg, t_para);
+
+%% Interpolate
+Interpolant = TriScatteredInterp(theta(:), t(:), RadonData(:),'nearest');
+F = Interpolant(thetaNewCoord,tNewCoord);
+
+
+
+
diff --git a/matlab/tools/sliceExtractor.m b/matlab/tools/sliceExtractor.m
new file mode 100644
index 0000000..dfc87ee
--- /dev/null
+++ b/matlab/tools/sliceExtractor.m
@@ -0,0 +1,34 @@
+function slice = sliceExtractor(data, dir, slicenr)
+
+%------------------------------------------------------------------------
+% slice = sliceExtractor(data, dir, slicenr)
+% 
+% Outputs a specified slice from a three dimensional matrix/volume
+%
+% data: the 3D volume.
+% dir: the direction in which the volume is sliced.
+% slicenr: the index of the slice to retrieve.
+% slice: 2D image matrix containing the slice.
+%------------------------------------------------------------------------
+%------------------------------------------------------------------------
+% This file is part of the
+% All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA-Toolbox")
+%
+% Copyright: iMinds-Vision Lab, University of Antwerp
+% License: Open Source under GPLv3
+% Contact: mailto:astra@ua.ac.be
+% Website: http://astra.ua.ac.be
+%------------------------------------------------------------------------
+% $Id$
+
+slicenr = round(slicenr);
+
+if strcmp(dir,'z')
+	slice = squeeze(data(:,:,slicenr));
+end
+if strcmp(dir,'x')
+	slice = squeeze(data(:,slicenr,:));
+end
+if strcmp(dir,'y')
+	slice = squeeze(data(slicenr,:,:));
+end