Merge branch 'consistent_scaling'

8 files changed, 161 insertions, 1278 deletions

diff --git a/cuda/3d/cgls3d.cu b/cuda/3d/cgls3d.cu
index 10c5f1e..4829574 100644
--- a/cuda/3d/cgls3d.cu
+++ b/cuda/3d/cgls3d.cu
@@ -33,10 +33,6 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
 #include <cstdio>
 #include <cassert>
 
-#ifdef STANDALONE
-#include "testutil.h"
-#endif
-
 namespace astraCUDA3d {
 
 CGLS::CGLS() : ReconAlgo3D()
@@ -263,161 +259,3 @@ bool doCGLS(cudaPitchedPtr& D_volumeData,
 }
 
 }
-
-#ifdef STANDALONE
-
-using namespace astraCUDA3d;
-
-int main()
-{
-	SDimensions3D dims;
-	dims.iVolX = 256;
-	dims.iVolY = 256;
-	dims.iVolZ = 256;
-	dims.iProjAngles = 100;
-	dims.iProjU = 512;
-	dims.iProjV = 512;
-	dims.iRaysPerDet = 1;
-
-	SConeProjection angle[100];
-	angle[0].fSrcX = -2905.6;
-	angle[0].fSrcY = 0;
-	angle[0].fSrcZ = 0;
-
-	angle[0].fDetSX = 694.4;
-	angle[0].fDetSY = -122.4704;
-	angle[0].fDetSZ = -122.4704;
-
-	angle[0].fDetUX = 0;
-	angle[0].fDetUY = .4784;
-	//angle[0].fDetUY = .5;
-	angle[0].fDetUZ = 0;
-
-	angle[0].fDetVX = 0;
-	angle[0].fDetVY = 0;
-	angle[0].fDetVZ = .4784;
-
-#define ROTATE0(name,i,alpha) do { angle[i].f##name##X = angle[0].f##name##X * cos(alpha) - angle[0].f##name##Y * sin(alpha); angle[i].f##name##Y = angle[0].f##name##X * sin(alpha) + angle[0].f##name##Y * cos(alpha); } while(0)
-	for (int i = 1; i < 100; ++i) {
-		angle[i] = angle[0];
-		ROTATE0(Src, i, i*2*M_PI/100);
-		ROTATE0(DetS, i, i*2*M_PI/100);
-		ROTATE0(DetU, i, i*2*M_PI/100);
-		ROTATE0(DetV, i, i*2*M_PI/100);
-	}
-#undef ROTATE0
-
-
-	cudaPitchedPtr volData = allocateVolumeData(dims);
-	cudaPitchedPtr projData = allocateProjectionData(dims);
-	zeroProjectionData(projData, dims);
-
-	float* pbuf = new float[100*512*512];
-	copyProjectionsFromDevice(pbuf, projData, dims);
-	copyProjectionsToDevice(pbuf, projData, dims);
-	delete[] pbuf;
-
-#if 0
-	float* slice = new float[256*256];
-	cudaPitchedPtr ptr;
-	ptr.ptr = slice;
-	ptr.pitch = 256*sizeof(float);
-	ptr.xsize = 256*sizeof(float);
-	ptr.ysize = 256;
-
-	for (unsigned int i = 0; i < 256; ++i) {
-		for (unsigned int y = 0; y < 256; ++y)
-			for (unsigned int x = 0; x < 256; ++x)
-				slice[y*256+x] = (i-127.5)*(i-127.5)+(y-127.5)*(y-127.5)+(x-127.5)*(x-127.5) < 4900 ? 1.0f : 0.0f;
-
-		cudaExtent extentS;
-		extentS.width = dims.iVolX*sizeof(float);
-		extentS.height = dims.iVolY;
-		extentS.depth = 1;
-		cudaPos sp = { 0, 0, 0 };
-		cudaPos dp = { 0, 0, i };
-		cudaMemcpy3DParms p;
-		p.srcArray = 0;
-		p.srcPos = sp;
-		p.srcPtr = ptr;
-		p.dstArray = 0;
-		p.dstPos = dp;
-		p.dstPtr = volData;
-		p.extent = extentS;
-		p.kind = cudaMemcpyHostToDevice;
-		cudaMemcpy3D(&p);
-	}
-	astraCUDA3d::ConeFP(volData, projData, dims, angle, 1.0f);
-
-#else
-
-	for (int i = 0; i < 100; ++i) {
-		char fname[32];
-		sprintf(fname, "Tiffs/%04d.png", 4*i);
-		unsigned int w,h;
-		float* bufp = loadImage(fname, w,h);
-
-		for (int j = 0; j < 512*512; ++j) {
-			float v = bufp[j];
-			if (v > 236.0f) v = 236.0f;
-			v = logf(236.0f / v);
-			bufp[j] = 256*v;
-		}
-
-		for (int j = 0; j < 512; ++j) {
-			cudaMemcpy(((float*)projData.ptr)+100*512*j+512*i, bufp+512*j, 512*sizeof(float), cudaMemcpyHostToDevice);
-		}
-
-		delete[] bufp;
-
-	}
-#endif
-
-#if 0
-	float* bufs = new float[100*512];
-
-	for (int i = 0; i < 512; ++i) {
-		cudaMemcpy(bufs, ((float*)projData.ptr)+100*512*i, 100*512*sizeof(float), cudaMemcpyDeviceToHost);
-
-		printf("%d %d %d\n", projData.pitch, projData.xsize, projData.ysize);
-
-		char fname[20];
-		sprintf(fname, "sino%03d.png", i);
-		saveImage(fname, 100, 512, bufs);
-	}
-
-	float* bufp = new float[512*512];
-
-	for (int i = 0; i < 100; ++i) {
-		for (int j = 0; j < 512; ++j) {
-			cudaMemcpy(bufp+512*j, ((float*)projData.ptr)+100*512*j+512*i, 512*sizeof(float), cudaMemcpyDeviceToHost);
-		}
-
-		char fname[20];
-		sprintf(fname, "proj%03d.png", i);
-		saveImage(fname, 512, 512, bufp);
-	}
-#endif
-
-	zeroVolumeData(volData, dims);
-
-	cudaPitchedPtr maskData;
-	maskData.ptr = 0;
-
-	astraCUDA3d::doCGLS(volData, projData, maskData, dims, angle, 50);
-#if 1
-	float* buf = new float[256*256];
-
-	for (int i = 0; i < 256; ++i) {
-		cudaMemcpy(buf, ((float*)volData.ptr)+256*256*i, 256*256*sizeof(float), cudaMemcpyDeviceToHost);
-
-		char fname[20];
-		sprintf(fname, "vol%03d.png", i);
-		saveImage(fname, 256, 256, buf);
-	}
-#endif
-
-	return 0;
-}
-#endif
-
diff --git a/cuda/3d/cone_bp.cu b/cuda/3d/cone_bp.cu
index feebda2..7312bbc 100644
--- a/cuda/3d/cone_bp.cu
+++ b/cuda/3d/cone_bp.cu
@@ -28,11 +28,6 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
 #include "astra/cuda/3d/util3d.h"
 #include "astra/cuda/3d/dims3d.h"
 
-#ifdef STANDALONE
-#include "astra/cuda/3d/cone_fp.h"
-#include "testutil.h"
-#endif
-
 #include <cstdio>
 #include <cassert>
 #include <iostream>
@@ -55,7 +50,13 @@ static const unsigned int g_volBlockY = 32;
 
 static const unsigned g_MaxAngles = 1024;
 
-__constant__ float gC_C[12*g_MaxAngles];
+struct DevConeParams {
+	float4 fNumU;
+	float4 fNumV;
+	float4 fDen;
+};
+
+__constant__ DevConeParams gC_C[g_MaxAngles];
 
 bool bindProjDataTexture(const cudaArray* array)
 {
@@ -118,16 +119,13 @@ __global__ void dev_cone_BP(void* D_volData, unsigned int volPitch, int startAng
 
 		for (int angle = startAngle; angle < endAngle; ++angle, fAngle += 1.0f)
 		{
-			float4 fCu  = make_float4(gC_C[12*angle+0], gC_C[12*angle+1], gC_C[12*angle+2], gC_C[12*angle+3]);
-			float4 fCv  = make_float4(gC_C[12*angle+4], gC_C[12*angle+5], gC_C[12*angle+6], gC_C[12*angle+7]);
-			float4 fCd  = make_float4(gC_C[12*angle+8], gC_C[12*angle+9], gC_C[12*angle+10], gC_C[12*angle+11]);
+			float4 fCu  = gC_C[angle].fNumU;
+			float4 fCv  = gC_C[angle].fNumV;
+			float4 fCd  = gC_C[angle].fDen;
 
 			float fUNum = fCu.w + fX * fCu.x + fY * fCu.y + fZ * fCu.z;
 			float fVNum = fCv.w + fX * fCv.x + fY * fCv.y + fZ * fCv.z;
-			float fDen  = fCd.w + fX * fCd.x + fY * fCd.y + fZ * fCd.z;
-
-			// fCd.w = -|| u v s || (determinant of 3x3 matrix with cols u,v,s)
-			// fDen =  || u v (x-s) ||
+			float fDen  = (FDKWEIGHT ? 1.0f : fCd.w) + fX * fCd.x + fY * fCd.y + fZ * fCd.z;
 
 			float fU,fV, fr;
 
@@ -137,18 +135,7 @@ __global__ void dev_cone_BP(void* D_volData, unsigned int volPitch, int startAng
 				fU = fUNum * fr;
 				fV = fVNum * fr;
 				float fVal = tex3D(gT_coneProjTexture, fU, fAngle, fV);
-				if (FDKWEIGHT) {
-					// The correct factor here is this one:
-					// Z[idx] += (fr*fCd.w)*(fr*fCd.w)*fVal;
-					// This is the square of the inverse magnification factor
-					// from fX,fY,fZ to the detector.
-
-					// Since we are assuming we have a circular cone
-					// beam trajectory, fCd.w is constant, and we instead
-					// multiply by fCd.w*fCd.w in the FDK preweighting step.
-					Z[idx] += fr*fr*fVal;
-				} else
-					Z[idx] += fVal;
+				Z[idx] += fr*fr*fVal;
 
 				fUNum += fCu.z;
 				fVNum += fCv.z;
@@ -215,19 +202,9 @@ __global__ void dev_cone_BP_SS(void* D_volData, unsigned int volPitch, int start
 
 		for (int angle = startAngle; angle < endAngle; ++angle, fAngle += 1.0f)
 		{
-
-			const float fCux = gC_C[12*angle+0];
-			const float fCuy = gC_C[12*angle+1];
-			const float fCuz = gC_C[12*angle+2];
-			const float fCuc = gC_C[12*angle+3];
-			const float fCvx = gC_C[12*angle+4];
-			const float fCvy = gC_C[12*angle+5];
-			const float fCvz = gC_C[12*angle+6];
-			const float fCvc = gC_C[12*angle+7];
-			const float fCdx = gC_C[12*angle+8];
-			const float fCdy = gC_C[12*angle+9];
-			const float fCdz = gC_C[12*angle+10];
-			const float fCdc = gC_C[12*angle+11];
+			float4 fCu  = gC_C[angle].fNumU;
+			float4 fCv  = gC_C[angle].fNumV;
+			float4 fCd  = gC_C[angle].fDen;
 
 			float fXs = fX;
 			for (int iSubX = 0; iSubX < iRaysPerVoxelDim; ++iSubX) {
@@ -236,14 +213,15 @@ __global__ void dev_cone_BP_SS(void* D_volData, unsigned int volPitch, int start
 			float fZs = fZ;
 			for (int iSubZ = 0; iSubZ < iRaysPerVoxelDim; ++iSubZ) {
 
-				const float fUNum = fCuc + fXs * fCux + fYs * fCuy + fZs * fCuz;
-				const float fVNum = fCvc + fXs * fCvx + fYs * fCvy + fZs * fCvz;
-				const float fDen = fCdc + fXs * fCdx + fYs * fCdy + fZs * fCdz;
+				const float fUNum = fCu.w + fX * fCu.x + fY * fCu.y + fZ * fCu.z;
+				const float fVNum = fCv.w + fX * fCv.x + fY * fCv.y + fZ * fCv.z;
+				const float fDen  = fCd.w + fX * fCd.x + fY * fCd.y + fZ * fCd.z;
 
-				const float fU = fUNum / fDen;
-				const float fV = fVNum / fDen;
+				const float fr = __fdividef(1.0f, fDen);
+				const float fU = fUNum * fr;
+				const float fV = fVNum * fr;
 
-				fVal += tex3D(gT_coneProjTexture, fU, fV, fAngle);
+				fVal += tex3D(gT_coneProjTexture, fU, fV, fAngle) * fr;
 
 				fZs += fSubStep;
 			}
@@ -259,6 +237,76 @@ __global__ void dev_cone_BP_SS(void* D_volData, unsigned int volPitch, int start
 }
 
 
+bool transferConstants(const SConeProjection* angles, unsigned int iProjAngles, const SProjectorParams3D& params)
+{
+	DevConeParams *p = new DevConeParams[iProjAngles];
+
+	// We need three things in the kernel:
+	// projected coordinates of pixels on the detector:
+
+	// u: || (x-s) v (s-d) || / || u v (s-x) ||
+	// v: -|| u (x-s) (s-d) || / || u v (s-x) ||
+
+	// ray density weighting factor for the adjoint
+	// || u v (s-d) ||^2 / ( |cross(u,v)| * || u v (s-x) ||^2 )
+
+	// FDK weighting factor
+	// ( || u v s || / || u v (s-x) || ) ^ 2
+
+	// Since u and v are ratios with the same denominator, we have
+	// a degree of freedom to scale the denominator. We use that to make
+	// the square of the denominator equal to the relevant weighting factor.
+
+
+	for (unsigned int i = 0; i < iProjAngles; ++i) {
+		Vec3 u(angles[i].fDetUX, angles[i].fDetUY, angles[i].fDetUZ);
+		Vec3 v(angles[i].fDetVX, angles[i].fDetVY, angles[i].fDetVZ);
+		Vec3 s(angles[i].fSrcX, angles[i].fSrcY, angles[i].fSrcZ);
+		Vec3 d(angles[i].fDetSX, angles[i].fDetSY, angles[i].fDetSZ);
+
+
+
+		double fScale;
+		if (!params.bFDKWeighting) {
+			// goal: 1/fDen^2 = || u v (s-d) ||^2 / ( |cross(u,v)| * || u v (s-x) ||^2 )
+			// fDen = ( sqrt(|cross(u,v)|) * || u v (s-x) || ) / || u v (s-d) || 
+			// i.e. scale = sqrt(|cross(u,v)|) * / || u v (s-d) ||
+
+
+			// NB: for cross(u,v) we invert the volume scaling (for the voxel
+			// size normalization) to get the proper dimensions for
+			// the scaling of the adjoint
+
+			fScale = sqrt(scaled_cross3(u,v,Vec3(params.fVolScaleX,params.fVolScaleY,params.fVolScaleZ)).norm()) / det3(u, v, s-d);
+		} else {
+			// goal: 1/fDen = || u v s || / || u v (s-x) ||
+			// fDen = || u v (s-x) || / || u v s ||
+			// i.e., scale = 1 / || u v s ||
+
+			fScale = 1.0 / det3(u, v, s);
+		}
+
+		p[i].fNumU.w = fScale * det3(s,v,d);
+		p[i].fNumU.x = fScale * det3x(v,s-d);
+		p[i].fNumU.y = fScale * det3y(v,s-d);
+		p[i].fNumU.z = fScale * det3z(v,s-d);
+		p[i].fNumV.w = -fScale * det3(s,u,d);
+		p[i].fNumV.x = -fScale * det3x(u,s-d);
+		p[i].fNumV.y = -fScale * det3y(u,s-d);
+		p[i].fNumV.z = -fScale * det3z(u,s-d);
+		p[i].fDen.w = fScale * det3(u, v, s); // == 1.0 for FDK
+		p[i].fDen.x = -fScale * det3x(u, v);
+		p[i].fDen.y = -fScale * det3y(u, v);
+		p[i].fDen.z = -fScale * det3z(u, v);
+	}
+
+	// TODO: Check for errors
+	cudaMemcpyToSymbol(gC_C, p, iProjAngles*sizeof(DevConeParams), 0, cudaMemcpyHostToDevice);
+
+	return true;
+}
+
+
 bool ConeBP_Array(cudaPitchedPtr D_volumeData,
                   cudaArray *D_projArray,
                   const SDimensions3D& dims, const SConeProjection* angles,
@@ -267,44 +315,21 @@ bool ConeBP_Array(cudaPitchedPtr D_volumeData,
 	bindProjDataTexture(D_projArray);
 
 	float fOutputScale;
-	if (params.bFDKWeighting)
-		fOutputScale = params.fOutputScale / (params.fVolScaleX * params.fVolScaleY * params.fVolScaleZ);
-	else
+	if (params.bFDKWeighting) {
+		// NB: assuming cube voxels here
+		fOutputScale = params.fOutputScale / (params.fVolScaleX);
+	} else {
 		fOutputScale = params.fOutputScale * (params.fVolScaleX * params.fVolScaleY * params.fVolScaleZ);
+	}
 
 	for (unsigned int th = 0; th < dims.iProjAngles; th += g_MaxAngles) {
 		unsigned int angleCount = g_MaxAngles;
 		if (th + angleCount > dims.iProjAngles)
 			angleCount = dims.iProjAngles - th;
 
-		// transfer angles to constant memory
-		float* tmp = new float[12*angleCount];
-
-
-		// NB: We increment angles at the end of the loop body.
-
-
-#define TRANSFER_TO_CONSTANT(expr,name) do { for (unsigned int i = 0; i < angleCount; ++i) tmp[12*i+name] = (expr) ; } while (0)
-
-		TRANSFER_TO_CONSTANT( (angles[i].fDetSZ - angles[i].fSrcZ)*angles[i].fDetVY - (angles[i].fDetSY - angles[i].fSrcY)*angles[i].fDetVZ , 0 );
-		TRANSFER_TO_CONSTANT( (angles[i].fDetSX - angles[i].fSrcX)*angles[i].fDetVZ -(angles[i].fDetSZ - angles[i].fSrcZ)*angles[i].fDetVX , 1 );
-		TRANSFER_TO_CONSTANT( (angles[i].fDetSY - angles[i].fSrcY)*angles[i].fDetVX - (angles[i].fDetSX - angles[i].fSrcX)*angles[i].fDetVY , 2 );
-		TRANSFER_TO_CONSTANT( (angles[i].fDetSY*angles[i].fDetVZ - angles[i].fDetSZ*angles[i].fDetVY)*angles[i].fSrcX - (angles[i].fDetSX*angles[i].fDetVZ - angles[i].fDetSZ*angles[i].fDetVX)*angles[i].fSrcY + (angles[i].fDetSX*angles[i].fDetVY - angles[i].fDetSY*angles[i].fDetVX)*angles[i].fSrcZ , 3 );
-
-		TRANSFER_TO_CONSTANT( (angles[i].fDetSY - angles[i].fSrcY)*angles[i].fDetUZ-(angles[i].fDetSZ - angles[i].fSrcZ)*angles[i].fDetUY, 4 );
-		TRANSFER_TO_CONSTANT( (angles[i].fDetSZ - angles[i].fSrcZ)*angles[i].fDetUX - (angles[i].fDetSX - angles[i].fSrcX)*angles[i].fDetUZ , 5 );
-		TRANSFER_TO_CONSTANT((angles[i].fDetSX - angles[i].fSrcX)*angles[i].fDetUY-(angles[i].fDetSY - angles[i].fSrcY)*angles[i].fDetUX , 6 );
-		TRANSFER_TO_CONSTANT( -(angles[i].fDetSY*angles[i].fDetUZ - angles[i].fDetSZ*angles[i].fDetUY)*angles[i].fSrcX + (angles[i].fDetSX*angles[i].fDetUZ - angles[i].fDetSZ*angles[i].fDetUX)*angles[i].fSrcY - (angles[i].fDetSX*angles[i].fDetUY - angles[i].fDetSY*angles[i].fDetUX)*angles[i].fSrcZ , 7 );
-
-		TRANSFER_TO_CONSTANT( angles[i].fDetUY*angles[i].fDetVZ - angles[i].fDetUZ*angles[i].fDetVY , 8 );
-		TRANSFER_TO_CONSTANT( angles[i].fDetUZ*angles[i].fDetVX - angles[i].fDetUX*angles[i].fDetVZ , 9 );
-		TRANSFER_TO_CONSTANT( angles[i].fDetUX*angles[i].fDetVY - angles[i].fDetUY*angles[i].fDetVX , 10 );
-		TRANSFER_TO_CONSTANT( -angles[i].fSrcX * (angles[i].fDetUY*angles[i].fDetVZ - angles[i].fDetUZ*angles[i].fDetVY) - angles[i].fSrcY * (angles[i].fDetUZ*angles[i].fDetVX - angles[i].fDetUX*angles[i].fDetVZ) - angles[i].fSrcZ * (angles[i].fDetUX*angles[i].fDetVY - angles[i].fDetUY*angles[i].fDetVX) , 11 );
-
-#undef TRANSFER_TO_CONSTANT
-		cudaMemcpyToSymbol(gC_C, tmp, angleCount*12*sizeof(float), 0, cudaMemcpyHostToDevice); 
-
-		delete[] tmp;
+		bool ok = transferConstants(angles, angleCount, params);
+		if (!ok)
+			return false;
 
 		dim3 dimBlock(g_volBlockX, g_volBlockY);
 
@@ -353,168 +378,3 @@ bool ConeBP(cudaPitchedPtr D_volumeData,
 
 
 }
-
-#ifdef STANDALONE
-int main()
-{
-	astraCUDA3d::SDimensions3D dims;
-	dims.iVolX = 512;
-	dims.iVolY = 512;
-	dims.iVolZ = 512;
-	dims.iProjAngles = 496;
-	dims.iProjU = 512;
-	dims.iProjV = 512;
-	dims.iRaysPerDetDim = 1;
-	dims.iRaysPerVoxelDim = 1;
-
-	cudaExtent extentV;
-	extentV.width = dims.iVolX*sizeof(float);
-	extentV.height = dims.iVolY;
-	extentV.depth = dims.iVolZ;
-
-	cudaPitchedPtr volData; // pitch, ptr, xsize, ysize
-
-	cudaMalloc3D(&volData, extentV);
-
-	cudaExtent extentP;
-	extentP.width = dims.iProjU*sizeof(float);
-	extentP.height = dims.iProjAngles;
-	extentP.depth = dims.iProjV;
-
-	cudaPitchedPtr projData; // pitch, ptr, xsize, ysize
-
-	cudaMalloc3D(&projData, extentP);
-	cudaMemset3D(projData, 0, extentP);
-
-#if 0
-	float* slice = new float[256*256];
-	cudaPitchedPtr ptr;
-	ptr.ptr = slice;
-	ptr.pitch = 256*sizeof(float);
-	ptr.xsize = 256*sizeof(float);
-	ptr.ysize = 256;
-
-	for (unsigned int i = 0; i < 256*256; ++i)
-		slice[i] = 1.0f;
-	for (unsigned int i = 0; i < 256; ++i) {
-		cudaExtent extentS;
-		extentS.width = dims.iVolX*sizeof(float);
-		extentS.height = dims.iVolY;
-		extentS.depth = 1;
-		cudaPos sp = { 0, 0, 0 };
-		cudaPos dp = { 0, 0, i };
-		cudaMemcpy3DParms p;
-		p.srcArray = 0;
-		p.srcPos = sp;
-		p.srcPtr = ptr;
-		p.dstArray = 0;
-		p.dstPos = dp;
-		p.dstPtr = volData;
-		p.extent = extentS;
-		p.kind = cudaMemcpyHostToDevice;
-		cudaMemcpy3D(&p);
-#if 0
-		if (i == 128) {
-			for (unsigned int j = 0; j < 256*256; ++j)
-				slice[j] = 0.0f;
-		}
-#endif 
-	}
-#endif
-
-
-	astraCUDA3d::SConeProjection angle[512];
-	angle[0].fSrcX = -5120;
-	angle[0].fSrcY = 0;
-	angle[0].fSrcZ = 0;
-
-	angle[0].fDetSX = 512;
-	angle[0].fDetSY = -256;
-	angle[0].fDetSZ = -256;
-
-	angle[0].fDetUX = 0;
-	angle[0].fDetUY = 1;
-	angle[0].fDetUZ = 0;
-
-	angle[0].fDetVX = 0;
-	angle[0].fDetVY = 0;
-	angle[0].fDetVZ = 1;
-
-#define ROTATE0(name,i,alpha) do { angle[i].f##name##X = angle[0].f##name##X * cos(alpha) - angle[0].f##name##Y * sin(alpha); angle[i].f##name##Y = angle[0].f##name##X * sin(alpha) + angle[0].f##name##Y * cos(alpha); } while(0)
-	for (int i = 1; i < 512; ++i) {
-		angle[i] = angle[0];
-		ROTATE0(Src, i, i*2*M_PI/512);
-		ROTATE0(DetS, i, i*2*M_PI/512);
-		ROTATE0(DetU, i, i*2*M_PI/512);
-		ROTATE0(DetV, i, i*2*M_PI/512);
-	}
-#undef ROTATE0
-
-#if 0
-	astraCUDA3d::ConeFP(volData, projData, dims, angle, 1.0f);
-#endif
-#if 0
-	float* bufs = new float[180*512];
-
-	for (int i = 0; i < 512; ++i) {
-		cudaMemcpy(bufs, ((float*)projData.ptr)+180*512*i, 180*512*sizeof(float), cudaMemcpyDeviceToHost);
-
-		printf("%d %d %d\n", projData.pitch, projData.xsize, projData.ysize);
-
-		char fname[20];
-		sprintf(fname, "sino%03d.png", i);
-		saveImage(fname, 180, 512, bufs);
-	}
-
-	float* bufp = new float[512*512];
-
-	for (int i = 0; i < 180; ++i) {
-		for (int j = 0; j < 512; ++j) {
-			cudaMemcpy(bufp+512*j, ((float*)projData.ptr)+180*512*j+512*i, 512*sizeof(float), cudaMemcpyDeviceToHost);
-		}
-
-		char fname[20];
-		sprintf(fname, "proj%03d.png", i);
-		saveImage(fname, 512, 512, bufp);
-	}
-#endif		
-#if 0
-	for (unsigned int i = 0; i < 256*256; ++i)
-		slice[i] = 0.0f;
-	for (unsigned int i = 0; i < 256; ++i) {
-		cudaExtent extentS;
-		extentS.width = dims.iVolX*sizeof(float);
-		extentS.height = dims.iVolY;
-		extentS.depth = 1;
-		cudaPos sp = { 0, 0, 0 };
-		cudaPos dp = { 0, 0, i };
-		cudaMemcpy3DParms p;
-		p.srcArray = 0;
-		p.srcPos = sp;
-		p.srcPtr = ptr;
-		p.dstArray = 0;
-		p.dstPos = dp;
-		p.dstPtr = volData;
-		p.extent = extentS;
-		p.kind = cudaMemcpyHostToDevice;
-		cudaMemcpy3D(&p);
-	}
-#endif
-
-	astraCUDA3d::ConeBP(volData, projData, dims, angle, 1.0f);
-#if 0
-	float* buf = new float[256*256];
-
-	for (int i = 0; i < 256; ++i) {
-		cudaMemcpy(buf, ((float*)volData.ptr)+256*256*i, 256*256*sizeof(float), cudaMemcpyDeviceToHost);
-
-		printf("%d %d %d\n", volData.pitch, volData.xsize, volData.ysize);
-
-		char fname[20];
-		sprintf(fname, "vol%03d.png", i);
-		saveImage(fname, 256, 256, buf);
-	}
-#endif
-
-}
-#endif
diff --git a/cuda/3d/cone_fp.cu b/cuda/3d/cone_fp.cu
index 7e0fae8..bd607fa 100644
--- a/cuda/3d/cone_fp.cu
+++ b/cuda/3d/cone_fp.cu
@@ -28,10 +28,6 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
 #include "astra/cuda/3d/util3d.h"
 #include "astra/cuda/3d/dims3d.h"
 
-#ifdef STANDALONE
-#include "testutil.h"
-#endif
-
 #include <cstdio>
 #include <cassert>
 #include <iostream>
@@ -368,7 +364,7 @@ bool ConeFP_Array_internal(cudaPitchedPtr D_projData,
 	SCALE_NONCUBE snoncubeY;
 	fS1 = params.fVolScaleX / params.fVolScaleY;
 	snoncubeY.fScale1 = fS1 * fS1;
-	fS2 = params.fVolScaleY / params.fVolScaleY;
+	fS2 = params.fVolScaleZ / params.fVolScaleY;
 	snoncubeY.fScale2 = fS2 * fS2;
 	snoncubeY.fOutputScale = params.fOutputScale * params.fVolScaleY;
 
@@ -498,105 +494,3 @@ bool ConeFP(cudaPitchedPtr D_volumeData,
 
 
 }
-
-#ifdef STANDALONE
-int main()
-{
-	SDimensions3D dims;
-	dims.iVolX = 256;
-	dims.iVolY = 256;
-	dims.iVolZ = 256;
-	dims.iProjAngles = 32;
-	dims.iProjU = 512;
-	dims.iProjV = 512;
-	dims.iRaysPerDet = 1;
-
-	cudaExtent extentV;
-	extentV.width = dims.iVolX*sizeof(float);
-	extentV.height = dims.iVolY;
-	extentV.depth = dims.iVolZ;
-
-	cudaPitchedPtr volData; // pitch, ptr, xsize, ysize
-
-	cudaMalloc3D(&volData, extentV);
-
-	cudaExtent extentP;
-	extentP.width = dims.iProjU*sizeof(float);
-	extentP.height = dims.iProjV;
-	extentP.depth = dims.iProjAngles;
-
-	cudaPitchedPtr projData; // pitch, ptr, xsize, ysize
-
-	cudaMalloc3D(&projData, extentP);
-	cudaMemset3D(projData, 0, extentP);
-
-	float* slice = new float[256*256];
-	cudaPitchedPtr ptr;
-	ptr.ptr = slice;
-	ptr.pitch = 256*sizeof(float);
-	ptr.xsize = 256*sizeof(float);
-	ptr.ysize = 256;
-
-	for (unsigned int i = 0; i < 256*256; ++i)
-		slice[i] = 1.0f;
-	for (unsigned int i = 0; i < 256; ++i) {
-		cudaExtent extentS;
-		extentS.width = dims.iVolX*sizeof(float);
-		extentS.height = dims.iVolY;
-		extentS.depth = 1;
-		cudaPos sp = { 0, 0, 0 };
-		cudaPos dp = { 0, 0, i };
-		cudaMemcpy3DParms p;
-		p.srcArray = 0;
-		p.srcPos = sp;
-		p.srcPtr = ptr;
-		p.dstArray = 0;
-		p.dstPos = dp;
-		p.dstPtr = volData;
-		p.extent = extentS;
-		p.kind = cudaMemcpyHostToDevice;
-		cudaError err = cudaMemcpy3D(&p);
-		assert(!err);
-	}
-
-
-	SConeProjection angle[32];
-	angle[0].fSrcX = -1536;
-	angle[0].fSrcY = 0;
-	angle[0].fSrcZ = 200;
-
-	angle[0].fDetSX = 512;
-	angle[0].fDetSY = -256;
-	angle[0].fDetSZ = -256;
-
-	angle[0].fDetUX = 0;
-	angle[0].fDetUY = 1;
-	angle[0].fDetUZ = 0;
-
-	angle[0].fDetVX = 0;
-	angle[0].fDetVY = 0;
-	angle[0].fDetVZ = 1;
-
-#define ROTATE0(name,i,alpha) do { angle[i].f##name##X = angle[0].f##name##X * cos(alpha) - angle[0].f##name##Y * sin(alpha); angle[i].f##name##Y = angle[0].f##name##X * sin(alpha) + angle[0].f##name##Y * cos(alpha); } while(0)
-	for (int i = 1; i < 32; ++i) {
-		angle[i] = angle[0];
-		ROTATE0(Src, i, i*1*M_PI/180);
-		ROTATE0(DetS, i, i*1*M_PI/180);
-		ROTATE0(DetU, i, i*1*M_PI/180);
-		ROTATE0(DetV, i, i*1*M_PI/180);
-	}
-#undef ROTATE0
-
-	astraCUDA3d::ConeFP(volData, projData, dims, angle, 1.0f);
-
-	float* buf = new float[512*512];
-
-	cudaMemcpy(buf, ((float*)projData.ptr)+512*512*8, 512*512*sizeof(float), cudaMemcpyDeviceToHost);
-
-	printf("%d %d %d\n", projData.pitch, projData.xsize, projData.ysize);
-
-	saveImage("proj.png", 512, 512, buf);
-	
-
-}
-#endif
diff --git a/cuda/3d/fdk.cu b/cuda/3d/fdk.cu
index 1294721..456694f 100644
--- a/cuda/3d/fdk.cu
+++ b/cuda/3d/fdk.cu
@@ -32,11 +32,6 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
 
 #include "astra/cuda/2d/fft.h"
 
-#ifdef STANDALONE
-#include "astra/cuda/3d/cone_fp.h"
-#include "testutil.h"
-#endif
-
 #include "astra/Logging.h"
 
 #include <cstdio>
@@ -57,10 +52,13 @@ static const unsigned g_MaxAngles = 12000;
 __constant__ float gC_angle[g_MaxAngles];
 
 
-// per-detector u/v shifts?
 
+// TODO: To support non-cube voxels, preweighting needs per-view
+// parameters. NB: Need to properly take into account the
+// anisotropic volume normalization done for that too.
 
-__global__ void devFDK_preweight(void* D_projData, unsigned int projPitch, unsigned int startAngle, unsigned int endAngle, float fSrcOrigin, float fDetOrigin, float fZShift, float fDetUSize, float fDetVSize, float fVoxSize, const SDimensions3D dims)
+
+__global__ void devFDK_preweight(void* D_projData, unsigned int projPitch, unsigned int startAngle, unsigned int endAngle, float fSrcOrigin, float fDetOrigin, float fZShift, float fDetUSize, float fDetVSize, const SDimensions3D dims)
 {
 	float* projData = (float*)D_projData;
 	int angle = startAngle + blockIdx.y * g_anglesPerWeightBlock + threadIdx.y;
@@ -88,14 +86,10 @@ __global__ void devFDK_preweight(void* D_projData, unsigned int projPitch, unsig
 	// fCentralRayLength / fRayLength   : the main FDK preweighting factor
 	// fSrcOrigin / (fDetUSize * fCentralRayLength)
 	//                                  : to adjust the filter to the det width
-	// || u v s || ^ 2                  : see cone_bp.cu, FDKWEIGHT
 	// pi / (2 * iProjAngles)           : scaling of the integral over angles
-	// fVoxSize ^ 2                     : ...
 
-	const float fW1 = fSrcOrigin * fDetUSize * fDetVSize;
 	const float fW2 = fCentralRayLength / (fDetUSize * fSrcOrigin);
-	const float fW3 = fVoxSize * fVoxSize;
-	const float fW = fCentralRayLength * fW1 * fW1 * fW2 * fW3 * (M_PI / 2.0f) / (float)dims.iProjAngles;
+	const float fW = fCentralRayLength * fW2 * (M_PI / 2.0f) / (float)dims.iProjAngles;
 
 	for (int detectorV = startDetectorV; detectorV < endDetectorV; ++detectorV)
 	{
@@ -167,7 +161,7 @@ __global__ void devFDK_ParkerWeight(void* D_projData, unsigned int projPitch, un
 bool FDK_PreWeight(cudaPitchedPtr D_projData,
                 float fSrcOrigin, float fDetOrigin,
                 float fZShift,
-                float fDetUSize, float fDetVSize, float fVoxSize,
+                float fDetUSize, float fDetVSize,
 				bool bShortScan,
                 const SDimensions3D& dims, const float* angles)
 {
@@ -180,7 +174,7 @@ bool FDK_PreWeight(cudaPitchedPtr D_projData,
 
 	int projPitch = D_projData.pitch/sizeof(float);
 
-	devFDK_preweight<<<dimGrid, dimBlock>>>(D_projData.ptr, projPitch, 0, dims.iProjAngles, fSrcOrigin, fDetOrigin, fZShift, fDetUSize, fDetVSize, fVoxSize, dims);
+	devFDK_preweight<<<dimGrid, dimBlock>>>(D_projData.ptr, projPitch, 0, dims.iProjAngles, fSrcOrigin, fDetOrigin, fZShift, fDetUSize, fDetVSize, dims);
 
 	cudaTextForceKernelsCompletion();
 
@@ -344,9 +338,8 @@ bool FDK(cudaPitchedPtr D_volumeData,
 
 
 #if 1
-	// NB: assuming cube voxels (params.fVolScaleX)
 	ok = FDK_PreWeight(D_projData, fSrcOrigin, fDetOrigin,
-	                fZShift, fDetUSize, fDetVSize, params.fVolScaleX,
+	                fZShift, fDetUSize, fDetVSize,
 	                bShortScan, dims, pfAngles);
 #else
 	ok = true;
@@ -379,220 +372,3 @@ bool FDK(cudaPitchedPtr D_volumeData,
 
 
 }
-
-#ifdef STANDALONE
-void dumpVolume(const char* filespec, const cudaPitchedPtr& data, const SDimensions3D& dims, float fMin, float fMax)
-{
-	float* buf = new float[dims.iVolX*dims.iVolY];
-	unsigned int pitch = data.pitch / sizeof(float);
-
-	for (int i = 0; i < dims.iVolZ; ++i) {
-		cudaMemcpy2D(buf, dims.iVolX*sizeof(float), ((float*)data.ptr)+pitch*dims.iVolY*i, data.pitch, dims.iVolX*sizeof(float), dims.iVolY, cudaMemcpyDeviceToHost);
-
-		char fname[512];
-		sprintf(fname, filespec, dims.iVolZ-i-1);
-		saveImage(fname, dims.iVolY, dims.iVolX, buf, fMin, fMax);
-	}
-}
-
-void dumpSinograms(const char* filespec, const cudaPitchedPtr& data, const SDimensions3D& dims, float fMin, float fMax)
-{
-	float* bufs = new float[dims.iProjAngles*dims.iProjU];
-	unsigned int pitch = data.pitch / sizeof(float);
-
-	for (int i = 0; i < dims.iProjV; ++i) {
-		cudaMemcpy2D(bufs, dims.iProjU*sizeof(float), ((float*)data.ptr)+pitch*dims.iProjAngles*i, data.pitch, dims.iProjU*sizeof(float), dims.iProjAngles, cudaMemcpyDeviceToHost);
-
-		char fname[512];
-		sprintf(fname, filespec, i);
-		saveImage(fname, dims.iProjAngles, dims.iProjU, bufs, fMin, fMax);
-	}
-}
-
-void dumpProjections(const char* filespec, const cudaPitchedPtr& data, const SDimensions3D& dims, float fMin, float fMax)
-{
-	float* bufp = new float[dims.iProjV*dims.iProjU];
-	unsigned int pitch = data.pitch / sizeof(float);
-
-	for (int i = 0; i < dims.iProjAngles; ++i) {
-		for (int j = 0; j < dims.iProjV; ++j) {
-			cudaMemcpy(bufp+dims.iProjU*j, ((float*)data.ptr)+pitch*dims.iProjAngles*j+pitch*i, dims.iProjU*sizeof(float), cudaMemcpyDeviceToHost);
-		}
-
-		char fname[512];
-		sprintf(fname, filespec, i);
-		saveImage(fname, dims.iProjV, dims.iProjU, bufp, fMin, fMax);
-	}
-}
-
-
-
-
-int main()
-{
-#if 0
-	SDimensions3D dims;
-	dims.iVolX = 512;
-	dims.iVolY = 512;
-	dims.iVolZ = 512;
-	dims.iProjAngles = 180;
-	dims.iProjU = 1024;
-	dims.iProjV = 1024;
-	dims.iRaysPerDet = 1;
-
-	cudaExtent extentV;
-	extentV.width = dims.iVolX*sizeof(float);
-	extentV.height = dims.iVolY;
-	extentV.depth = dims.iVolZ;
-
-	cudaPitchedPtr volData; // pitch, ptr, xsize, ysize
-
-	cudaMalloc3D(&volData, extentV);
-
-	cudaExtent extentP;
-	extentP.width = dims.iProjU*sizeof(float);
-	extentP.height = dims.iProjAngles;
-	extentP.depth = dims.iProjV;
-
-	cudaPitchedPtr projData; // pitch, ptr, xsize, ysize
-
-	cudaMalloc3D(&projData, extentP);
-	cudaMemset3D(projData, 0, extentP);
-
-#if 0
-	float* slice = new float[256*256];
-	cudaPitchedPtr ptr;
-	ptr.ptr = slice;
-	ptr.pitch = 256*sizeof(float);
-	ptr.xsize = 256*sizeof(float);
-	ptr.ysize = 256;
-
-	for (unsigned int i = 0; i < 256*256; ++i)
-		slice[i] = 1.0f;
-	for (unsigned int i = 0; i < 256; ++i) {
-		cudaExtent extentS;
-		extentS.width = dims.iVolX*sizeof(float);
-		extentS.height = dims.iVolY;
-		extentS.depth = 1;
-		cudaPos sp = { 0, 0, 0 };
-		cudaPos dp = { 0, 0, i };
-		cudaMemcpy3DParms p;
-		p.srcArray = 0;
-		p.srcPos = sp;
-		p.srcPtr = ptr;
-		p.dstArray = 0;
-		p.dstPos = dp;
-		p.dstPtr = volData;
-		p.extent = extentS;
-		p.kind = cudaMemcpyHostToDevice;
-		cudaMemcpy3D(&p);
-#if 0
-		if (i == 128) {
-			for (unsigned int j = 0; j < 256*256; ++j)
-				slice[j] = 0.0f;
-		}
-#endif 
-	}
-#endif
-
-	SConeProjection angle[180];
-	angle[0].fSrcX = -1536;
-	angle[0].fSrcY = 0;
-	angle[0].fSrcZ = 0;
-
-	angle[0].fDetSX = 1024;
-	angle[0].fDetSY = -512;
-	angle[0].fDetSZ = 512;
-
-	angle[0].fDetUX = 0;
-	angle[0].fDetUY = 1;
-	angle[0].fDetUZ = 0;
-
-	angle[0].fDetVX = 0;
-	angle[0].fDetVY = 0;
-	angle[0].fDetVZ = -1;
-
-#define ROTATE0(name,i,alpha) do { angle[i].f##name##X = angle[0].f##name##X * cos(alpha) - angle[0].f##name##Y * sin(alpha); angle[i].f##name##Y = angle[0].f##name##X * sin(alpha) + angle[0].f##name##Y * cos(alpha); } while(0)
-	for (int i = 1; i < 180; ++i) {
-		angle[i] = angle[0];
-		ROTATE0(Src, i, i*2*M_PI/180);
-		ROTATE0(DetS, i, i*2*M_PI/180);
-		ROTATE0(DetU, i, i*2*M_PI/180);
-		ROTATE0(DetV, i, i*2*M_PI/180);
-	}
-#undef ROTATE0
-
-	astraCUDA3d::ConeFP(volData, projData, dims, angle, 1.0f);
-
-	//dumpSinograms("sino%03d.png", projData, dims, 0, 512);
-	//dumpProjections("proj%03d.png", projData, dims, 0, 512);
-
-	astraCUDA3d::zeroVolumeData(volData, dims);
-
-	float* angles = new float[dims.iProjAngles];
-	for (int i = 0; i < 180; ++i)
-		angles[i] = i*2*M_PI/180;
-
-	astraCUDA3d::FDK(volData, projData, 1536, 512, 0, 0, dims, angles);
-
-	dumpVolume("vol%03d.png", volData, dims, -20, 100);
-
-
-#else
-
-	SDimensions3D dims;
-	dims.iVolX = 1000;
-	dims.iVolY = 999;
-	dims.iVolZ = 500;
-	dims.iProjAngles = 376;
-	dims.iProjU = 1024;
-	dims.iProjV = 524;
-	dims.iRaysPerDet = 1;
-
-	float* angles = new float[dims.iProjAngles];
-	for (int i = 0; i < dims.iProjAngles; ++i)
-		angles[i] = -i*(M_PI)/360;
-
-	cudaPitchedPtr volData = astraCUDA3d::allocateVolumeData(dims);
-	cudaPitchedPtr projData = astraCUDA3d::allocateProjectionData(dims);
-	astraCUDA3d::zeroProjectionData(projData, dims);
-	astraCUDA3d::zeroVolumeData(volData, dims);
-
-	timeval t;
-	tic(t);
-
-	for (int i = 0; i < dims.iProjAngles; ++i) {
-		char fname[256];
-		sprintf(fname, "/home/wpalenst/tmp/Elke/proj%04d.png", i);
-		unsigned int w,h;
-		float* bufp = loadImage(fname, w,h);
-
-		int pitch = projData.pitch / sizeof(float);
-		for (int j = 0; j < dims.iProjV; ++j) {
-			cudaMemcpy(((float*)projData.ptr)+dims.iProjAngles*pitch*j+pitch*i, bufp+dims.iProjU*j, dims.iProjU*sizeof(float), cudaMemcpyHostToDevice);
-		}
-
-		delete[] bufp;
-	}
-	printf("Load time: %f\n", toc(t));
-
-	//dumpSinograms("sino%03d.png", projData, dims, -8.0f, 256.0f);
-	//astraCUDA3d::FDK(volData, projData, 7350, 62355, 0, 10, dims, angles);
-	//astraCUDA3d::FDK(volData, projData, 7350, -380, 0, 10, dims, angles);
-
-	tic(t);
-
-	astraCUDA3d::FDK(volData, projData, 7383.29867, 0, 0, 10, dims, angles);
-
-	printf("FDK time: %f\n", toc(t));
-	tic(t);
-
-	dumpVolume("vol%03d.png", volData, dims, -65.9f, 200.0f);
-	//dumpVolume("vol%03d.png", volData, dims, 0.0f, 256.0f);
-	printf("Save time: %f\n", toc(t));
-
-#endif
-
-
-}
-#endif
diff --git a/cuda/3d/mem3d.cu b/cuda/3d/mem3d.cu
index 697d2d2..50cfe75 100644
--- a/cuda/3d/mem3d.cu
+++ b/cuda/3d/mem3d.cu
@@ -268,7 +268,7 @@ bool FP(const astra::CProjectionGeometry3D* pProjGeom, MemHandle3D projData, con
 	return ok;
 }
 
-bool BP(const astra::CProjectionGeometry3D* pProjGeom, MemHandle3D projData, const astra::CVolumeGeometry3D* pVolGeom, MemHandle3D volData, int iVoxelSuperSampling, bool bFDKWeighting)
+bool BP(const astra::CProjectionGeometry3D* pProjGeom, MemHandle3D projData, const astra::CVolumeGeometry3D* pVolGeom, MemHandle3D volData, int iVoxelSuperSampling)
 {
 	assert(!volData.d->arr);
 	SDimensions3D dims;
@@ -289,7 +289,7 @@ bool BP(const astra::CProjectionGeometry3D* pProjGeom, MemHandle3D projData, con
 	                          pParProjs, pConeProjs,
 	                          params);
 
-	params.bFDKWeighting = bFDKWeighting;
+	params.bFDKWeighting = false;
 
 	if (pParProjs) {
 		if (projData.d->arr)
diff --git a/cuda/3d/par3d_bp.cu b/cuda/3d/par3d_bp.cu
index 3656f78..602f209 100644
--- a/cuda/3d/par3d_bp.cu
+++ b/cuda/3d/par3d_bp.cu
@@ -28,11 +28,6 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
 #include "astra/cuda/3d/util3d.h"
 #include "astra/cuda/3d/dims3d.h"
 
-#ifdef STANDALONE
-#include "astra/cuda/3d/par3d_fp.h"
-#include "testutil.h"
-#endif
-
 #include <cstdio>
 #include <cassert>
 #include <iostream>
@@ -55,7 +50,13 @@ static const unsigned int g_volBlockY = 32;
 
 static const unsigned g_MaxAngles = 1024;
 
-__constant__ float gC_C[8*g_MaxAngles];
+struct DevPar3DParams {
+	float4 fNumU;
+	float4 fNumV;
+};
+
+__constant__ DevPar3DParams gC_C[g_MaxAngles];
+__constant__ float gC_scale[g_MaxAngles];
 
 
 static bool bindProjDataTexture(const cudaArray* array)
@@ -115,8 +116,9 @@ __global__ void dev_par3D_BP(void* D_volData, unsigned int volPitch, int startAn
 		for (int angle = startAngle; angle < endAngle; ++angle, fAngle += 1.0f)
 		{
 
-			float4 fCu = make_float4(gC_C[8*angle+0], gC_C[8*angle+1], gC_C[8*angle+2], gC_C[8*angle+3]);
-			float4 fCv = make_float4(gC_C[8*angle+4], gC_C[8*angle+5], gC_C[8*angle+6], gC_C[8*angle+7]);
+			float4 fCu = gC_C[angle].fNumU;
+			float4 fCv = gC_C[angle].fNumV;
+			float fS = gC_scale[angle];
 
 			float fU = fCu.w + fX * fCu.x + fY * fCu.y + fZ * fCu.z;
 			float fV = fCv.w + fX * fCv.x + fY * fCv.y + fZ * fCv.z;
@@ -124,7 +126,7 @@ __global__ void dev_par3D_BP(void* D_volData, unsigned int volPitch, int startAn
 			for (int idx = 0; idx < ZSIZE; ++idx) {
 
 				float fVal = tex3D(gT_par3DProjTexture, fU, fAngle, fV);
-				Z[idx] += fVal;
+				Z[idx] += fVal * fS;
 
 				fU += fCu.z;
 				fV += fCv.z;
@@ -190,14 +192,9 @@ __global__ void dev_par3D_BP_SS(void* D_volData, unsigned int volPitch, int star
 
 		for (int angle = startAngle; angle < endAngle; ++angle, fAngle += 1.0f)
 		{
-			const float fCux = gC_C[8*angle+0];
-			const float fCuy = gC_C[8*angle+1];
-			const float fCuz = gC_C[8*angle+2];
-			const float fCuc = gC_C[8*angle+3];
-			const float fCvx = gC_C[8*angle+4];
-			const float fCvy = gC_C[8*angle+5];
-			const float fCvz = gC_C[8*angle+6];
-			const float fCvc = gC_C[8*angle+7];
+			float4 fCu = gC_C[angle].fNumU;
+			float4 fCv = gC_C[angle].fNumV;
+			float fS = gC_scale[angle];
 
 			float fXs = fX;
 			for (int iSubX = 0; iSubX < iRaysPerVoxelDim; ++iSubX) {
@@ -206,10 +203,10 @@ __global__ void dev_par3D_BP_SS(void* D_volData, unsigned int volPitch, int star
 			float fZs = fZ;
 			for (int iSubZ = 0; iSubZ < iRaysPerVoxelDim; ++iSubZ) {
 
-				const float fU = fCuc + fXs * fCux + fYs * fCuy + fZs * fCuz;
-				const float fV = fCvc + fXs * fCvx + fYs * fCvy + fZs * fCvz;
+				const float fU = fCu.w + fXs * fCu.x + fYs * fCu.y + fZs * fCu.z;
+				const float fV = fCv.w + fXs * fCv.x + fYs * fCv.y + fZs * fCv.z;
 
-				fVal += tex3D(gT_par3DProjTexture, fU, fAngle, fV);
+				fVal += tex3D(gT_par3DProjTexture, fU, fAngle, fV) * fS;
 				fZs += fSubStep;
 			}
 			fYs += fSubStep;
@@ -224,6 +221,35 @@ __global__ void dev_par3D_BP_SS(void* D_volData, unsigned int volPitch, int star
 
 }
 
+bool transferConstants(const SPar3DProjection* angles, unsigned int iProjAngles, const SProjectorParams3D& params)
+{
+	DevPar3DParams *p = new DevPar3DParams[iProjAngles];
+	float *s = new float[iProjAngles];
+
+	for (unsigned int i = 0; i < iProjAngles; ++i) {
+		Vec3 u(angles[i].fDetUX, angles[i].fDetUY, angles[i].fDetUZ);
+		Vec3 v(angles[i].fDetVX, angles[i].fDetVY, angles[i].fDetVZ);
+		Vec3 r(angles[i].fRayX, angles[i].fRayY, angles[i].fRayZ);
+		Vec3 d(angles[i].fDetSX, angles[i].fDetSY, angles[i].fDetSZ);
+
+		double fDen = det3(r,u,v);
+		p[i].fNumU.x = -det3x(r,v) / fDen;
+		p[i].fNumU.y = -det3y(r,v) / fDen;
+		p[i].fNumU.z = -det3z(r,v) / fDen;
+		p[i].fNumU.w = -det3(r,d,v) / fDen;
+		p[i].fNumV.x = det3x(r,u) / fDen;
+		p[i].fNumV.y = det3y(r,u) / fDen;
+		p[i].fNumV.z = det3z(r,u) / fDen;
+		p[i].fNumV.w = det3(r,d,u) / fDen;
+
+		s[i] = 1.0 / scaled_cross3(u,v,Vec3(params.fVolScaleX,params.fVolScaleY,params.fVolScaleZ)).norm();
+	}
+
+	cudaMemcpyToSymbol(gC_C, p, iProjAngles*sizeof(DevPar3DParams), 0, cudaMemcpyHostToDevice);
+	cudaMemcpyToSymbol(gC_scale, s, iProjAngles*sizeof(float), 0, cudaMemcpyHostToDevice);
+	return true;
+}
+
 bool Par3DBP_Array(cudaPitchedPtr D_volumeData,
                    cudaArray *D_projArray,
                    const SDimensions3D& dims, const SPar3DProjection* angles,
@@ -238,33 +264,9 @@ bool Par3DBP_Array(cudaPitchedPtr D_volumeData,
 		if (th + angleCount > dims.iProjAngles)
 			angleCount = dims.iProjAngles - th;
 
-		// transfer angles to constant memory
-		float* tmp = new float[8*dims.iProjAngles];
-
-		// NB: We increment angles at the end of the loop body.
-
-
-		// TODO: Use functions from dims3d.cu for this:
-
-#define TRANSFER_TO_CONSTANT(expr,name) do { for (unsigned int i = 0; i < angleCount; ++i) tmp[8*i + name] = (expr) ; } while (0)
-
-#define DENOM (angles[i].fRayX*angles[i].fDetUY*angles[i].fDetVZ - angles[i].fRayX*angles[i].fDetUZ*angles[i].fDetVY - angles[i].fRayY*angles[i].fDetUX*angles[i].fDetVZ + angles[i].fRayY*angles[i].fDetUZ*angles[i].fDetVX + angles[i].fRayZ*angles[i].fDetUX*angles[i].fDetVY - angles[i].fRayZ*angles[i].fDetUY*angles[i].fDetVX)
-
-		TRANSFER_TO_CONSTANT( ( - (angles[i].fRayY*angles[i].fDetVZ - angles[i].fRayZ*angles[i].fDetVY)) / DENOM , 0 );
-		TRANSFER_TO_CONSTANT( ( (angles[i].fRayX*angles[i].fDetVZ - angles[i].fRayZ*angles[i].fDetVX)) / DENOM , 1 );
-		TRANSFER_TO_CONSTANT( (- (angles[i].fRayX*angles[i].fDetVY - angles[i].fRayY*angles[i].fDetVX) ) / DENOM , 2 );
-		TRANSFER_TO_CONSTANT( (-(angles[i].fDetSY*angles[i].fDetVZ - angles[i].fDetSZ*angles[i].fDetVY)*angles[i].fRayX + (angles[i].fRayY*angles[i].fDetVZ - angles[i].fRayZ*angles[i].fDetVY)*angles[i].fDetSX - (angles[i].fRayY*angles[i].fDetSZ - angles[i].fRayZ*angles[i].fDetSY)*angles[i].fDetVX) / DENOM , 3 );
-
-		TRANSFER_TO_CONSTANT( ((angles[i].fRayY*angles[i].fDetUZ - angles[i].fRayZ*angles[i].fDetUY) ) / DENOM , 4 );
-		TRANSFER_TO_CONSTANT( (- (angles[i].fRayX*angles[i].fDetUZ - angles[i].fRayZ*angles[i].fDetUX) ) / DENOM , 5 );
-		TRANSFER_TO_CONSTANT( ((angles[i].fRayX*angles[i].fDetUY - angles[i].fRayY*angles[i].fDetUX) ) / DENOM , 6 );
-		TRANSFER_TO_CONSTANT( ((angles[i].fDetSY*angles[i].fDetUZ - angles[i].fDetSZ*angles[i].fDetUY)*angles[i].fRayX - (angles[i].fRayY*angles[i].fDetUZ - angles[i].fRayZ*angles[i].fDetUY)*angles[i].fDetSX + (angles[i].fRayY*angles[i].fDetSZ - angles[i].fRayZ*angles[i].fDetSY)*angles[i].fDetUX ) / DENOM , 7 );
-
-#undef TRANSFER_TO_CONSTANT
-#undef DENOM
-		cudaMemcpyToSymbol(gC_C, tmp, angleCount*8*sizeof(float), 0, cudaMemcpyHostToDevice); 
-
-		delete[] tmp;
+		bool ok = transferConstants(angles, dims.iProjAngles, params);
+		if (!ok)
+			return false;
 
 		dim3 dimBlock(g_volBlockX, g_volBlockY);
 
@@ -310,161 +312,3 @@ bool Par3DBP(cudaPitchedPtr D_volumeData,
 
 
 }
-
-#ifdef STANDALONE
-int main()
-{
-	SDimensions3D dims;
-	dims.iVolX = 256;
-	dims.iVolY = 256;
-	dims.iVolZ = 256;
-	dims.iProjAngles = 180;
-	dims.iProjU = 512;
-	dims.iProjV = 512;
-	dims.iRaysPerDet = 1;
-
-	cudaExtent extentV;
-	extentV.width = dims.iVolX*sizeof(float);
-	extentV.height = dims.iVolY;
-	extentV.depth = dims.iVolZ;
-
-	cudaPitchedPtr volData; // pitch, ptr, xsize, ysize
-
-	cudaMalloc3D(&volData, extentV);
-
-	cudaExtent extentP;
-	extentP.width = dims.iProjU*sizeof(float);
-	extentP.height = dims.iProjAngles;
-	extentP.depth = dims.iProjV;
-
-	cudaPitchedPtr projData; // pitch, ptr, xsize, ysize
-
-	cudaMalloc3D(&projData, extentP);
-	cudaMemset3D(projData, 0, extentP);
-
-	float* slice = new float[256*256];
-	cudaPitchedPtr ptr;
-	ptr.ptr = slice;
-	ptr.pitch = 256*sizeof(float);
-	ptr.xsize = 256*sizeof(float);
-	ptr.ysize = 256;
-
-	for (unsigned int i = 0; i < 256*256; ++i)
-		slice[i] = 1.0f;
-	for (unsigned int i = 0; i < 256; ++i) {
-		cudaExtent extentS;
-		extentS.width = dims.iVolX*sizeof(float);
-		extentS.height = dims.iVolY;
-		extentS.depth = 1;
-		cudaPos sp = { 0, 0, 0 };
-		cudaPos dp = { 0, 0, i };
-		cudaMemcpy3DParms p;
-		p.srcArray = 0;
-		p.srcPos = sp;
-		p.srcPtr = ptr;
-		p.dstArray = 0;
-		p.dstPos = dp;
-		p.dstPtr = volData;
-		p.extent = extentS;
-		p.kind = cudaMemcpyHostToDevice;
-		cudaMemcpy3D(&p);
-#if 0
-		if (i == 128) {
-			for (unsigned int j = 0; j < 256*256; ++j)
-				slice[j] = 0.0f;
-		}
-#endif 
-	}
-
-
-	SPar3DProjection angle[180];
-	angle[0].fRayX = 1;
-	angle[0].fRayY = 0;
-	angle[0].fRayZ = 0;
-
-	angle[0].fDetSX = 512;
-	angle[0].fDetSY = -256;
-	angle[0].fDetSZ = -256;
-
-	angle[0].fDetUX = 0;
-	angle[0].fDetUY = 1;
-	angle[0].fDetUZ = 0;
-
-	angle[0].fDetVX = 0;
-	angle[0].fDetVY = 0;
-	angle[0].fDetVZ = 1;
-
-#define ROTATE0(name,i,alpha) do { angle[i].f##name##X = angle[0].f##name##X * cos(alpha) - angle[0].f##name##Y * sin(alpha); angle[i].f##name##Y = angle[0].f##name##X * sin(alpha) + angle[0].f##name##Y * cos(alpha); } while(0)
-	for (int i = 1; i < 180; ++i) {
-		angle[i] = angle[0];
-		ROTATE0(Ray, i, i*2*M_PI/180);
-		ROTATE0(DetS, i, i*2*M_PI/180);
-		ROTATE0(DetU, i, i*2*M_PI/180);
-		ROTATE0(DetV, i, i*2*M_PI/180);
-	}
-#undef ROTATE0
-
-	astraCUDA3d::Par3DFP(volData, projData, dims, angle, 1.0f);
-#if 1
-	float* bufs = new float[180*512];
-
-	for (int i = 0; i < 512; ++i) {
-		cudaMemcpy(bufs, ((float*)projData.ptr)+180*512*i, 180*512*sizeof(float), cudaMemcpyDeviceToHost);
-
-		printf("%d %d %d\n", projData.pitch, projData.xsize, projData.ysize);
-
-		char fname[20];
-		sprintf(fname, "sino%03d.png", i);
-		saveImage(fname, 180, 512, bufs, 0, 512);
-	}
-
-	float* bufp = new float[512*512];
-
-	for (int i = 0; i < 180; ++i) {
-		for (int j = 0; j < 512; ++j) {
-			cudaMemcpy(bufp+512*j, ((float*)projData.ptr)+180*512*j+512*i, 512*sizeof(float), cudaMemcpyDeviceToHost);
-		}
-
-		char fname[20];
-		sprintf(fname, "proj%03d.png", i);
-		saveImage(fname, 512, 512, bufp, 0, 512);
-	}
-#endif		
-	for (unsigned int i = 0; i < 256*256; ++i)
-		slice[i] = 0.0f;
-	for (unsigned int i = 0; i < 256; ++i) {
-		cudaExtent extentS;
-		extentS.width = dims.iVolX*sizeof(float);
-		extentS.height = dims.iVolY;
-		extentS.depth = 1;
-		cudaPos sp = { 0, 0, 0 };
-		cudaPos dp = { 0, 0, i };
-		cudaMemcpy3DParms p;
-		p.srcArray = 0;
-		p.srcPos = sp;
-		p.srcPtr = ptr;
-		p.dstArray = 0;
-		p.dstPos = dp;
-		p.dstPtr = volData;
-		p.extent = extentS;
-		p.kind = cudaMemcpyHostToDevice;
-		cudaMemcpy3D(&p);
-	}
-
-	astraCUDA3d::Par3DBP(volData, projData, dims, angle, 1.0f);
-#if 1
-	float* buf = new float[256*256];
-
-	for (int i = 0; i < 256; ++i) {
-		cudaMemcpy(buf, ((float*)volData.ptr)+256*256*i, 256*256*sizeof(float), cudaMemcpyDeviceToHost);
-
-		printf("%d %d %d\n", volData.pitch, volData.xsize, volData.ysize);
-
-		char fname[20];
-		sprintf(fname, "vol%03d.png", i);
-		saveImage(fname, 256, 256, buf, 0, 60000);
-	}
-#endif
-
-}
-#endif
diff --git a/cuda/3d/par3d_fp.cu b/cuda/3d/par3d_fp.cu
index 515b1ba..0a4a5cc 100644
--- a/cuda/3d/par3d_fp.cu
+++ b/cuda/3d/par3d_fp.cu
@@ -28,11 +28,6 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
 #include "astra/cuda/3d/util3d.h"
 #include "astra/cuda/3d/dims3d.h"
 
-#ifdef STANDALONE
-#include "testutil.h"
-#endif
-
-
 #include <cstdio>
 #include <cassert>
 #include <iostream>
@@ -751,166 +746,3 @@ bool Par3DFP_SumSqW(cudaPitchedPtr D_volumeData,
 
 
 }
-
-#ifdef STANDALONE
-
-using namespace astraCUDA3d;
-
-int main()
-{
-	cudaSetDevice(1);
-
-
-	SDimensions3D dims;
-	dims.iVolX = 500;
-	dims.iVolY = 500;
-	dims.iVolZ = 81;
-	dims.iProjAngles = 241;
-	dims.iProjU = 600;
-	dims.iProjV = 100;
-	dims.iRaysPerDet = 1;
-
-	SPar3DProjection base;
-	base.fRayX = 1.0f;
-	base.fRayY = 0.0f;
-	base.fRayZ = 0.1f;
-
-	base.fDetSX = 0.0f;
-	base.fDetSY = -300.0f;
-	base.fDetSZ = -50.0f;
-
-	base.fDetUX = 0.0f;
-	base.fDetUY = 1.0f;
-	base.fDetUZ = 0.0f;
-
-	base.fDetVX = 0.0f;
-	base.fDetVY = 0.0f;
-	base.fDetVZ = 1.0f;
-
-	SPar3DProjection angle[dims.iProjAngles];
-
-	cudaPitchedPtr volData; // pitch, ptr, xsize, ysize
-
-	volData = allocateVolumeData(dims);
-
-	cudaPitchedPtr projData; // pitch, ptr, xsize, ysize
-
-	projData = allocateProjectionData(dims);
-
-	unsigned int ix = 500,iy = 500;
-
-	float* buf = new float[dims.iProjU*dims.iProjV];
-
-	float* slice = new float[dims.iVolX*dims.iVolY];
-	for (int i = 0; i < dims.iVolX*dims.iVolY; ++i)
-		slice[i] = 1.0f;
-
-	for (unsigned int a = 0; a < 241; a += dims.iProjAngles) {
-
-		zeroProjectionData(projData, dims);
-
-		for (int y = 0; y < iy; y += dims.iVolY) {
-			for (int x = 0; x < ix; x += dims.iVolX) { 
-
-				timeval st;
-				tic(st);
-
-				for (int z = 0; z < dims.iVolZ; ++z) {
-//					char sfn[256];
-//					sprintf(sfn, "/home/wpalenst/projects/cone_simulation/phantom_4096/mouse_fem_phantom_%04d.png", 30+z);
-//					float* slice = loadSubImage(sfn, x, y, dims.iVolX, dims.iVolY);
-
-					cudaPitchedPtr ptr;
-					ptr.ptr = slice;
-					ptr.pitch = dims.iVolX*sizeof(float);
-					ptr.xsize = dims.iVolX*sizeof(float);
-					ptr.ysize = dims.iVolY;
-					cudaExtent extentS;
-					extentS.width = dims.iVolX*sizeof(float);
-					extentS.height = dims.iVolY;
-					extentS.depth = 1;
-
-					cudaPos sp = { 0, 0, 0 };
-					cudaPos dp = { 0, 0, z };
-					cudaMemcpy3DParms p;
-					p.srcArray = 0;
-					p.srcPos = sp;
-					p.srcPtr = ptr;
-					p.dstArray = 0;
-					p.dstPos = dp;
-					p.dstPtr = volData;
-					p.extent = extentS;
-					p.kind = cudaMemcpyHostToDevice;
-					cudaError err = cudaMemcpy3D(&p);
-					assert(!err);
-//					delete[] slice;
-				}
-
-				printf("Load: %f\n", toc(st));
-
-#if 0
-
-	cudaPos zp = { 0, 0, 0 };
-
-	cudaPitchedPtr t;
-	t.ptr = new float[1024*1024];
-	t.pitch = 1024*4;
-	t.xsize = 1024*4;
-	t.ysize = 1024;
-
-	cudaMemcpy3DParms p;
-	p.srcArray = 0;
-	p.srcPos = zp;
-	p.srcPtr = volData;
-	p.extent = extentS;
-	p.dstArray = 0;
-	p.dstPtr = t;
-	p.dstPos = zp;
-	p.kind = cudaMemcpyDeviceToHost;
-	cudaError err = cudaMemcpy3D(&p);
-	assert(!err);
-
-	char fn[32];
-	sprintf(fn, "t%d%d.png", x / dims.iVolX, y / dims.iVolY);
-	saveImage(fn, 1024, 1024, (float*)t.ptr);
-	saveImage("s.png", 4096, 4096, slice);
-	delete[] (float*)t.ptr;
-#endif
-
-
-#define ROTATE0(name,i,alpha) do { angle[i].f##name##X = base.f##name##X * cos(alpha) - base.f##name##Y * sin(alpha); angle[i].f##name##Y = base.f##name##X * sin(alpha) + base.f##name##Y * cos(alpha); angle[i].f##name##Z = base.f##name##Z; } while(0)
-#define SHIFT(name,i,x,y) do { angle[i].f##name##X += x; angle[i].f##name##Y += y; } while(0)
-				for (int i = 0; i < dims.iProjAngles; ++i) {
-					ROTATE0(Ray, i, (a+i)*.8*M_PI/180);
-					ROTATE0(DetS, i, (a+i)*.8*M_PI/180);
-					ROTATE0(DetU, i, (a+i)*.8*M_PI/180);
-					ROTATE0(DetV, i, (a+i)*.8*M_PI/180);
-
-
-//					SHIFT(Src, i, (-x+1536), (-y+1536));
-//					SHIFT(DetS, i, (-x+1536), (-y+1536));
-				}
-#undef ROTATE0
-#undef SHIFT
-				tic(st);
-
-				astraCUDA3d::Par3DFP(volData, projData, dims, angle, 1.0f);
-
-				printf("FP: %f\n", toc(st));
-
-			}
-		}
-		for (unsigned int aa = 0; aa < dims.iProjAngles; ++aa) {
-			for (unsigned int v = 0; v < dims.iProjV; ++v)
-				cudaMemcpy(buf+v*dims.iProjU, ((float*)projData.ptr)+(v*dims.iProjAngles+aa)*(projData.pitch/sizeof(float)), dims.iProjU*sizeof(float), cudaMemcpyDeviceToHost);
-
-			char fname[32];
-			sprintf(fname, "proj%03d.png", a+aa);
-			saveImage(fname, dims.iProjV, dims.iProjU, buf, 0.0f, 1000.0f);
-		}
-	}
-
-	delete[] buf;
-
-}
-#endif
diff --git a/cuda/3d/sirt3d.cu b/cuda/3d/sirt3d.cu
index 869b2fd..e68bde8 100644
--- a/cuda/3d/sirt3d.cu
+++ b/cuda/3d/sirt3d.cu
@@ -30,10 +30,6 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
 #include "astra/cuda/3d/arith3d.h"
 #include "astra/cuda/3d/cone_fp.h"
 
-#ifdef STANDALONE
-#include "testutil.h"
-#endif
-
 #include <cstdio>
 #include <cassert>
 
@@ -375,160 +371,3 @@ bool doSIRT(cudaPitchedPtr& D_volumeData,
 
 }
 
-#ifdef STANDALONE
-
-using namespace astraCUDA3d;
-
-int main()
-{
-	SDimensions3D dims;
-	dims.iVolX = 256;
-	dims.iVolY = 256;
-	dims.iVolZ = 256;
-	dims.iProjAngles = 100;
-	dims.iProjU = 512;
-	dims.iProjV = 512;
-	dims.iRaysPerDet = 1;
-
-	SConeProjection angle[100];
-	angle[0].fSrcX = -2905.6;
-	angle[0].fSrcY = 0;
-	angle[0].fSrcZ = 0;
-
-	angle[0].fDetSX = 694.4;
-	angle[0].fDetSY = -122.4704;
-	angle[0].fDetSZ = -122.4704;
-
-	angle[0].fDetUX = 0;
-	angle[0].fDetUY = .4784;
-	//angle[0].fDetUY = .5;
-	angle[0].fDetUZ = 0;
-
-	angle[0].fDetVX = 0;
-	angle[0].fDetVY = 0;
-	angle[0].fDetVZ = .4784;
-
-#define ROTATE0(name,i,alpha) do { angle[i].f##name##X = angle[0].f##name##X * cos(alpha) - angle[0].f##name##Y * sin(alpha); angle[i].f##name##Y = angle[0].f##name##X * sin(alpha) + angle[0].f##name##Y * cos(alpha); } while(0)
-	for (int i = 1; i < 100; ++i) {
-		angle[i] = angle[0];
-		ROTATE0(Src, i, i*2*M_PI/100);
-		ROTATE0(DetS, i, i*2*M_PI/100);
-		ROTATE0(DetU, i, i*2*M_PI/100);
-		ROTATE0(DetV, i, i*2*M_PI/100);
-	}
-#undef ROTATE0
-
-
-	cudaPitchedPtr volData = allocateVolumeData(dims);
-	cudaPitchedPtr projData = allocateProjectionData(dims);
-	zeroProjectionData(projData, dims);
-
-	float* pbuf = new float[100*512*512];
-	copyProjectionsFromDevice(pbuf, projData, dims);
-	copyProjectionsToDevice(pbuf, projData, dims);
-	delete[] pbuf;
-
-#if 0
-	float* slice = new float[256*256];
-	cudaPitchedPtr ptr;
-	ptr.ptr = slice;
-	ptr.pitch = 256*sizeof(float);
-	ptr.xsize = 256*sizeof(float);
-	ptr.ysize = 256;
-
-	for (unsigned int i = 0; i < 256; ++i) {
-		for (unsigned int y = 0; y < 256; ++y)
-			for (unsigned int x = 0; x < 256; ++x)
-				slice[y*256+x] = (i-127.5)*(i-127.5)+(y-127.5)*(y-127.5)+(x-127.5)*(x-127.5) < 4900 ? 1.0f : 0.0f;
-
-		cudaExtent extentS;
-		extentS.width = dims.iVolX*sizeof(float);
-		extentS.height = dims.iVolY;
-		extentS.depth = 1;
-		cudaPos sp = { 0, 0, 0 };
-		cudaPos dp = { 0, 0, i };
-		cudaMemcpy3DParms p;
-		p.srcArray = 0;
-		p.srcPos = sp;
-		p.srcPtr = ptr;
-		p.dstArray = 0;
-		p.dstPos = dp;
-		p.dstPtr = volData;
-		p.extent = extentS;
-		p.kind = cudaMemcpyHostToDevice;
-		cudaMemcpy3D(&p);
-	}
-	astraCUDA3d::ConeFP(volData, projData, dims, angle, 1.0f);
-
-#else
-
-	for (int i = 0; i < 100; ++i) {
-		char fname[32];
-		sprintf(fname, "Tiffs/%04d.png", 4*i);
-		unsigned int w,h;
-		float* bufp = loadImage(fname, w,h);
-
-		for (int j = 0; j < 512*512; ++j) {
-			float v = bufp[j];
-			if (v > 236.0f) v = 236.0f;
-			v = logf(236.0f / v);
-			bufp[j] = 256*v;
-		}
-
-		for (int j = 0; j < 512; ++j) {
-			cudaMemcpy(((float*)projData.ptr)+100*512*j+512*i, bufp+512*j, 512*sizeof(float), cudaMemcpyHostToDevice);
-		}
-
-		delete[] bufp;
-
-	}
-#endif
-
-#if 0
-	float* bufs = new float[100*512];
-
-	for (int i = 0; i < 512; ++i) {
-		cudaMemcpy(bufs, ((float*)projData.ptr)+100*512*i, 100*512*sizeof(float), cudaMemcpyDeviceToHost);
-
-		printf("%d %d %d\n", projData.pitch, projData.xsize, projData.ysize);
-
-		char fname[20];
-		sprintf(fname, "sino%03d.png", i);
-		saveImage(fname, 100, 512, bufs);
-	}
-
-	float* bufp = new float[512*512];
-
-	for (int i = 0; i < 100; ++i) {
-		for (int j = 0; j < 512; ++j) {
-			cudaMemcpy(bufp+512*j, ((float*)projData.ptr)+100*512*j+512*i, 512*sizeof(float), cudaMemcpyDeviceToHost);
-		}
-
-		char fname[20];
-		sprintf(fname, "proj%03d.png", i);
-		saveImage(fname, 512, 512, bufp);
-	}
-#endif
-
-	zeroVolumeData(volData, dims);
-
-	cudaPitchedPtr maskData;
-	maskData.ptr = 0;
-
-	astraCUDA3d::doSIRT(volData, projData, maskData, dims, angle, 50);
-#if 1
-	float* buf = new float[256*256];
-
-	for (int i = 0; i < 256; ++i) {
-		cudaMemcpy(buf, ((float*)volData.ptr)+256*256*i, 256*256*sizeof(float), cudaMemcpyDeviceToHost);
-
-		char fname[20];
-		sprintf(fname, "vol%03d.png", i);
-		saveImage(fname, 256, 256, buf);
-	}
-#endif
-
-	return 0;
-}
-#endif
-