From 64abe91dd26e98001f3f5c7cc73543f5f94cb80d Mon Sep 17 00:00:00 2001 From: Willem Jan Palenstijn Date: Wed, 3 Apr 2019 18:25:52 +0200 Subject: Improve adjoint matching for fan/cone BP functions, and clean up --- cuda/2d/fan_bp.cu | 264 +++++++++++++++++++++++------------------------------ cuda/3d/cone_bp.cu | 207 +++++++++++++++++++++++++++-------------- cuda/3d/fdk.cu | 3 +- 3 files changed, 251 insertions(+), 223 deletions(-) (limited to 'cuda') 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 __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<<>>(D_volumeData, volumePitch, i, dims, fOutputScale); else - devFanBP<<>>(D_volumeData, volumePitch, i, dims, fOutputScale); + devFanBP<<>>(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<<>>(D_volumeData, volumePitch, i, dims, fOutputScale); + devFanBP<<>>(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) { -- cgit v1.2.3