Improve adjoint matching for fan/cone BP functions, and clean up

3 files changed, 251 insertions, 223 deletions

diff --git a/cuda/2d/fan_bp.cu b/cuda/2d/fan_bp.cu
index 428485c..d9d993b 100644
--- a/cuda/2d/fan_bp.cu
+++ b/cuda/2d/fan_bp.cu
@@ -48,15 +48,18 @@ const unsigned int g_anglesPerBlock = 16;
 const unsigned int g_blockSliceSize = 32;
 const unsigned int g_blockSlices = 16;
 
-const unsigned int g_MaxAngles = 2240;
+const unsigned int g_MaxAngles = 2560;
 
-__constant__ float gC_SrcX[g_MaxAngles];
-__constant__ float gC_SrcY[g_MaxAngles];
-__constant__ float gC_DetSX[g_MaxAngles];
-__constant__ float gC_DetSY[g_MaxAngles];
-__constant__ float gC_DetUX[g_MaxAngles];
-__constant__ float gC_DetUY[g_MaxAngles];
-__constant__ float gC_Scale[g_MaxAngles];
+struct DevFanParams {
+	float fNumC;
+	float fNumX;
+	float fNumY;
+	float fDenC;
+	float fDenX;
+	float fDenY;
+};
+
+__constant__ DevFanParams gC_C[g_MaxAngles];
 
 
 static bool bindProjDataTexture(float* data, unsigned int pitch, unsigned int width, unsigned int height, cudaTextureAddressMode mode = cudaAddressModeBorder)
@@ -75,6 +78,7 @@ static bool bindProjDataTexture(float* data, unsigned int pitch, unsigned int wi
 	return true;
 }
 
+template<bool FBPWEIGHT>
 __global__ void devFanBP(float* D_volData, unsigned int volPitch, unsigned int startAngle, const SDimensions dims, float fOutputScale)
 {
 	const int relX = threadIdx.x;
@@ -99,21 +103,14 @@ __global__ void devFanBP(float* D_volData, unsigned int volPitch, unsigned int s
 
 	for (int angle = startAngle; angle < endAngle; ++angle)
 	{
-		const float fSrcX = gC_SrcX[angle];
-		const float fSrcY = gC_SrcY[angle];
-		const float fDetSX = gC_DetSX[angle];
-		const float fDetSY = gC_DetSY[angle];
-		const float fDetUX = gC_DetUX[angle];
-		const float fDetUY = gC_DetUY[angle];
-		const float fScale = gC_Scale[angle];
-
-		const float fXD = fSrcX - fX;
-		const float fYD = fSrcY - fY;
+		const float fNumC = gC_C[angle].fNumC;
+		const float fNumX = gC_C[angle].fNumX;
+		const float fNumY = gC_C[angle].fNumY;
+		const float fDenX = gC_C[angle].fDenX;
+		const float fDenY = gC_C[angle].fDenY;
 
-		const float fNum = fDetSY * fXD - fDetSX * fYD + fX*fSrcY - fY*fSrcX;
-		const float fDen = fDetUX * fYD - fDetUY * fXD;
-
-		// fDen = || u (x-s) ||     (2x2 determinant)
+		const float fNum = fNumC + fNumX * fX + fNumY * fY;
+		const float fDen = (FBPWEIGHT ? 1.0 : gC_C[angle].fDenC) + fDenX * fX + fDenY * fY;
 
 		// Scale factor is the approximate number of rays traversing this pixel,
 		// given by the inverse size of a detector pixel scaled by the magnification
@@ -122,7 +119,7 @@ __global__ void devFanBP(float* D_volData, unsigned int volPitch, unsigned int s
 
 		const float fr = __fdividef(1.0f, fDen);
 		const float fT = fNum * fr;
-		fVal += tex2D(gT_FanProjTexture, fT, fA) * fScale * fr;
+		fVal += tex2D(gT_FanProjTexture, fT, fA) * (FBPWEIGHT ? fr * fr : fr);
 		fA += 1.0f;
 	}
 
@@ -158,28 +155,25 @@ __global__ void devFanBP_SS(float* D_volData, unsigned int volPitch, unsigned in
 
 	for (int angle = startAngle; angle < endAngle; ++angle)
 	{
-		const float fSrcX = gC_SrcX[angle];
-		const float fSrcY = gC_SrcY[angle];
-		const float fDetSX = gC_DetSX[angle];
-		const float fDetSY = gC_DetSY[angle];
-		const float fDetUX = gC_DetUX[angle];
-		const float fDetUY = gC_DetUY[angle];
-		const float fScale = gC_Scale[angle];
+		const float fNumC = gC_C[angle].fNumC;
+		const float fNumX = gC_C[angle].fNumX;
+		const float fNumY = gC_C[angle].fNumY;
+		const float fDenC = gC_C[angle].fDenC;
+		const float fDenX = gC_C[angle].fDenX;
+		const float fDenY = gC_C[angle].fDenY;
 
 		// TODO: Optimize these loops...
 		float fX = fXb;
 		for (int iSubX = 0; iSubX < dims.iRaysPerPixelDim; ++iSubX) {
 			float fY = fYb;
 			for (int iSubY = 0; iSubY < dims.iRaysPerPixelDim; ++iSubY) {
-				const float fXD = fSrcX - fX;
-				const float fYD = fSrcY - fY;
 
-				const float fNum = fDetSY * fXD - fDetSX * fYD + fX*fSrcY - fY*fSrcX;
-				const float fDen = fDetUX * fYD - fDetUY * fXD;
+				const float fNum = fNumC + fNumX * fX + fNumY * fY;
+				const float fDen = fDenC + fDenX * fX + fDenY * fY;
 				const float fr = __fdividef(1.0f, fDen);
 
 				const float fT = fNum * fr;
-				fVal += tex2D(gT_FanProjTexture, fT, fA) * fScale * fr;
+				fVal += tex2D(gT_FanProjTexture, fT, fA) * fr;
 				fY -= fSubStep;
 			}
 			fX += fSubStep;
@@ -210,79 +204,97 @@ __global__ void devFanBP_SART(float* D_volData, unsigned int volPitch, const SDi
 
 	float* volData = (float*)D_volData;
 
-	// TODO: Constant memory vs parameters.
-	const float fSrcX = gC_SrcX[0];
-	const float fSrcY = gC_SrcY[0];
-	const float fDetSX = gC_DetSX[0];
-	const float fDetSY = gC_DetSY[0];
-	const float fDetUX = gC_DetUX[0];
-	const float fDetUY = gC_DetUY[0];
-
-	// NB: The 'scale' constant in devBP is cancelled out by the SART weighting
+	const float fNumC = gC_C[0].fNumC;
+	const float fNumX = gC_C[0].fNumX;
+	const float fNumY = gC_C[0].fNumY;
+	const float fDenC = gC_C[0].fDenC;
+	const float fDenX = gC_C[0].fDenX;
+	const float fDenY = gC_C[0].fDenY;
 
-	const float fXD = fSrcX - fX;
-	const float fYD = fSrcY - fY;
+	const float fNum = fNumC + fNumX * fX + fNumY * fY;
+	const float fDen = fDenC + fDenX * fX + fDenY * fY;
 
-	const float fNum = fDetSY * fXD - fDetSX * fYD + fX*fSrcY - fY*fSrcX;
-	const float fDen = fDetUX * fYD - fDetUY * fXD;
-	const float fT = fNum / fDen;
+	const float fr = __fdividef(1.0f, fDen);
+	const float fT = fNum * fr;
+	// NB: The scale constant in devBP is cancelled out by the SART weighting
 	const float fVal = tex2D(gT_FanProjTexture, fT, 0.5f);
 
 	volData[Y*volPitch+X] += fVal * fOutputScale;
 }
 
-// Weighted BP for use in fan beam FBP
-// Each pixel/ray is weighted by 1/L^2 where L is the distance to the source.
-__global__ void devFanBP_FBPWeighted(float* D_volData, unsigned int volPitch, unsigned int startAngle, const SDimensions dims, float fOutputScale)
+struct Vec2 {
+	double x;
+	double y;
+	Vec2(double x_, double y_) : x(x_), y(y_) { }
+	Vec2 operator+(const Vec2 &b) const {
+		return Vec2(x + b.x, y + b.y);
+	}
+	Vec2 operator-(const Vec2 &b) const {
+		return Vec2(x - b.x, y - b.y);
+	}
+	Vec2 operator-() const {
+		return Vec2(-x, -y);
+	}
+	double norm() const {
+		return sqrt(x*x + y*y);
+	}
+};
+
+double det2(const Vec2 &a, const Vec2 &b) {
+	return a.x * b.y - a.y * b.x;
+}
+
+
+bool transferConstants(const SFanProjection* angles, unsigned int iProjAngles, bool FBP)
 {
-	const int relX = threadIdx.x;
-	const int relY = threadIdx.y;
+	DevFanParams *p = new DevFanParams[iProjAngles];
 
-	int endAngle = startAngle + g_anglesPerBlock;
-	if (endAngle > dims.iProjAngles)
-		endAngle = dims.iProjAngles;
-	const int X = blockIdx.x * g_blockSlices + relX;
-	const int Y = blockIdx.y * g_blockSliceSize + relY;
+	// We need three values in the kernel:
+	// projected coordinates of pixels on the detector:
+	// || x (s-d) || + ||s d|| / || u (s-x) ||
 
-	if (X >= dims.iVolWidth || Y >= dims.iVolHeight)
-		return;
+	// ray density weighting factor for the adjoint
+	// || u (s-d) || / ( |u| * || u (s-x) || )
 
-	const float fX = ( X - 0.5f*dims.iVolWidth + 0.5f );
-	const float fY = - ( Y - 0.5f*dims.iVolHeight + 0.5f );
+	// fan-beam FBP weighting factor
+	// ( || u s || / || u (s-x) || ) ^ 2
 
-	float* volData = (float*)D_volData;
 
-	float fVal = 0.0f;
-	float fA = startAngle + 0.5f;
 
-	// TODO: Update for new projection scaling
+	for (unsigned int i = 0; i < iProjAngles; ++i) {
+		Vec2 u(angles[i].fDetUX, angles[i].fDetUY);
+		Vec2 s(angles[i].fSrcX, angles[i].fSrcY);
+		Vec2 d(angles[i].fDetSX, angles[i].fDetSY);
 
-	for (int angle = startAngle; angle < endAngle; ++angle)
-	{
-		const float fSrcX = gC_SrcX[angle];
-		const float fSrcY = gC_SrcY[angle];
-		const float fDetSX = gC_DetSX[angle];
-		const float fDetSY = gC_DetSY[angle];
-		const float fDetUX = gC_DetUX[angle];
-		const float fDetUY = gC_DetUY[angle];
-
-		const float fXD = fSrcX - fX;
-		const float fYD = fSrcY - fY;
-
-		const float fNum = fDetSY * fXD - fDetSX * fYD + fX*fSrcY - fY*fSrcX;
-		const float fDen = fDetUX * fYD - fDetUY * fXD;
-		const float fr = __fdividef(1.0f, fDen);
 
-		// fDen = || u (x-s) ||
-		// Required scale factor is ( || u s || / || u (x-s) || ) ^ 2.
-		// The factor || u s || ^ 2 is handled by the preweighting
 
-		const float fT = fNum * fr;
-		fVal += tex2D(gT_FanProjTexture, fT, fA) * fr * fr;
-		fA += 1.0f;
+		double fScale;
+		if (!FBP) {
+			// goal: 1/fDen = || u (s-d) || / ( |u| * || u (s-x) || )
+			// fDen = ( |u| * || u (s-x) || ) / || u (s-d) ||
+			// i.e. scale = |u| /  || u (s-d) ||
+
+			fScale = u.norm() / det2(u, s-d);
+		} else {
+			// goal: 1/fDen = || u s || / || u (s-x) ||
+			// fDen = || u (s-x) || / || u s ||
+			// i.e., scale = 1 / || u s ||
+
+			fScale = 1.0 / det2(u, s);
+		}
+
+		p[i].fNumC = fScale * det2(s,d);
+		p[i].fNumX = fScale * (s-d).y;
+		p[i].fNumY = -fScale * (s-d).x;
+		p[i].fDenC = fScale * det2(u, s); // == 1.0 for FBP
+		p[i].fDenX = fScale * u.y;
+		p[i].fDenY = -fScale * u.x;
 	}
 
-	volData[Y*volPitch+X] += fVal * fOutputScale;
+	// TODO: Check for errors
+	cudaMemcpyToSymbol(gC_C, p, iProjAngles*sizeof(DevFanParams), 0, cudaMemcpyHostToDevice);
+
+	return true;
 }
 
 
@@ -295,28 +307,9 @@ bool FanBP_internal(float* D_volumeData, unsigned int volumePitch,
 
 	bindProjDataTexture(D_projData, projPitch, dims.iProjDets, dims.iProjAngles);
 
-	// transfer angles to constant memory
-	float* tmp = new float[dims.iProjAngles];
-
-#define TRANSFER_TO_CONSTANT(name) do { for (unsigned int i = 0; i < dims.iProjAngles; ++i) tmp[i] = angles[i].f##name ; cudaMemcpyToSymbol(gC_##name, tmp, dims.iProjAngles*sizeof(float), 0, cudaMemcpyHostToDevice); } while (0)
-
-	TRANSFER_TO_CONSTANT(SrcX);
-	TRANSFER_TO_CONSTANT(SrcY);
-	TRANSFER_TO_CONSTANT(DetSX);
-	TRANSFER_TO_CONSTANT(DetSY);
-	TRANSFER_TO_CONSTANT(DetUX);
-	TRANSFER_TO_CONSTANT(DetUY);
-
-#undef TRANSFER_TO_CONSTANT
-
-	for (unsigned int i = 0; i < dims.iProjAngles; ++i) {
-		double detsize = sqrt(angles[i].fDetUX * angles[i].fDetUX + angles[i].fDetUY * angles[i].fDetUY);
-		double scale = (angles[i].fDetUX * (angles[i].fSrcY - angles[i].fDetSY) - angles[i].fDetUY * (angles[i].fSrcX - angles[i].fDetSX)) / detsize;
-		tmp[i] = (float)scale;
-	}
-	cudaMemcpyToSymbol(gC_Scale, tmp, dims.iProjAngles*sizeof(float), 0, cudaMemcpyHostToDevice);
-
-	delete[] tmp;
+	bool ok = transferConstants(angles, dims.iProjAngles, false);
+	if (!ok)
+		return false;
 
 	dim3 dimBlock(g_blockSlices, g_blockSliceSize);
 	dim3 dimGrid((dims.iVolWidth+g_blockSlices-1)/g_blockSlices,
@@ -329,7 +322,7 @@ bool FanBP_internal(float* D_volumeData, unsigned int volumePitch,
 		if (dims.iRaysPerPixelDim > 1)
 			devFanBP_SS<<<dimGrid, dimBlock, 0, stream>>>(D_volumeData, volumePitch, i, dims, fOutputScale);
 		else
-			devFanBP<<<dimGrid, dimBlock, 0, stream>>>(D_volumeData, volumePitch, i, dims, fOutputScale);
+			devFanBP<false><<<dimGrid, dimBlock, 0, stream>>>(D_volumeData, volumePitch, i, dims, fOutputScale);
 	}
 	cudaThreadSynchronize();
 
@@ -349,29 +342,9 @@ bool FanBP_FBPWeighted_internal(float* D_volumeData, unsigned int volumePitch,
 
 	bindProjDataTexture(D_projData, projPitch, dims.iProjDets, dims.iProjAngles);
 
-	// transfer angles to constant memory
-	float* tmp = new float[dims.iProjAngles];
-
-#define TRANSFER_TO_CONSTANT(name) do { for (unsigned int i = 0; i < dims.iProjAngles; ++i) tmp[i] = angles[i].f##name ; cudaMemcpyToSymbol(gC_##name, tmp, dims.iProjAngles*sizeof(float), 0, cudaMemcpyHostToDevice); } while (0)
-
-	TRANSFER_TO_CONSTANT(SrcX);
-	TRANSFER_TO_CONSTANT(SrcY);
-	TRANSFER_TO_CONSTANT(DetSX);
-	TRANSFER_TO_CONSTANT(DetSY);
-	TRANSFER_TO_CONSTANT(DetUX);
-	TRANSFER_TO_CONSTANT(DetUY);
-
-#undef TRANSFER_TO_CONSTANT
-
-	for (unsigned int i = 0; i < dims.iProjAngles; ++i) {
-		double detsize = sqrt(angles[i].fDetUX * angles[i].fDetUX + angles[i].fDetUY * angles[i].fDetUY);
-		double scale = (angles[i].fDetUX * (angles[i].fSrcY - angles[i].fDetSY) - angles[i].fDetUY * (angles[i].fSrcX - angles[i].fDetSX)) / detsize;
-		tmp[i] = (float)scale;
-	}
-	cudaMemcpyToSymbol(gC_Scale, tmp, dims.iProjAngles*sizeof(float), 0, cudaMemcpyHostToDevice);
-
-
-	delete[] tmp;
+	bool ok = transferConstants(angles, dims.iProjAngles, true);
+	if (!ok)
+		return false;
 
 	dim3 dimBlock(g_blockSlices, g_blockSliceSize);
 	dim3 dimGrid((dims.iVolWidth+g_blockSlices-1)/g_blockSlices,
@@ -381,7 +354,7 @@ bool FanBP_FBPWeighted_internal(float* D_volumeData, unsigned int volumePitch,
 	cudaStreamCreate(&stream);
 
 	for (unsigned int i = 0; i < dims.iProjAngles; i += g_anglesPerBlock) {
-		devFanBP_FBPWeighted<<<dimGrid, dimBlock, 0, stream>>>(D_volumeData, volumePitch, i, dims, fOutputScale);
+		devFanBP<true><<<dimGrid, dimBlock, 0, stream>>>(D_volumeData, volumePitch, i, dims, fOutputScale);
 	}
 	cudaThreadSynchronize();
 
@@ -402,22 +375,9 @@ bool FanBP_SART(float* D_volumeData, unsigned int volumePitch,
 	// only one angle
 	bindProjDataTexture(D_projData, projPitch, dims.iProjDets, 1, cudaAddressModeClamp);
 
-	// transfer angle to constant memory
-#define TRANSFER_TO_CONSTANT(name) do { cudaMemcpyToSymbol(gC_##name, &(angles[angle].f##name), sizeof(float), 0, cudaMemcpyHostToDevice); } while (0)
-
-	TRANSFER_TO_CONSTANT(SrcX);
-	TRANSFER_TO_CONSTANT(SrcY);
-	TRANSFER_TO_CONSTANT(DetSX);
-	TRANSFER_TO_CONSTANT(DetSY);
-	TRANSFER_TO_CONSTANT(DetUX);
-	TRANSFER_TO_CONSTANT(DetUY);
-
-#undef TRANSFER_TO_CONSTANT
-
-	double detsize = sqrt(angles[angle].fDetUX * angles[angle].fDetUX + angles[angle].fDetUY * angles[angle].fDetUY);
-	double scale = (angles[angle].fDetUX * (angles[angle].fSrcY - angles[angle].fDetSY) - angles[angle].fDetUY * (angles[angle].fSrcX - angles[angle].fDetSX)) / detsize;
-	float tmp = (float)scale;
-	cudaMemcpyToSymbol(gC_Scale, &tmp, sizeof(float), 0, cudaMemcpyHostToDevice);
+	bool ok = transferConstants(angles + angle, 1, false);
+	if (!ok)
+		return false;
 
 	dim3 dimBlock(g_blockSlices, g_blockSliceSize);
 	dim3 dimGrid((dims.iVolWidth+g_blockSlices-1)/g_blockSlices,
diff --git a/cuda/3d/cone_bp.cu b/cuda/3d/cone_bp.cu
index 2a7ec80..a614c29 100644
--- a/cuda/3d/cone_bp.cu
+++ b/cuda/3d/cone_bp.cu
@@ -55,7 +55,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 +124,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,20 +140,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 magnification factor
-					// from fX,fY,fZ to the virtual detector, where the
-					// virtual detector is the plane through the origin
-					// parallel to the detector, so spanned by u,v.
-
-					// 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;
@@ -217,19 +207,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) {
@@ -238,14 +218,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;
 			}
@@ -260,6 +241,119 @@ __global__ void dev_cone_BP_SS(void* D_volData, unsigned int volPitch, int start
 	}
 }
 
+struct Vec3 {
+	double x;
+	double y;
+	double z;
+	Vec3(double x_, double y_, double z_) : x(x_), y(y_), z(z_) { }
+	Vec3 operator+(const Vec3 &b) const {
+		return Vec3(x + b.x, y + b.y, z + b.z);
+	}
+	Vec3 operator-(const Vec3 &b) const {
+		return Vec3(x - b.x, y - b.y, z - b.z);
+	}
+	Vec3 operator-() const {
+		return Vec3(-x, -y, -z);
+	}
+	double norm() const {
+		return sqrt(x*x + y*y + z*z);
+	}
+};
+
+double det3x(const Vec3 &b, const Vec3 &c) {
+	return (b.y * c.z - b.z * c.y);
+}
+double det3y(const Vec3 &b, const Vec3 &c) {
+	return -(b.x * c.z - b.z * c.x);
+}
+
+double det3z(const Vec3 &b, const Vec3 &c) {
+	return (b.x * c.y - b.y * c.x);
+}
+
+double det3(const Vec3 &a, const Vec3 &b, const Vec3 &c) {
+	return a.x * det3x(b,c) + a.y * det3y(b,c) + a.z * det3z(b,c);
+}
+
+Vec3 cross3(const Vec3 &a, const Vec3 &b) {
+	return Vec3(det3x(a,b), det3y(a,b), det3z(a,b));
+}
+
+Vec3 scaled_cross3(const Vec3 &a, const Vec3 &b, const Vec3 &sc) {
+	Vec3 ret = cross3(a, b);
+	ret.x *= sc.y * sc.z;
+	ret.y *= sc.x * sc.z;
+	ret.z *= sc.x * sc.y;
+	return ret;
+}
+
+
+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
+
+
+
+	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,
@@ -279,34 +373,9 @@ bool ConeBP_Array(cudaPitchedPtr D_volumeData,
 		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);
 
diff --git a/cuda/3d/fdk.cu b/cuda/3d/fdk.cu
index 1294721..92d3ef6 100644
--- a/cuda/3d/fdk.cu
+++ b/cuda/3d/fdk.cu
@@ -92,10 +92,9 @@ __global__ void devFDK_preweight(void* D_projData, unsigned int projPitch, unsig
 	// 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 * fW3 * (M_PI / 2.0f) / (float)dims.iProjAngles;
 
 	for (int detectorV = startDetectorV; detectorV < endDetectorV; ++detectorV)
 	{