diff options
Diffstat (limited to 'include/astra/ParallelBeamLineKernelProjector2D.inl')
| -rw-r--r-- | include/astra/ParallelBeamLineKernelProjector2D.inl | 731 |
1 files changed, 731 insertions, 0 deletions
diff --git a/include/astra/ParallelBeamLineKernelProjector2D.inl b/include/astra/ParallelBeamLineKernelProjector2D.inl new file mode 100644 index 0000000..08bbe5f --- /dev/null +++ b/include/astra/ParallelBeamLineKernelProjector2D.inl @@ -0,0 +1,731 @@ +/* +----------------------------------------------------------------------- +Copyright 2012 iMinds-Vision Lab, University of Antwerp + +Contact: astra@ua.ac.be +Website: http://astra.ua.ac.be + + +This file is part of the +All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox"). + +The ASTRA Toolbox is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +The ASTRA Toolbox is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>. + +----------------------------------------------------------------------- +$Id$ +*/ + + + +//---------------------------------------------------------------------------------------- +// PROJECT ALL +template <typename Policy> +void CParallelBeamLineKernelProjector2D::project(Policy& p) +{ + // variables + float32 theta, sin_theta, cos_theta, inv_sin_theta, inv_cos_theta, S, T, t, I, P, x, x2; + float32 lengthPerRow, updatePerRow, inv_pixelLengthX, lengthPerCol, updatePerCol, inv_pixelLengthY; + int iVolumeIndex, iRayIndex, row, col, iAngle, iDetector, x1; + bool switch_t; + + // loop angles + for (iAngle = 0; iAngle < m_pProjectionGeometry->getProjectionAngleCount(); ++iAngle) { + + // get theta + theta = m_pProjectionGeometry->getProjectionAngle(iAngle); + switch_t = false; + if (theta >= 7*PIdiv4) theta -= 2*PI; + if (theta >= 3*PIdiv4) { + theta -= PI; + switch_t = true; + } + + // precalculate sin, cos, 1/cos + sin_theta = sin(theta); + cos_theta = cos(theta); + inv_sin_theta = 1.0f / sin_theta; + inv_cos_theta = 1.0f / cos_theta; + + // precalculate kernel limits + lengthPerRow = m_pVolumeGeometry->getPixelLengthY() * inv_cos_theta; + updatePerRow = sin_theta * inv_cos_theta; + inv_pixelLengthX = 1.0f / m_pVolumeGeometry->getPixelLengthX(); + + // precalculate kernel limits + lengthPerCol = m_pVolumeGeometry->getPixelLengthX() * inv_sin_theta; + updatePerCol = cos_theta * inv_sin_theta; + inv_pixelLengthY = 1.0f / m_pVolumeGeometry->getPixelLengthY(); + + // precalculate S and T + S = 0.5f - 0.5f * ((updatePerRow < 0) ? -updatePerRow : updatePerRow); + T = 0.5f - 0.5f * ((updatePerCol < 0) ? -updatePerCol : updatePerCol); + + // loop detectors + for (iDetector = 0; iDetector < m_pProjectionGeometry->getDetectorCount(); ++iDetector) { + + iRayIndex = iAngle * m_pProjectionGeometry->getDetectorCount() + iDetector; + + // POLICY: RAY PRIOR + if (!p.rayPrior(iRayIndex)) continue; + + // get t + t = m_pProjectionGeometry->indexToDetectorOffset(iDetector); + if (switch_t) t = -t; + + // vertically + if (theta <= PIdiv4) { + + // calculate x for row 0 + P = (t - sin_theta * m_pVolumeGeometry->pixelRowToCenterY(0)) * inv_cos_theta; + x = (P - m_pVolumeGeometry->getWindowMinX()) * inv_pixelLengthX; + + // get coords + int nextx1 = int((x > 0.0f) ? x : x-1.0f); + float nextx2 = x - nextx1; + + // for each row + for (row = 0; row < m_pVolumeGeometry->getGridRowCount(); ++row) { + + x1 = nextx1; + x2 = nextx2; + + nextx2 += updatePerRow; + while (nextx2 >= 1.0f) { + nextx2 -= 1.0f; + nextx1++; + } + while (nextx2 < 0.0f) { + nextx2 += 1.0f; + nextx1--; + } + + if (x1 < -1 || x1 > m_pVolumeGeometry->getGridColCount()) continue; + + // left + if (x2 < 0.5f-S) { + I = (0.5f - S + x2) / (1.0f - 2.0f*S) * lengthPerRow; + + if (x1-1 >= 0 && x1-1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1-1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerRow-I); + p.pixelPosterior(iVolumeIndex); + } + } + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // center + else if (x2 <= 0.5f+S) { + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerRow); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // right + else { + I = (1.5f - S - x2) / (1.0f - 2.0f*S) * lengthPerRow; + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + if (x1+1 >= 0 && x1+1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1+1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerRow-I); + p.pixelPosterior(iVolumeIndex); + } + } + } + } + } + + // horizontally + else if (PIdiv4 <= theta && theta <= 3*PIdiv4) { + + // calculate point P + P = (t - cos_theta * m_pVolumeGeometry->pixelColToCenterX(0)) * inv_sin_theta; + x = (m_pVolumeGeometry->getWindowMaxY() - P) * inv_pixelLengthY; + + // get coords + int nextx1 = int((x > 0.0f) ? x : x-1.0f); + float nextx2 = x - nextx1; + + // for each col + for (col = 0; col < m_pVolumeGeometry->getGridColCount(); ++col) { + + x1 = nextx1; + x2 = nextx2; + + nextx2 += updatePerCol; + while (nextx2 >= 1.0f) { + nextx2 -= 1.0f; + nextx1++; + } + while (nextx2 < 0.0f) { + nextx2 += 1.0f; + nextx1--; + } + + if (x1 < -1 || x1 > m_pVolumeGeometry->getGridRowCount()) continue; + + // up + if (x2 < 0.5f-T) { + I = (0.5f - T + x2) / (1.0f - 2.0f*T) * lengthPerCol; + + if (x1-1 >= 0 && x1-1 < m_pVolumeGeometry->getGridRowCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1-1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerCol-I); + p.pixelPosterior(iVolumeIndex); + } + } + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridRowCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // center + else if (x2 <= 0.5f+T) { + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridRowCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerCol); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // down + else { + I = (1.5f - T - x2) / (1.0f - 2.0f*T) * lengthPerCol; + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + if (x1+1 >= 0 && x1+1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1+1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerCol-I); + p.pixelPosterior(iVolumeIndex); + } + } + } + } + } // end loop col + + // POLICY: RAY POSTERIOR + p.rayPosterior(iRayIndex); + + } // end loop detector + } // end loop angles + +} + + +//---------------------------------------------------------------------------------------- +// PROJECT SINGLE PROJECTION +template <typename Policy> +void CParallelBeamLineKernelProjector2D::projectSingleProjection(int _iProjection, Policy& p) +{ + // variables + float32 theta, sin_theta, cos_theta, inv_sin_theta, inv_cos_theta, S, T, t, I, P, x, x2; + float32 lengthPerRow, updatePerRow, inv_pixelLengthX, lengthPerCol, updatePerCol, inv_pixelLengthY; + int iVolumeIndex, iRayIndex, row, col, iDetector, x1; + bool switch_t; + + // get theta + theta = m_pProjectionGeometry->getProjectionAngle(_iProjection); + switch_t = false; + if (theta >= 7*PIdiv4) theta -= 2*PI; + if (theta >= 3*PIdiv4) { + theta -= PI; + switch_t = true; + } + + // precalculate sin, cos, 1/cos + sin_theta = sin(theta); + cos_theta = cos(theta); + inv_sin_theta = 1.0f / sin_theta; + inv_cos_theta = 1.0f / cos_theta; + + // precalculate kernel limits + lengthPerRow = m_pVolumeGeometry->getPixelLengthY() * inv_cos_theta; + updatePerRow = sin_theta * inv_cos_theta; + inv_pixelLengthX = 1.0f / m_pVolumeGeometry->getPixelLengthX(); + + // precalculate kernel limits + lengthPerCol = m_pVolumeGeometry->getPixelLengthX() * inv_sin_theta; + updatePerCol = cos_theta * inv_sin_theta; + inv_pixelLengthY = 1.0f / m_pVolumeGeometry->getPixelLengthY(); + + // precalculate S and T + S = 0.5f - 0.5f * ((updatePerRow < 0) ? -updatePerRow : updatePerRow); + T = 0.5f - 0.5f * ((updatePerCol < 0) ? -updatePerCol : updatePerCol); + + // loop detectors + for (iDetector = 0; iDetector < m_pProjectionGeometry->getDetectorCount(); ++iDetector) { + + iRayIndex = _iProjection * m_pProjectionGeometry->getDetectorCount() + iDetector; + + // POLICY: RAY PRIOR + if (!p.rayPrior(iRayIndex)) continue; + + // get t + t = m_pProjectionGeometry->indexToDetectorOffset(iDetector); + if (switch_t) t = -t; + + // vertically + if (theta <= PIdiv4) { + + // calculate x for row 0 + P = (t - sin_theta * m_pVolumeGeometry->pixelRowToCenterY(0)) * inv_cos_theta; + x = (P - m_pVolumeGeometry->getWindowMinX()) * inv_pixelLengthX; + + // get coords + int nextx1 = int((x > 0.0f) ? x : x-1.0f); + float nextx2 = x - nextx1; + + // for each row + for (row = 0; row < m_pVolumeGeometry->getGridRowCount(); ++row) { + + x1 = nextx1; + x2 = nextx2; + + nextx2 += updatePerRow; + while (nextx2 >= 1.0f) { + nextx2 -= 1.0f; + nextx1++; + } + while (nextx2 < 0.0f) { + nextx2 += 1.0f; + nextx1--; + } + + if (x1 < -1 || x1 > m_pVolumeGeometry->getGridColCount()) continue; + + // left + if (x2 < 0.5f-S) { + I = (0.5f - S + x2) / (1.0f - 2.0f*S) * lengthPerRow; + + if (x1-1 >= 0 && x1-1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1-1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerRow-I); + p.pixelPosterior(iVolumeIndex); + } + } + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // center + else if (x2 <= 0.5f+S) { + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerRow); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // right + else { + I = (1.5f - S - x2) / (1.0f - 2.0f*S) * lengthPerRow; + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + if (x1+1 >= 0 && x1+1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1+1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerRow-I); + p.pixelPosterior(iVolumeIndex); + } + } + } + } + } + + // horizontally + else if (PIdiv4 <= theta && theta <= 3*PIdiv4) { + + // calculate point P + P = (t - cos_theta * m_pVolumeGeometry->pixelColToCenterX(0)) * inv_sin_theta; + x = (m_pVolumeGeometry->getWindowMaxY() - P) * inv_pixelLengthY; + + // get coords + int nextx1 = int((x > 0.0f) ? x : x-1.0f); + float nextx2 = x - nextx1; + + // for each col + for (col = 0; col < m_pVolumeGeometry->getGridColCount(); ++col) { + + x1 = nextx1; + x2 = nextx2; + + nextx2 += updatePerCol; + while (nextx2 >= 1.0f) { + nextx2 -= 1.0f; + nextx1++; + } + while (nextx2 < 0.0f) { + nextx2 += 1.0f; + nextx1--; + } + + if (x1 < -1 || x1 > m_pVolumeGeometry->getGridRowCount()) continue; + + // up + if (x2 < 0.5f-T) { + I = (0.5f - T + x2) / (1.0f - 2.0f*T) * lengthPerCol; + + if (x1-1 >= 0 && x1-1 < m_pVolumeGeometry->getGridRowCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1-1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerCol-I); + p.pixelPosterior(iVolumeIndex); + } + } + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridRowCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // center + else if (x2 <= 0.5f+T) { + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridRowCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerCol); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // down + else { + I = (1.5f - T - x2) / (1.0f - 2.0f*T) * lengthPerCol; + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + if (x1+1 >= 0 && x1+1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1+1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerCol-I); + p.pixelPosterior(iVolumeIndex); + } + } + } + } + } // end loop col + + // POLICY: RAY POSTERIOR + p.rayPosterior(iRayIndex); + + } // end loop detector +} + + + +//---------------------------------------------------------------------------------------- +// PROJECT SINGLE RAY +template <typename Policy> +void CParallelBeamLineKernelProjector2D::projectSingleRay(int _iProjection, int _iDetector, Policy& p) +{ + int iRayIndex = _iProjection * m_pProjectionGeometry->getDetectorCount() + _iDetector; + + // POLICY: RAY PRIOR + if (!p.rayPrior(iRayIndex)) return; + + // variables + float32 t, I, P, x, x2; + int iVolumeIndex, row, col, x1; + + // get theta + float32 theta = m_pProjectionGeometry->getProjectionAngle(_iProjection); + bool switch_t = false; + if (theta >= 7*PIdiv4) theta -= 2*PI; + if (theta >= 3*PIdiv4) { + theta -= PI; + switch_t = true; + } + + // get t + t = m_pProjectionGeometry->indexToDetectorOffset(_iDetector); + if (switch_t) t = -t; + + // vertically + if (theta <= PIdiv4) { + + float32 sin_theta = sin(theta); + float32 inv_cos_theta = 1.0f / cos(theta); + + // precalculate kernel limits + float32 lengthPerRow = m_pVolumeGeometry->getPixelLengthY() * inv_cos_theta; + float32 updatePerRow = sin_theta * inv_cos_theta; + float32 inv_pixelLengthX = 1.0f / m_pVolumeGeometry->getPixelLengthX(); + float32 S = 0.5f - 0.5f * ((updatePerRow < 0) ? -updatePerRow : updatePerRow); + + // calculate x for row 0 + P = (t - sin_theta * m_pVolumeGeometry->pixelRowToCenterY(0)) * inv_cos_theta; + x = (P - m_pVolumeGeometry->getWindowMinX()) * inv_pixelLengthX; + + // get coords + int nextx1 = int((x > 0.0f) ? x : x-1.0f); + float nextx2 = x - nextx1; + + // for each row + for (row = 0; row < m_pVolumeGeometry->getGridRowCount(); ++row) { + + x1 = nextx1; + x2 = nextx2; + + nextx2 += updatePerRow; + while (nextx2 >= 1.0f) { + nextx2 -= 1.0f; + nextx1++; + } + while (nextx2 < 0.0f) { + nextx2 += 1.0f; + nextx1--; + } + + if (x1 < -1 || x1 > m_pVolumeGeometry->getGridColCount()) continue; + + // left + if (x2 < 0.5f-S) { + I = (0.5f - S + x2) / (1.0f - 2.0f*S) * lengthPerRow; + + if (x1-1 >= 0 && x1-1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1-1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerRow-I); + p.pixelPosterior(iVolumeIndex); + } + } + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // center + else if (x2 <= 0.5f+S) { + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerRow); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // right + else { + I = (1.5f - S - x2) / (1.0f - 2.0f*S) * lengthPerRow; + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + if (x1+1 >= 0 && x1+1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(row, x1+1); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerRow-I); + p.pixelPosterior(iVolumeIndex); + } + } + } + } + } + + // horizontally + else if (PIdiv4 <= theta && theta <= 3*PIdiv4) { + + float32 cos_theta = cos(theta); + float32 inv_sin_theta = 1.0f / sin(theta); + + // precalculate kernel limits + float32 lengthPerCol = m_pVolumeGeometry->getPixelLengthX() * inv_sin_theta; + float32 updatePerCol = cos_theta * inv_sin_theta; + float32 inv_pixelLengthY = 1.0f / m_pVolumeGeometry->getPixelLengthY(); + float32 T = 0.5f - 0.5f * ((updatePerCol < 0) ? -updatePerCol : updatePerCol); + + // calculate point P + P = (t - cos_theta * m_pVolumeGeometry->pixelColToCenterX(0)) * inv_sin_theta; + x = (m_pVolumeGeometry->getWindowMaxY() - P) * inv_pixelLengthY; + + // get coords + int nextx1 = int((x > 0.0f) ? x : x-1.0f); + float nextx2 = x - nextx1; + + // for each col + for (col = 0; col < m_pVolumeGeometry->getGridColCount(); ++col) { + + x1 = nextx1; + x2 = nextx2; + + nextx2 += updatePerCol; + while (nextx2 >= 1.0f) { + nextx2 -= 1.0f; + nextx1++; + } + while (nextx2 < 0.0f) { + nextx2 += 1.0f; + nextx1--; + } + + if (x1 < -1 || x1 > m_pVolumeGeometry->getGridRowCount()) continue; + + // up + if (x2 < 0.5f-T) { + I = (0.5f - T + x2) / (1.0f - 2.0f*T) * lengthPerCol; + + if (x1-1 >= 0 && x1-1 < m_pVolumeGeometry->getGridRowCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1-1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerCol-I); + p.pixelPosterior(iVolumeIndex); + } + } + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridRowCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // center + else if (x2 <= 0.5f+T) { + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridRowCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerCol); + p.pixelPosterior(iVolumeIndex); + } + } + } + + // down + else { + I = (1.5f - T - x2) / (1.0f - 2.0f*T) * lengthPerCol; + + if (x1 >= 0 && x1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, I); + p.pixelPosterior(iVolumeIndex); + } + } + if (x1+1 >= 0 && x1+1 < m_pVolumeGeometry->getGridColCount()) { + iVolumeIndex = m_pVolumeGeometry->pixelRowColToIndex(x1+1, col); + // POLICY: PIXEL PRIOR + ADD + POSTERIOR + if (p.pixelPrior(iVolumeIndex)) { + p.addWeight(iRayIndex, iVolumeIndex, lengthPerCol-I); + p.pixelPosterior(iVolumeIndex); + } + } + } + } + } // end loop col + + // POLICY: RAY POSTERIOR + p.rayPosterior(iRayIndex); + +} |