From 27a964cb66f3a78ca27cc5a5befbdd3f405ccee4 Mon Sep 17 00:00:00 2001 From: Willem Jan Palenstijn Date: Fri, 28 Oct 2016 09:24:25 +0200 Subject: Remove unused function --- src/Float32Data3DMemory.cpp | 1 + 1 file changed, 1 insertion(+) (limited to 'src') diff --git a/src/Float32Data3DMemory.cpp b/src/Float32Data3DMemory.cpp index 95b1859..8735585 100644 --- a/src/Float32Data3DMemory.cpp +++ b/src/Float32Data3DMemory.cpp @@ -27,6 +27,7 @@ along with the ASTRA Toolbox. If not, see . #include "astra/Float32Data3DMemory.h" #include +#include namespace astra { -- cgit v1.2.3 From e8f6dd643fc04588cb8a8eaa8453c0eb6d40e236 Mon Sep 17 00:00:00 2001 From: Willem Jan Palenstijn Date: Fri, 28 Oct 2016 09:35:21 +0200 Subject: Remove unused data3d functions --- src/Float32ProjectionData3D.cpp | 226 ---------------------------------- src/Float32ProjectionData3DMemory.cpp | 96 --------------- src/Float32VolumeData3D.cpp | 222 --------------------------------- src/Float32VolumeData3DMemory.cpp | 90 -------------- 4 files changed, 634 deletions(-) (limited to 'src') diff --git a/src/Float32ProjectionData3D.cpp b/src/Float32ProjectionData3D.cpp index c751c58..ba41e10 100644 --- a/src/Float32ProjectionData3D.cpp +++ b/src/Float32ProjectionData3D.cpp @@ -47,232 +47,6 @@ CFloat32ProjectionData3D::~CFloat32ProjectionData3D() { m_pGeometry = 0; } -CFloat32ProjectionData3D& CFloat32ProjectionData3D::operator+=(const CFloat32ProjectionData3D& _data) -{ - CProjectionGeometry3D * pThisGeometry = getGeometry(); - - int iProjectionCount = pThisGeometry->getProjectionCount(); - int iDetectorCount = pThisGeometry->getDetectorTotCount(); -#ifdef _DEBUG - CProjectionGeometry3D * pDataGeometry = _data.getGeometry(); - int iDataProjectionDetectorCount = pDataGeometry->getDetectorTotCount(); - - ASTRA_ASSERT(iProjectionCount == pDataGeometry->getProjectionCount()); - ASTRA_ASSERT(iDetectorCount == iDataProjectionDetectorCount); -#endif - - for(int iProjectionIndex = 0; iProjectionIndex < iProjectionCount; iProjectionIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchProjection(iProjectionIndex); - CFloat32VolumeData2D * pDataProjection = _data.fetchProjection(iProjectionIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorCount; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - float32 fDataValue = pDataProjection->getDataConst()[iDetectorIndex]; - - fThisValue += fDataValue; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnProjection(iProjectionIndex, pThisProjection); - - delete pThisProjection; - delete pDataProjection; - } - - return *this; -} - -CFloat32ProjectionData3D& CFloat32ProjectionData3D::operator-=(const CFloat32ProjectionData3D& _data) -{ - CProjectionGeometry3D * pThisGeometry = getGeometry(); - - int iProjectionCount = pThisGeometry->getProjectionCount(); - int iDetectorCount = pThisGeometry->getDetectorTotCount(); -#ifdef _DEBUG - CProjectionGeometry3D * pDataGeometry = _data.getGeometry(); - int iDataProjectionDetectorCount = pDataGeometry->getDetectorTotCount(); - - ASTRA_ASSERT(iProjectionCount == pDataGeometry->getProjectionCount()); - ASTRA_ASSERT(iDetectorCount == iDataProjectionDetectorCount); -#endif - - for(int iProjectionIndex = 0; iProjectionIndex < iProjectionCount; iProjectionIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchProjection(iProjectionIndex); - CFloat32VolumeData2D * pDataProjection = _data.fetchProjection(iProjectionIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorCount; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - float32 fDataValue = pDataProjection->getDataConst()[iDetectorIndex]; - - fThisValue -= fDataValue; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnProjection(iProjectionIndex, pThisProjection); - - delete pThisProjection; - delete pDataProjection; - } - - return *this; -} - -CFloat32ProjectionData3D& CFloat32ProjectionData3D::operator*=(const CFloat32ProjectionData3D& _data) -{ - CProjectionGeometry3D * pThisGeometry = getGeometry(); - - int iProjectionCount = pThisGeometry->getProjectionCount(); - int iDetectorCount = pThisGeometry->getDetectorTotCount(); -#ifdef _DEBUG - CProjectionGeometry3D * pDataGeometry = _data.getGeometry(); - int iDataProjectionDetectorCount = pDataGeometry->getDetectorTotCount(); - - ASTRA_ASSERT(iProjectionCount == pDataGeometry->getProjectionCount()); - ASTRA_ASSERT(iDetectorCount == iDataProjectionDetectorCount); -#endif - - for(int iProjectionIndex = 0; iProjectionIndex < iProjectionCount; iProjectionIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchProjection(iProjectionIndex); - CFloat32VolumeData2D * pDataProjection = _data.fetchProjection(iProjectionIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorCount; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - float32 fDataValue = pDataProjection->getDataConst()[iDetectorIndex]; - - fThisValue *= fDataValue; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnProjection(iProjectionIndex, pThisProjection); - - delete pThisProjection; - delete pDataProjection; - } - - return *this; -} - -CFloat32ProjectionData3D& CFloat32ProjectionData3D::operator*=(const float32& _fScalar) -{ - CProjectionGeometry3D * pThisGeometry = getGeometry(); - - int iProjectionCount = pThisGeometry->getProjectionCount(); - int iDetectorCount = pThisGeometry->getDetectorTotCount(); - - for(int iProjectionIndex = 0; iProjectionIndex < iProjectionCount; iProjectionIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchProjection(iProjectionIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorCount; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - - fThisValue *= _fScalar; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnProjection(iProjectionIndex, pThisProjection); - - delete pThisProjection; - } - - return *this; -} - -CFloat32ProjectionData3D& CFloat32ProjectionData3D::operator/=(const float32& _fScalar) -{ - CProjectionGeometry3D * pThisGeometry = getGeometry(); - - int iProjectionCount = pThisGeometry->getProjectionCount(); - int iDetectorCount = pThisGeometry->getDetectorTotCount(); - - for(int iProjectionIndex = 0; iProjectionIndex < iProjectionCount; iProjectionIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchProjection(iProjectionIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorCount; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - - fThisValue /= _fScalar; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnProjection(iProjectionIndex, pThisProjection); - - delete pThisProjection; - } - - return *this; -} - -CFloat32ProjectionData3D& CFloat32ProjectionData3D::operator+=(const float32& _fScalar) -{ - CProjectionGeometry3D * pThisGeometry = getGeometry(); - - int iProjectionCount = pThisGeometry->getProjectionCount(); - int iDetectorCount = pThisGeometry->getDetectorTotCount(); - - for(int iProjectionIndex = 0; iProjectionIndex < iProjectionCount; iProjectionIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchProjection(iProjectionIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorCount; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - - fThisValue += _fScalar; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnProjection(iProjectionIndex, pThisProjection); - - delete pThisProjection; - } - - return *this; -} - -CFloat32ProjectionData3D& CFloat32ProjectionData3D::operator-=(const float32& _fScalar) -{ - CProjectionGeometry3D * pThisGeometry = getGeometry(); - - int iProjectionCount = pThisGeometry->getProjectionCount(); - int iDetectorCount = pThisGeometry->getDetectorTotCount(); - - for(int iProjectionIndex = 0; iProjectionIndex < iProjectionCount; iProjectionIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchProjection(iProjectionIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorCount; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - - fThisValue -= _fScalar; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnProjection(iProjectionIndex, pThisProjection); - - delete pThisProjection; - } - - return *this; -} - void CFloat32ProjectionData3D::changeGeometry(CProjectionGeometry3D* _pGeometry) { if (!m_bInitialized) return; diff --git a/src/Float32ProjectionData3DMemory.cpp b/src/Float32ProjectionData3DMemory.cpp index f42e216..81daf9e 100644 --- a/src/Float32ProjectionData3DMemory.cpp +++ b/src/Float32ProjectionData3DMemory.cpp @@ -130,102 +130,6 @@ CFloat32ProjectionData3DMemory::~CFloat32ProjectionData3DMemory() //_unInit(); //delete stuff inherited from CFloat32Data3DMemory } -//---------------------------------------------------------------------------------------- -// Fetch a projection -CFloat32VolumeData2D* CFloat32ProjectionData3DMemory::fetchProjection(int _iProjectionNr) const -{ - // fetch slice of the geometry - CVolumeGeometry2D volGeom(m_pGeometry->getDetectorColCount(), m_pGeometry->getDetectorRowCount()); - // create new volume data - CFloat32VolumeData2D* res = new CFloat32VolumeData2D(&volGeom); - // copy data - int row, col; - for (row = 0; row < m_pGeometry->getDetectorRowCount(); ++row) { - for (col = 0; col < m_pGeometry->getDetectorColCount(); ++col) { - res->getData()[row*m_pGeometry->getDetectorColCount() + col] = - m_pfData[_iProjectionNr * m_pGeometry->getDetectorColCount() + m_pGeometry->getDetectorColCount()* m_pGeometry->getProjectionCount() * row + col]; - } - } - // return - return res; -} - -//---------------------------------------------------------------------------------------- -// Return a projection -void CFloat32ProjectionData3DMemory::returnProjection(int _iProjectionNr, CFloat32VolumeData2D* _pProjection) -{ - /// TODO: check geometry - // copy data - int row, col; - for (row = 0; row < m_pGeometry->getDetectorRowCount(); ++row) { - for (col = 0; col < m_pGeometry->getDetectorColCount(); ++col) { - m_pfData[_iProjectionNr * m_pGeometry->getDetectorColCount() + m_pGeometry->getDetectorColCount()* m_pGeometry->getProjectionCount() * row + col] = - _pProjection->getData()[row*m_pGeometry->getDetectorColCount() + col]; - } - } -} - -//---------------------------------------------------------------------------------------- -// Fetch a sinogram -CFloat32ProjectionData2D* CFloat32ProjectionData3DMemory::fetchSinogram(int _iSliceNr) const -{ - CParallelProjectionGeometry3D * pParallelProjGeo = (CParallelProjectionGeometry3D *)m_pGeometry; - CParallelProjectionGeometry2D * pProjGeo2D = pParallelProjGeo->createProjectionGeometry2D(); - - // create new projection data - CFloat32ProjectionData2D* res = new CFloat32ProjectionData2D(pProjGeo2D); - // copy data - int row, col; - - int iDetectorColumnCount = m_pGeometry->getDetectorColCount(); - int iProjectionAngleCount = m_pGeometry->getProjectionCount(); - - for (row = 0; row < m_pGeometry->getProjectionCount(); ++row) { - for (col = 0; col < m_pGeometry->getDetectorColCount(); ++col) - { - int iTargetIndex = row * iDetectorColumnCount + col; - int iSourceIndex = _iSliceNr * iDetectorColumnCount * iProjectionAngleCount + row * iDetectorColumnCount + col; - - float32 fStoredValue = m_pfData[iSourceIndex]; - - res->getData()[iTargetIndex] = fStoredValue; - } - } - - delete pProjGeo2D; - - // return - return res; -} - -//---------------------------------------------------------------------------------------- -// Return a sinogram -void CFloat32ProjectionData3DMemory::returnSinogram(int _iSliceNr, CFloat32ProjectionData2D* _pSinogram2D) -{ - /// TODO: check geometry - // copy data - int row, col; - for (row = 0; row < m_pGeometry->getProjectionCount(); ++row) { - for (col = 0; col < m_pGeometry->getDetectorColCount(); ++col) { - m_pfData[_iSliceNr*m_pGeometry->getDetectorColCount()*m_pGeometry->getProjectionCount() + row*m_pGeometry->getDetectorColCount() + col] = - _pSinogram2D->getData()[row*m_pGeometry->getDetectorColCount() + col]; - } - } -} - -//---------------------------------------------------------------------------------------- -// Returns a specific value -float32 CFloat32ProjectionData3DMemory::getDetectorValue(int _iIndex) -{ - return m_pfData[_iIndex]; -} - -//---------------------------------------------------------------------------------------- -// Sets a specific value -void CFloat32ProjectionData3DMemory::setDetectorValue(int _iIndex, float32 _fValue) -{ - m_pfData[_iIndex] = _fValue; -} //---------------------------------------------------------------------------------------- CFloat32ProjectionData3DMemory& CFloat32ProjectionData3DMemory::operator=(const CFloat32ProjectionData3DMemory& _dataIn) diff --git a/src/Float32VolumeData3D.cpp b/src/Float32VolumeData3D.cpp index bf7eced..96e6940 100644 --- a/src/Float32VolumeData3D.cpp +++ b/src/Float32VolumeData3D.cpp @@ -43,228 +43,6 @@ CFloat32VolumeData3D::~CFloat32VolumeData3D() { } -CFloat32VolumeData3D& CFloat32VolumeData3D::operator+=(const CFloat32VolumeData3D& _data) -{ - CVolumeGeometry3D * pThisGeometry = getGeometry(); - - int iSliceCount = pThisGeometry->getGridSliceCount(); -#ifdef _DEBUG - CVolumeGeometry3D * pDataGeometry = _data.getGeometry(); - int iThisSlicePixelCount = pThisGeometry->getGridRowCount() * pThisGeometry->getGridColCount(); - int iDataSlicePixelCount = pDataGeometry->getGridRowCount() * pDataGeometry->getGridColCount(); - - ASTRA_ASSERT(iSliceCount == pDataGeometry->getGridSliceCount()); - ASTRA_ASSERT(iThisSlicePixelCount == iDataSlicePixelCount); -#endif - - for(int iSliceIndex = 0; iSliceIndex < iSliceCount; iSliceIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchSliceZ(iSliceIndex); - CFloat32VolumeData2D * pDataProjection = _data.fetchSliceZ(iSliceIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorIndex; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - float32 fDataValue = pDataProjection->getDataConst()[iDetectorIndex]; - - fThisValue += fDataValue; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnSliceZ(iSliceIndex, pThisProjection); - - delete pThisProjection; - delete pDataProjection; - } - - return *this; -} - -CFloat32VolumeData3D& CFloat32VolumeData3D::operator-=(const CFloat32VolumeData3D& _data) -{ - CVolumeGeometry3D * pThisGeometry = getGeometry(); - - int iSliceCount = pThisGeometry->getGridSliceCount(); -#ifdef _DEBUG - CVolumeGeometry3D * pDataGeometry = _data.getGeometry(); - int iThisSlicePixelCount = pThisGeometry->getGridRowCount() * pThisGeometry->getGridColCount(); - int iDataSlicePixelCount = pDataGeometry->getGridRowCount() * pDataGeometry->getGridColCount(); - - ASTRA_ASSERT(iSliceCount == pDataGeometry->getGridSliceCount()); - ASTRA_ASSERT(iThisSlicePixelCount == iDataSlicePixelCount); -#endif - - for(int iSliceIndex = 0; iSliceIndex < iSliceCount; iSliceIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchSliceZ(iSliceIndex); - CFloat32VolumeData2D * pDataProjection = _data.fetchSliceZ(iSliceIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorIndex; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - float32 fDataValue = pDataProjection->getDataConst()[iDetectorIndex]; - - fThisValue -= fDataValue; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnSliceZ(iSliceIndex, pThisProjection); - - delete pThisProjection; - delete pDataProjection; - } - - return *this; -} - -CFloat32VolumeData3D& CFloat32VolumeData3D::operator*=(const CFloat32VolumeData3D& _data) -{ - CVolumeGeometry3D * pThisGeometry = getGeometry(); - - int iSliceCount = pThisGeometry->getGridSliceCount(); -#ifdef _DEBUG - CVolumeGeometry3D * pDataGeometry = _data.getGeometry(); - int iThisSlicePixelCount = pThisGeometry->getGridRowCount() * pThisGeometry->getGridColCount(); - int iDataSlicePixelCount = pDataGeometry->getGridRowCount() * pDataGeometry->getGridColCount(); - - ASTRA_ASSERT(iSliceCount == pDataGeometry->getGridSliceCount()); - ASTRA_ASSERT(iThisSlicePixelCount == iDataSlicePixelCount); -#endif - - for(int iSliceIndex = 0; iSliceIndex < iSliceCount; iSliceIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchSliceZ(iSliceIndex); - CFloat32VolumeData2D * pDataProjection = _data.fetchSliceZ(iSliceIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorIndex; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - float32 fDataValue = pDataProjection->getDataConst()[iDetectorIndex]; - - fThisValue *= fDataValue; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnSliceZ(iSliceIndex, pThisProjection); - - delete pThisProjection; - delete pDataProjection; - } - - return *this; -} - -CFloat32VolumeData3D& CFloat32VolumeData3D::operator*=(const float32& _fScalar) -{ - CVolumeGeometry3D * pThisGeometry = getGeometry(); - - int iSliceCount = pThisGeometry->getGridSliceCount(); - - for(int iSliceIndex = 0; iSliceIndex < iSliceCount; iSliceIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchSliceZ(iSliceIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorIndex; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - - fThisValue *= _fScalar; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnSliceZ(iSliceIndex, pThisProjection); - - delete pThisProjection; - } - - return *this; -} - -CFloat32VolumeData3D& CFloat32VolumeData3D::operator/=(const float32& _fScalar) -{ - CVolumeGeometry3D * pThisGeometry = getGeometry(); - - int iSliceCount = pThisGeometry->getGridSliceCount(); - - for(int iSliceIndex = 0; iSliceIndex < iSliceCount; iSliceIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchSliceZ(iSliceIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorIndex; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - - fThisValue /= _fScalar; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnSliceZ(iSliceIndex, pThisProjection); - - delete pThisProjection; - } - - return *this; -} - -CFloat32VolumeData3D& CFloat32VolumeData3D::operator+=(const float32& _fScalar) -{ - CVolumeGeometry3D * pThisGeometry = getGeometry(); - - int iSliceCount = pThisGeometry->getGridSliceCount(); - - for(int iSliceIndex = 0; iSliceIndex < iSliceCount; iSliceIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchSliceZ(iSliceIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorIndex; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - - fThisValue += _fScalar; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnSliceZ(iSliceIndex, pThisProjection); - - delete pThisProjection; - } - - return *this; -} - -CFloat32VolumeData3D& CFloat32VolumeData3D::operator-=(const float32& _fScalar) -{ - CVolumeGeometry3D * pThisGeometry = getGeometry(); - - int iSliceCount = pThisGeometry->getGridSliceCount(); - - for(int iSliceIndex = 0; iSliceIndex < iSliceCount; iSliceIndex++) - { - CFloat32VolumeData2D * pThisProjection = fetchSliceZ(iSliceIndex); - - for(int iDetectorIndex = 0; iDetectorIndex < iDetectorIndex; iDetectorIndex++) - { - float32 fThisValue = pThisProjection->getData()[iDetectorIndex]; - - fThisValue -= _fScalar; - - pThisProjection->getData()[iDetectorIndex] = fThisValue; - } - - returnSliceZ(iSliceIndex, pThisProjection); - - delete pThisProjection; - } - - return *this; -} - void CFloat32VolumeData3D::changeGeometry(CVolumeGeometry3D* _pGeometry) { if (!m_bInitialized) return; diff --git a/src/Float32VolumeData3DMemory.cpp b/src/Float32VolumeData3DMemory.cpp index ba39eaa..9f81c85 100644 --- a/src/Float32VolumeData3DMemory.cpp +++ b/src/Float32VolumeData3DMemory.cpp @@ -121,96 +121,6 @@ bool CFloat32VolumeData3DMemory::initialize(CVolumeGeometry3D* _pGeometry, CFloa return m_bInitialized; } - -//---------------------------------------------------------------------------------------- -// Fetch a slice -CFloat32VolumeData2D * CFloat32VolumeData3DMemory::fetchSliceZ(int _iSliceIndex) const -{ - // fetch slice of the geometry - int iRowCount = m_pGeometry->getGridRowCount(); - int iColumnCount = m_pGeometry->getGridColCount(); - CVolumeGeometry2D volGeom(iColumnCount, iRowCount); - - // create new volume data - CFloat32VolumeData2D* res = new CFloat32VolumeData2D(&volGeom); - - // copy data - float * pfTargetData = res->getData(); - for(int iRowIndex = 0; iRowIndex < iRowCount; iRowIndex++) - { - for(int iColumnIndex = 0; iColumnIndex < iColumnCount; iColumnIndex++) - { - int iSourceIndex = _iSliceIndex * iColumnCount * iRowCount + iRowIndex * iColumnCount + iColumnIndex; - int iTargetIndex = iRowIndex * iColumnCount + iColumnIndex; - float fStoredValue = m_pfData[iSourceIndex]; - pfTargetData[iTargetIndex] = fStoredValue; - } - } - // return - return res; -} - -//---------------------------------------------------------------------------------------- -// Return a slice -void CFloat32VolumeData3DMemory::returnSliceZ(int _iSliceIndex, CFloat32VolumeData2D * _pSlice) -{ - int iRowCount = _pSlice->getGeometry()->getGridRowCount(); - int iColumnCount = _pSlice->getGeometry()->getGridColCount(); - - assert(iRowCount == m_pGeometry->getGridRowCount()); - assert(iColumnCount == m_pGeometry->getGridColCount()); - - for(int iRowIndex = 0; iRowIndex < iRowCount; iRowIndex++) - { - for(int iColumnIndex = 0; iColumnIndex < iColumnCount; iColumnIndex++) - { - int iSourceIndex = iRowIndex * iColumnCount + iColumnIndex; - int iTargetIndex = _iSliceIndex * iColumnCount * iRowCount + iRowIndex * iColumnCount + iColumnIndex; - float fStoredValue = _pSlice->getDataConst()[iSourceIndex]; - m_pfData[iTargetIndex] = fStoredValue; - } - } -} - -CFloat32VolumeData2D * CFloat32VolumeData3DMemory::fetchSliceX(int _iColumnIndex) const -{ - // TODO: - assert(false); - return NULL; -} - -CFloat32VolumeData2D * CFloat32VolumeData3DMemory::fetchSliceY(int _iRowIndex) const -{ - // TODO: - assert(false); - return NULL; -} - -void CFloat32VolumeData3DMemory::returnSliceX(int _iColumnIndex, CFloat32VolumeData2D * _pSliceData) -{ - // TODO: - assert(false); -} - -void CFloat32VolumeData3DMemory::returnSliceY(int _iRowIndex, CFloat32VolumeData2D * _pSliceData) -{ - // TODO: - assert(false); -} - -//---------------------------------------------------------------------------------------- -// Returns a specific value -float32 CFloat32VolumeData3DMemory::getVoxelValue(int _iIndex) -{ - return m_pfData[_iIndex]; -} - -//---------------------------------------------------------------------------------------- -// Sets a specific value -void CFloat32VolumeData3DMemory::setVoxelValue(int _iIndex, float32 _fValue) -{ - m_pfData[_iIndex] = _fValue; -} //---------------------------------------------------------------------------------------- CFloat32VolumeData3DMemory& CFloat32VolumeData3DMemory::operator=(const CFloat32VolumeData3DMemory& _dataIn) -- cgit v1.2.3 From 1d851f0a8fa093e044c7264569cc6f88df39a16e Mon Sep 17 00:00:00 2001 From: Willem Jan Palenstijn Date: Thu, 26 Jan 2017 14:57:42 +0100 Subject: Remove unused 3d global min/max --- src/Float32Data3DMemory.cpp | 38 -------------------------------------- 1 file changed, 38 deletions(-) (limited to 'src') diff --git a/src/Float32Data3DMemory.cpp b/src/Float32Data3DMemory.cpp index 8735585..7e60527 100644 --- a/src/Float32Data3DMemory.cpp +++ b/src/Float32Data3DMemory.cpp @@ -76,10 +76,6 @@ bool CFloat32Data3DMemory::_initialize(int _iWidth, int _iHeight, int _iDepth) m_pCustomMemory = 0; _allocateData(); - // set minmax to default values - m_fGlobalMin = 0.0; - m_fGlobalMax = 0.0; - // initialization complete return true; @@ -273,9 +269,6 @@ void CFloat32Data3DMemory::_clear() m_ppfDataRowInd = NULL; m_pppfDataSliceInd = NULL; m_pCustomMemory = NULL; - - //m_fGlobalMin = 0.0f; - //m_fGlobalMax = 0.0f; } //---------------------------------------------------------------------------------------- @@ -289,37 +282,6 @@ void CFloat32Data3DMemory::_unInit() m_bInitialized = false; } -//---------------------------------------------------------------------------------------- -// Update data statistics, such as minimum and maximum value, after the data has been modified. -void CFloat32Data3DMemory::updateStatistics() -{ - _computeGlobalMinMax(); -} - -//---------------------------------------------------------------------------------------- -// Find the minimum and maximum data value. -void CFloat32Data3DMemory::_computeGlobalMinMax() -{ - // basic checks - ASTRA_ASSERT(m_bInitialized); - ASTRA_ASSERT(m_pfData != NULL); - ASTRA_ASSERT(m_iSize > 0); - - // initial values - m_fGlobalMin = m_pfData[0]; - m_fGlobalMax = m_pfData[0]; - - // loop - size_t i; - float32 v; - for (i = 0; i < m_iSize; ++i) - { - v = m_pfData[i]; - if (v < m_fGlobalMin) m_fGlobalMin = v; - if (v > m_fGlobalMax) m_fGlobalMax = v; - } -} - //---------------------------------------------------------------------------------------- // Copy the data block pointed to by _pfData to the data block pointed to by m_pfData. void CFloat32Data3DMemory::copyData(const float32* _pfData, size_t _iSize) -- cgit v1.2.3 From d85a660f064e8130b27e11c7fd762221c754c315 Mon Sep 17 00:00:00 2001 From: Willem Jan Palenstijn Date: Thu, 26 Jan 2017 14:57:57 +0100 Subject: Start work on CFloat32Data3DGPU to allow persistent/external GPU memory --- src/CompositeGeometryManager.cpp | 260 ++++++++++++++++++++++++++----- src/CudaBackProjectionAlgorithm3D.cpp | 20 ++- src/CudaFDKAlgorithm3D.cpp | 12 +- src/CudaForwardProjectionAlgorithm3D.cpp | 8 +- src/Float32Data3D.cpp | 6 +- src/Float32Data3DGPU.cpp | 98 ++++++++++++ src/Float32Data3DMemory.cpp | 2 +- src/Float32ProjectionData3DGPU.cpp | 71 +++++++++ src/Float32ProjectionData3DMemory.cpp | 2 +- src/Float32VolumeData3DGPU.cpp | 71 +++++++++ src/Float32VolumeData3DMemory.cpp | 2 +- 11 files changed, 486 insertions(+), 66 deletions(-) create mode 100644 src/Float32Data3DGPU.cpp create mode 100644 src/Float32ProjectionData3DGPU.cpp create mode 100644 src/Float32VolumeData3DGPU.cpp (limited to 'src') diff --git a/src/CompositeGeometryManager.cpp b/src/CompositeGeometryManager.cpp index c3af228..74466db 100644 --- a/src/CompositeGeometryManager.cpp +++ b/src/CompositeGeometryManager.cpp @@ -39,6 +39,8 @@ along with the ASTRA Toolbox. If not, see . #include "astra/CudaProjector3D.h" #include "astra/Float32ProjectionData3DMemory.h" #include "astra/Float32VolumeData3DMemory.h" +#include "astra/Float32ProjectionData3DGPU.h" +#include "astra/Float32VolumeData3DGPU.h" #include "astra/Logging.h" #include "../cuda/3d/mem3d.h" @@ -97,6 +99,127 @@ CCompositeGeometryManager::CCompositeGeometryManager() // (First approach: 0.5/0.5) + + + +class _AstraExport CFloat32CustomGPUMemory { +public: + astraCUDA3d::MemHandle3D hnd; // Only required to be valid between allocate/free + virtual bool allocateGPUMemory(unsigned int x, unsigned int y, unsigned int z, astraCUDA3d::Mem3DZeroMode zero)=0; + virtual bool copyToGPUMemory(const astraCUDA3d::SSubDimensions3D &pos)=0; + virtual bool copyFromGPUMemory(const astraCUDA3d::SSubDimensions3D &pos)=0; + virtual bool freeGPUMemory()=0; + virtual ~CFloat32CustomGPUMemory() { } +}; + +class CFloat32ExistingGPUMemory : public astra::CFloat32CustomGPUMemory { +public: + CFloat32ExistingGPUMemory(CFloat32Data3DGPU *d); + virtual bool allocateGPUMemory(unsigned int x, unsigned int y, unsigned int z, astraCUDA3d::Mem3DZeroMode zero); + virtual bool copyToGPUMemory(const astraCUDA3d::SSubDimensions3D &pos); + virtual bool copyFromGPUMemory(const astraCUDA3d::SSubDimensions3D &pos); + virtual bool freeGPUMemory(); + +protected: + unsigned int x, y, z; +}; + +class CFloat32DefaultGPUMemory : public astra::CFloat32CustomGPUMemory { +public: + CFloat32DefaultGPUMemory(CFloat32Data3DMemory* d) { + ptr = d->getData(); + } + virtual bool allocateGPUMemory(unsigned int x, unsigned int y, unsigned int z, astraCUDA3d::Mem3DZeroMode zero) { + hnd = astraCUDA3d::allocateGPUMemory(x, y, z, zero); + return (bool)hnd; + } + virtual bool copyToGPUMemory(const astraCUDA3d::SSubDimensions3D &pos) { + return astraCUDA3d::copyToGPUMemory(ptr, hnd, pos); + } + virtual bool copyFromGPUMemory(const astraCUDA3d::SSubDimensions3D &pos) { + return astraCUDA3d::copyFromGPUMemory(ptr, hnd, pos); + } + virtual bool freeGPUMemory() { + return astraCUDA3d::freeGPUMemory(hnd); + } + +protected: + float *ptr; +}; + + + +CFloat32ExistingGPUMemory::CFloat32ExistingGPUMemory(CFloat32Data3DGPU *d) +{ + hnd = d->getHandle(); + x = d->getWidth(); + y = d->getHeight(); + z = d->getDepth(); +} + +bool CFloat32ExistingGPUMemory::allocateGPUMemory(unsigned int x_, unsigned int y_, unsigned int z_, astraCUDA3d::Mem3DZeroMode zero) { + assert(x_ == x); + assert(y_ == y); + assert(z_ == z); + + if (zero == astraCUDA3d::INIT_ZERO) + return astraCUDA3d::zeroGPUMemory(hnd, x, y, z); + else + return true; +} +bool CFloat32ExistingGPUMemory::copyToGPUMemory(const astraCUDA3d::SSubDimensions3D &pos) { + assert(pos.nx == x); + assert(pos.ny == y); + assert(pos.nz == z); + assert(pos.pitch == x); + assert(pos.subx == 0); + assert(pos.suby == 0); + assert(pos.subnx == x); + assert(pos.subny == y); + + // These are less necessary than x/y, but allowing access to + // subvolumes needs an interface change + assert(pos.subz == 0); + assert(pos.subnz == z); + + return true; +} +bool CFloat32ExistingGPUMemory::copyFromGPUMemory(const astraCUDA3d::SSubDimensions3D &pos) { + assert(pos.nx == x); + assert(pos.ny == y); + assert(pos.nz == z); + assert(pos.pitch == x); + assert(pos.subx == 0); + assert(pos.suby == 0); + assert(pos.subnx == x); + assert(pos.subny == y); + + // These are less necessary than x/y, but allowing access to + // subvolumes needs an interface change + assert(pos.subz == 0); + assert(pos.subnz == z); + + return true; +} +bool CFloat32ExistingGPUMemory::freeGPUMemory() { + return true; +} + + +CFloat32CustomGPUMemory * createGPUMemoryHandler(CFloat32Data3D *d) { + CFloat32Data3DMemory *dMem = dynamic_cast(d); + CFloat32Data3DGPU *dGPU = dynamic_cast(d); + + if (dMem) + return new CFloat32DefaultGPUMemory(dMem); + else + return new CFloat32ExistingGPUMemory(dGPU); +} + + + + + bool CCompositeGeometryManager::splitJobs(TJobSet &jobs, size_t maxSize, int div, TJobSet &split) { int maxBlockDim = astraCUDA3d::maxBlockDimension(); @@ -280,7 +403,7 @@ CCompositeGeometryManager::CVolumePart::~CVolumePart() delete pGeom; } -void CCompositeGeometryManager::CVolumePart::getDims(size_t &x, size_t &y, size_t &z) +void CCompositeGeometryManager::CVolumePart::getDims(size_t &x, size_t &y, size_t &z) const { if (!pGeom) { x = y = z = 0; @@ -292,13 +415,28 @@ void CCompositeGeometryManager::CVolumePart::getDims(size_t &x, size_t &y, size_ z = pGeom->getGridSliceCount(); } -size_t CCompositeGeometryManager::CPart::getSize() +size_t CCompositeGeometryManager::CPart::getSize() const { size_t x, y, z; getDims(x, y, z); return x * y * z; } +bool CCompositeGeometryManager::CPart::isFull() const +{ + size_t x, y, z; + getDims(x, y, z); + return x == pData->getWidth() && + y == pData->getHeight() && + z == pData->getDepth(); +} + +bool CCompositeGeometryManager::CPart::canSplitAndReduce() const +{ + return dynamic_cast(pData) != 0; +} + + static bool testVolumeRange(const std::pair& fullRange, const CVolumeGeometry3D *pVolGeom, @@ -334,6 +472,9 @@ static bool testVolumeRange(const std::pair& fullRange, CCompositeGeometryManager::CPart* CCompositeGeometryManager::CVolumePart::reduce(const CPart *_other) { + if (!canSplitAndReduce()) + return clone(); + const CProjectionPart *other = dynamic_cast(_other); assert(other); @@ -654,7 +795,7 @@ static CProjectionGeometry3D* getSubProjectionGeometryV(const CProjectionGeometr // - maybe all approximately the same size? void CCompositeGeometryManager::CVolumePart::splitX(CCompositeGeometryManager::TPartList& out, size_t maxSize, size_t maxDim, int div) { - if (true) { + if (canSplitAndReduce()) { // Split in vertical direction only at first, until we figure out // a model for splitting in other directions @@ -698,12 +839,14 @@ void CCompositeGeometryManager::CVolumePart::splitX(CCompositeGeometryManager::T out.push_back(boost::shared_ptr(sub)); } + } else { + out.push_back(boost::shared_ptr(clone())); } } void CCompositeGeometryManager::CVolumePart::splitY(CCompositeGeometryManager::TPartList& out, size_t maxSize, size_t maxDim, int div) { - if (true) { + if (canSplitAndReduce()) { // Split in vertical direction only at first, until we figure out // a model for splitting in other directions @@ -747,12 +890,14 @@ void CCompositeGeometryManager::CVolumePart::splitY(CCompositeGeometryManager::T out.push_back(boost::shared_ptr(sub)); } + } else { + out.push_back(boost::shared_ptr(clone())); } } void CCompositeGeometryManager::CVolumePart::splitZ(CCompositeGeometryManager::TPartList& out, size_t maxSize, size_t maxDim, int div) { - if (true) { + if (canSplitAndReduce()) { // Split in vertical direction only at first, until we figure out // a model for splitting in other directions @@ -796,6 +941,8 @@ void CCompositeGeometryManager::CVolumePart::splitZ(CCompositeGeometryManager::T out.push_back(boost::shared_ptr(sub)); } + } else { + out.push_back(boost::shared_ptr(clone())); } } @@ -815,7 +962,7 @@ CCompositeGeometryManager::CProjectionPart::~CProjectionPart() delete pGeom; } -void CCompositeGeometryManager::CProjectionPart::getDims(size_t &x, size_t &y, size_t &z) +void CCompositeGeometryManager::CProjectionPart::getDims(size_t &x, size_t &y, size_t &z) const { if (!pGeom) { x = y = z = 0; @@ -831,6 +978,9 @@ void CCompositeGeometryManager::CProjectionPart::getDims(size_t &x, size_t &y, s CCompositeGeometryManager::CPart* CCompositeGeometryManager::CProjectionPart::reduce(const CPart *_other) { + if (!canSplitAndReduce()) + return clone(); + const CVolumePart *other = dynamic_cast(_other); assert(other); @@ -868,7 +1018,7 @@ CCompositeGeometryManager::CPart* CCompositeGeometryManager::CProjectionPart::re void CCompositeGeometryManager::CProjectionPart::splitX(CCompositeGeometryManager::TPartList &out, size_t maxSize, size_t maxDim, int div) { - if (true) { + if (canSplitAndReduce()) { // Split in vertical direction only at first, until we figure out // a model for splitting in other directions @@ -903,6 +1053,8 @@ void CCompositeGeometryManager::CProjectionPart::splitX(CCompositeGeometryManage out.push_back(boost::shared_ptr(sub)); } + } else { + out.push_back(boost::shared_ptr(clone())); } } @@ -914,7 +1066,7 @@ void CCompositeGeometryManager::CProjectionPart::splitY(CCompositeGeometryManage void CCompositeGeometryManager::CProjectionPart::splitZ(CCompositeGeometryManager::TPartList &out, size_t maxSize, size_t maxDim, int div) { - if (true) { + if (canSplitAndReduce()) { // Split in vertical direction only at first, until we figure out // a model for splitting in other directions @@ -949,6 +1101,8 @@ void CCompositeGeometryManager::CProjectionPart::splitZ(CCompositeGeometryManage out.push_back(boost::shared_ptr(sub)); } + } else { + out.push_back(boost::shared_ptr(clone())); } } @@ -959,8 +1113,8 @@ CCompositeGeometryManager::CProjectionPart* CCompositeGeometryManager::CProjecti } CCompositeGeometryManager::SJob CCompositeGeometryManager::createJobFP(CProjector3D *pProjector, - CFloat32VolumeData3DMemory *pVolData, - CFloat32ProjectionData3DMemory *pProjData) + CFloat32VolumeData3D *pVolData, + CFloat32ProjectionData3D *pProjData) { ASTRA_DEBUG("CCompositeGeometryManager::createJobFP"); // Create single job for FP @@ -992,8 +1146,8 @@ CCompositeGeometryManager::SJob CCompositeGeometryManager::createJobFP(CProjecto } CCompositeGeometryManager::SJob CCompositeGeometryManager::createJobBP(CProjector3D *pProjector, - CFloat32VolumeData3DMemory *pVolData, - CFloat32ProjectionData3DMemory *pProjData) + CFloat32VolumeData3D *pVolData, + CFloat32ProjectionData3D *pProjData) { ASTRA_DEBUG("CCompositeGeometryManager::createJobBP"); // Create single job for BP @@ -1022,8 +1176,8 @@ CCompositeGeometryManager::SJob CCompositeGeometryManager::createJobBP(CProjecto return BP; } -bool CCompositeGeometryManager::doFP(CProjector3D *pProjector, CFloat32VolumeData3DMemory *pVolData, - CFloat32ProjectionData3DMemory *pProjData) +bool CCompositeGeometryManager::doFP(CProjector3D *pProjector, CFloat32VolumeData3D *pVolData, + CFloat32ProjectionData3D *pProjData) { TJobList L; L.push_back(createJobFP(pProjector, pVolData, pProjData)); @@ -1031,8 +1185,8 @@ bool CCompositeGeometryManager::doFP(CProjector3D *pProjector, CFloat32VolumeDat return doJobs(L); } -bool CCompositeGeometryManager::doBP(CProjector3D *pProjector, CFloat32VolumeData3DMemory *pVolData, - CFloat32ProjectionData3DMemory *pProjData) +bool CCompositeGeometryManager::doBP(CProjector3D *pProjector, CFloat32VolumeData3D *pVolData, + CFloat32ProjectionData3D *pProjData) { TJobList L; L.push_back(createJobBP(pProjector, pVolData, pProjData)); @@ -1041,8 +1195,8 @@ bool CCompositeGeometryManager::doBP(CProjector3D *pProjector, CFloat32VolumeDat } -bool CCompositeGeometryManager::doFDK(CProjector3D *pProjector, CFloat32VolumeData3DMemory *pVolData, - CFloat32ProjectionData3DMemory *pProjData, bool bShortScan, +bool CCompositeGeometryManager::doFDK(CProjector3D *pProjector, CFloat32VolumeData3D *pVolData, + CFloat32ProjectionData3D *pProjData, bool bShortScan, const float *pfFilter) { if (!dynamic_cast(pProjData->getGeometry())) { @@ -1061,11 +1215,11 @@ bool CCompositeGeometryManager::doFDK(CProjector3D *pProjector, CFloat32VolumeDa return doJobs(L); } -bool CCompositeGeometryManager::doFP(CProjector3D *pProjector, const std::vector& volData, const std::vector& projData) +bool CCompositeGeometryManager::doFP(CProjector3D *pProjector, const std::vector& volData, const std::vector& projData) { ASTRA_DEBUG("CCompositeGeometryManager::doFP, multi-volume"); - std::vector::const_iterator i; + std::vector::const_iterator i; std::vector > inputs; for (i = volData.begin(); i != volData.end(); ++i) { @@ -1079,7 +1233,7 @@ bool CCompositeGeometryManager::doFP(CProjector3D *pProjector, const std::vector inputs.push_back(boost::shared_ptr(input)); } - std::vector::const_iterator j; + std::vector::const_iterator j; std::vector > outputs; for (j = projData.begin(); j != projData.end(); ++j) { @@ -1115,12 +1269,12 @@ bool CCompositeGeometryManager::doFP(CProjector3D *pProjector, const std::vector return doJobs(L); } -bool CCompositeGeometryManager::doBP(CProjector3D *pProjector, const std::vector& volData, const std::vector& projData) +bool CCompositeGeometryManager::doBP(CProjector3D *pProjector, const std::vector& volData, const std::vector& projData) { ASTRA_DEBUG("CCompositeGeometryManager::doBP, multi-volume"); - std::vector::const_iterator i; + std::vector::const_iterator i; std::vector > outputs; for (i = volData.begin(); i != volData.end(); ++i) { @@ -1134,7 +1288,7 @@ bool CCompositeGeometryManager::doBP(CProjector3D *pProjector, const std::vector outputs.push_back(boost::shared_ptr(output)); } - std::vector::const_iterator j; + std::vector::const_iterator j; std::vector > inputs; for (j = projData.begin(); j != projData.end(); ++j) { @@ -1188,14 +1342,25 @@ static bool doJob(const CCompositeGeometryManager::TJobSet::const_iterator& iter if (L.begin()->eType == CCompositeGeometryManager::SJob::JOB_NOP) { // just zero output? if (zero) { - for (size_t z = 0; z < outz; ++z) { - for (size_t y = 0; y < outy; ++y) { - float* ptr = output->pData->getData(); - ptr += (z + output->subX) * (size_t)output->pData->getHeight() * (size_t)output->pData->getWidth(); - ptr += (y + output->subY) * (size_t)output->pData->getWidth(); - ptr += output->subX; - memset(ptr, 0, sizeof(float) * outx); + // TODO: This function shouldn't have to know about this difference + // between Memory/GPU + CFloat32Data3DMemory *hostMem = dynamic_cast(output->pData); + if (hostMem) { + for (size_t z = 0; z < outz; ++z) { + for (size_t y = 0; y < outy; ++y) { + float* ptr = hostMem->getData(); + ptr += (z + output->subX) * (size_t)output->pData->getHeight() * (size_t)output->pData->getWidth(); + ptr += (y + output->subY) * (size_t)output->pData->getWidth(); + ptr += output->subX; + memset(ptr, 0, sizeof(float) * outx); + } } + } else { + CFloat32Data3DGPU *gpuMem = dynamic_cast(output->pData); + assert(gpuMem); + assert(output->isFull()); // TODO: zero subset? + + zeroGPUMemory(gpuMem->getHandle(), outx, outy, outz); } } return true; @@ -1214,10 +1379,11 @@ static bool doJob(const CCompositeGeometryManager::TJobSet::const_iterator& iter dstdims.subx = output->subX; dstdims.suby = output->subY; dstdims.subz = output->subZ; - float *dst = output->pData->getData(); - astraCUDA3d::MemHandle3D outputMem = astraCUDA3d::allocateGPUMemory(outx, outy, outz, zero ? astraCUDA3d::INIT_ZERO : astraCUDA3d::INIT_NO); - bool ok = outputMem; + CFloat32CustomGPUMemory *dstMem = createGPUMemoryHandler(output->pData); + + bool ok = dstMem->allocateGPUMemory(outx, outy, outz, zero ? astraCUDA3d::INIT_ZERO : astraCUDA3d::INIT_NO); + if (!ok) ASTRA_ERROR("Error allocating GPU memory"); for (CCompositeGeometryManager::TJobList::const_iterator i = L.begin(); i != L.end(); ++i) { const CCompositeGeometryManager::SJob &j = *i; @@ -1238,7 +1404,8 @@ static bool doJob(const CCompositeGeometryManager::TJobSet::const_iterator& iter size_t inx, iny, inz; j.pInput->getDims(inx, iny, inz); - astraCUDA3d::MemHandle3D inputMem = astraCUDA3d::allocateGPUMemory(inx, iny, inz, astraCUDA3d::INIT_NO); + + CFloat32CustomGPUMemory *srcMem = createGPUMemoryHandler(j.pInput->pData); astraCUDA3d::SSubDimensions3D srcdims; srcdims.nx = j.pInput->pData->getWidth(); @@ -1251,9 +1418,11 @@ static bool doJob(const CCompositeGeometryManager::TJobSet::const_iterator& iter srcdims.subx = j.pInput->subX; srcdims.suby = j.pInput->subY; srcdims.subz = j.pInput->subZ; - const float *src = j.pInput->pData->getDataConst(); - ok = astraCUDA3d::copyToGPUMemory(src, inputMem, srcdims); + ok = srcMem->allocateGPUMemory(inx, iny, inz, astraCUDA3d::INIT_NO); + if (!ok) ASTRA_ERROR("Error allocating GPU memory"); + + ok = srcMem->copyToGPUMemory(srcdims); if (!ok) ASTRA_ERROR("Error copying input data to GPU"); switch (j.eType) { @@ -1264,7 +1433,7 @@ static bool doJob(const CCompositeGeometryManager::TJobSet::const_iterator& iter ASTRA_DEBUG("CCompositeGeometryManager::doJobs: doing FP"); - ok = astraCUDA3d::FP(((CCompositeGeometryManager::CProjectionPart*)j.pOutput.get())->pGeom, outputMem, ((CCompositeGeometryManager::CVolumePart*)j.pInput.get())->pGeom, inputMem, detectorSuperSampling, projKernel); + ok = astraCUDA3d::FP(((CCompositeGeometryManager::CProjectionPart*)j.pOutput.get())->pGeom, dstMem->hnd, ((CCompositeGeometryManager::CVolumePart*)j.pInput.get())->pGeom, srcMem->hnd, detectorSuperSampling, projKernel); if (!ok) ASTRA_ERROR("Error performing sub-FP"); ASTRA_DEBUG("CCompositeGeometryManager::doJobs: FP done"); } @@ -1276,7 +1445,7 @@ static bool doJob(const CCompositeGeometryManager::TJobSet::const_iterator& iter ASTRA_DEBUG("CCompositeGeometryManager::doJobs: doing BP"); - ok = astraCUDA3d::BP(((CCompositeGeometryManager::CProjectionPart*)j.pInput.get())->pGeom, inputMem, ((CCompositeGeometryManager::CVolumePart*)j.pOutput.get())->pGeom, outputMem, voxelSuperSampling, densityWeighting); + ok = astraCUDA3d::BP(((CCompositeGeometryManager::CProjectionPart*)j.pInput.get())->pGeom, srcMem->hnd, ((CCompositeGeometryManager::CVolumePart*)j.pOutput.get())->pGeom, dstMem->hnd, voxelSuperSampling, densityWeighting); if (!ok) ASTRA_ERROR("Error performing sub-BP"); ASTRA_DEBUG("CCompositeGeometryManager::doJobs: BP done"); } @@ -1292,7 +1461,7 @@ static bool doJob(const CCompositeGeometryManager::TJobSet::const_iterator& iter } else { ASTRA_DEBUG("CCompositeGeometryManager::doJobs: doing FDK"); - ok = astraCUDA3d::FDK(((CCompositeGeometryManager::CProjectionPart*)j.pInput.get())->pGeom, inputMem, ((CCompositeGeometryManager::CVolumePart*)j.pOutput.get())->pGeom, outputMem, j.FDKSettings.bShortScan, j.FDKSettings.pfFilter); + ok = astraCUDA3d::FDK(((CCompositeGeometryManager::CProjectionPart*)j.pInput.get())->pGeom, srcMem->hnd, ((CCompositeGeometryManager::CVolumePart*)j.pOutput.get())->pGeom, dstMem->hnd, j.FDKSettings.bShortScan, j.FDKSettings.pfFilter); if (!ok) ASTRA_ERROR("Error performing sub-FDK"); ASTRA_DEBUG("CCompositeGeometryManager::doJobs: FDK done"); } @@ -1302,17 +1471,20 @@ static bool doJob(const CCompositeGeometryManager::TJobSet::const_iterator& iter assert(false); } - ok = astraCUDA3d::freeGPUMemory(inputMem); + ok = srcMem->freeGPUMemory(); if (!ok) ASTRA_ERROR("Error freeing GPU memory"); + delete srcMem; } - ok = astraCUDA3d::copyFromGPUMemory(dst, outputMem, dstdims); + ok = dstMem->copyFromGPUMemory(dstdims); if (!ok) ASTRA_ERROR("Error copying output data from GPU"); - ok = astraCUDA3d::freeGPUMemory(outputMem); + ok = dstMem->freeGPUMemory(); if (!ok) ASTRA_ERROR("Error freeing GPU memory"); + delete dstMem; + return true; } @@ -1455,6 +1627,8 @@ void CCompositeGeometryManager::setGPUIndices(const std::vector& GPUIndices bool CCompositeGeometryManager::doJobs(TJobList &jobs) { + // TODO: Proper clean up if substeps fail (Or as proper as possible) + ASTRA_DEBUG("CCompositeGeometryManager::doJobs"); // Sort job list into job set by output part diff --git a/src/CudaBackProjectionAlgorithm3D.cpp b/src/CudaBackProjectionAlgorithm3D.cpp index 223a9a4..27bb968 100644 --- a/src/CudaBackProjectionAlgorithm3D.cpp +++ b/src/CudaBackProjectionAlgorithm3D.cpp @@ -60,8 +60,8 @@ CCudaBackProjectionAlgorithm3D::CCudaBackProjectionAlgorithm3D() //---------------------------------------------------------------------------------------- // Constructor with initialization CCudaBackProjectionAlgorithm3D::CCudaBackProjectionAlgorithm3D(CProjector3D* _pProjector, - CFloat32ProjectionData3DMemory* _pProjectionData, - CFloat32VolumeData3DMemory* _pReconstruction) + CFloat32ProjectionData3D* _pProjectionData, + CFloat32VolumeData3D* _pReconstruction) { _clear(); initialize(_pProjector, _pProjectionData, _pReconstruction); @@ -145,8 +145,8 @@ bool CCudaBackProjectionAlgorithm3D::initialize(const Config& _cfg) //---------------------------------------------------------------------------------------- // Initialize - C++ bool CCudaBackProjectionAlgorithm3D::initialize(CProjector3D* _pProjector, - CFloat32ProjectionData3DMemory* _pSinogram, - CFloat32VolumeData3DMemory* _pReconstruction) + CFloat32ProjectionData3D* _pSinogram, + CFloat32VolumeData3D* _pReconstruction) { // if already initialized, clear first if (m_bIsInitialized) { @@ -187,17 +187,21 @@ void CCudaBackProjectionAlgorithm3D::run(int _iNrIterations) // check initialized ASTRA_ASSERT(m_bIsInitialized); - CFloat32ProjectionData3DMemory* pSinoMem = dynamic_cast(m_pSinogram); + CFloat32ProjectionData3D* pSinoMem = dynamic_cast(m_pSinogram); ASTRA_ASSERT(pSinoMem); - CFloat32VolumeData3DMemory* pReconMem = dynamic_cast(m_pReconstruction); + CFloat32VolumeData3D* pReconMem = dynamic_cast(m_pReconstruction); ASTRA_ASSERT(pReconMem); const CProjectionGeometry3D* projgeom = pSinoMem->getGeometry(); const CVolumeGeometry3D& volgeom = *pReconMem->getGeometry(); if (m_bSIRTWeighting) { - astraCudaBP_SIRTWeighted(pReconMem->getData(), - pSinoMem->getDataConst(), + CFloat32ProjectionData3DMemory* pSinoMemory = dynamic_cast(m_pSinogram); + ASTRA_ASSERT(pSinoMemory); + CFloat32VolumeData3DMemory* pReconMemory = dynamic_cast(m_pReconstruction); + ASTRA_ASSERT(pReconMemory); + astraCudaBP_SIRTWeighted(pReconMemory->getData(), + pSinoMemory->getDataConst(), &volgeom, projgeom, m_iGPUIndex, m_iVoxelSuperSampling); } else { diff --git a/src/CudaFDKAlgorithm3D.cpp b/src/CudaFDKAlgorithm3D.cpp index d02db6d..d503351 100644 --- a/src/CudaFDKAlgorithm3D.cpp +++ b/src/CudaFDKAlgorithm3D.cpp @@ -59,8 +59,8 @@ CCudaFDKAlgorithm3D::CCudaFDKAlgorithm3D() //---------------------------------------------------------------------------------------- // Constructor with initialization CCudaFDKAlgorithm3D::CCudaFDKAlgorithm3D(CProjector3D* _pProjector, - CFloat32ProjectionData3DMemory* _pProjectionData, - CFloat32VolumeData3DMemory* _pReconstruction) + CFloat32ProjectionData3D* _pProjectionData, + CFloat32VolumeData3D* _pReconstruction) { _clear(); initialize(_pProjector, _pProjectionData, _pReconstruction); @@ -179,8 +179,8 @@ bool CCudaFDKAlgorithm3D::initialize(const Config& _cfg) //---------------------------------------------------------------------------------------- // Initialize - C++ bool CCudaFDKAlgorithm3D::initialize(CProjector3D* _pProjector, - CFloat32ProjectionData3DMemory* _pSinogram, - CFloat32VolumeData3DMemory* _pReconstruction) + CFloat32ProjectionData3D* _pSinogram, + CFloat32VolumeData3D* _pReconstruction) { // if already initialized, clear first if (m_bIsInitialized) { @@ -225,9 +225,9 @@ void CCudaFDKAlgorithm3D::run(int _iNrIterations) ASTRA_ASSERT(conegeom); - CFloat32ProjectionData3DMemory* pSinoMem = dynamic_cast(m_pSinogram); + CFloat32ProjectionData3D* pSinoMem = dynamic_cast(m_pSinogram); ASTRA_ASSERT(pSinoMem); - CFloat32VolumeData3DMemory* pReconMem = dynamic_cast(m_pReconstruction); + CFloat32VolumeData3D* pReconMem = dynamic_cast(m_pReconstruction); ASTRA_ASSERT(pReconMem); const float *filter = NULL; diff --git a/src/CudaForwardProjectionAlgorithm3D.cpp b/src/CudaForwardProjectionAlgorithm3D.cpp index 6783093..ce808eb 100644 --- a/src/CudaForwardProjectionAlgorithm3D.cpp +++ b/src/CudaForwardProjectionAlgorithm3D.cpp @@ -101,14 +101,14 @@ bool CCudaForwardProjectionAlgorithm3D::initialize(const Config& _cfg) node = _cfg.self.getSingleNode("ProjectionDataId"); ASTRA_CONFIG_CHECK(node, "CudaForwardProjection3D", "No ProjectionDataId tag specified."); id = node.getContentInt(); - m_pProjections = dynamic_cast(CData3DManager::getSingleton().get(id)); + m_pProjections = dynamic_cast(CData3DManager::getSingleton().get(id)); CC.markNodeParsed("ProjectionDataId"); // reconstruction data node = _cfg.self.getSingleNode("VolumeDataId"); ASTRA_CONFIG_CHECK(node, "CudaForwardProjection3D", "No VolumeDataId tag specified."); id = node.getContentInt(); - m_pVolume = dynamic_cast(CData3DManager::getSingleton().get(id)); + m_pVolume = dynamic_cast(CData3DManager::getSingleton().get(id)); CC.markNodeParsed("VolumeDataId"); // optional: projector @@ -140,8 +140,8 @@ bool CCudaForwardProjectionAlgorithm3D::initialize(const Config& _cfg) bool CCudaForwardProjectionAlgorithm3D::initialize(CProjector3D* _pProjector, - CFloat32ProjectionData3DMemory* _pProjections, - CFloat32VolumeData3DMemory* _pVolume, + CFloat32ProjectionData3D* _pProjections, + CFloat32VolumeData3D* _pVolume, int _iGPUindex, int _iDetectorSuperSampling) { m_pProjector = _pProjector; diff --git a/src/Float32Data3D.cpp b/src/Float32Data3D.cpp index cad1f18..cc824bd 100644 --- a/src/Float32Data3D.cpp +++ b/src/Float32Data3D.cpp @@ -28,6 +28,10 @@ along with the ASTRA Toolbox. If not, see . #include "astra/Float32Data3D.h" #include +#ifdef ASTRA_CUDA +#include "../../cuda/3d/mem3d.h" +#endif + using namespace std; namespace astra { @@ -60,7 +64,5 @@ std::string CFloat32Data3D::description() const if (getType() == CFloat32Data3D::VOLUME) res << " volume data \t"; return res.str(); } -//---------------------------------------------------------------------------------------- - } // end namespace astra diff --git a/src/Float32Data3DGPU.cpp b/src/Float32Data3DGPU.cpp new file mode 100644 index 0000000..cd9c4ad --- /dev/null +++ b/src/Float32Data3DGPU.cpp @@ -0,0 +1,98 @@ +/* +----------------------------------------------------------------------- +Copyright: 2010-2015, iMinds-Vision Lab, University of Antwerp + 2014-2015, CWI, Amsterdam + +Contact: astra@uantwerpen.be +Website: http://sf.net/projects/astra-toolbox + +This file is part of the 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 . + +----------------------------------------------------------------------- +$Id$ +*/ + +#include "astra/Float32Data3DGPU.h" + +namespace astra { + +//---------------------------------------------------------------------------------------- +// Default constructor. +CFloat32Data3DGPU::CFloat32Data3DGPU() +{ + _clear(); + m_bInitialized = false; +} + +//---------------------------------------------------------------------------------------- +// Destructor. +CFloat32Data3DGPU::~CFloat32Data3DGPU() +{ + if (m_bInitialized) + { + _unInit(); + } +} + +//---------------------------------------------------------------------------------------- +// Initializes an instance of the CFloat32Data3DGPU class with pre-allocated memory +bool CFloat32Data3DGPU::_initialize(int _iWidth, int _iHeight, int _iDepth, astraCUDA3d::MemHandle3D _hnd) +{ + // basic checks + ASTRA_ASSERT(_iWidth > 0); + ASTRA_ASSERT(_iHeight > 0); + ASTRA_ASSERT(_iDepth > 0); + //ASTRA_ASSERT(_pCustomMemory != NULL); + + if (m_bInitialized) { + _unInit(); + } + + // calculate size + m_iWidth = _iWidth; + m_iHeight = _iHeight; + m_iDepth = _iDepth; + m_iSize = (size_t)m_iWidth * m_iHeight * m_iDepth; + + m_hnd = _hnd; + + // initialization complete + return true; +} +//---------------------------------------------------------------------------------------- +// Clear all member variables, setting all numeric variables to 0 and all pointers to NULL. +void CFloat32Data3DGPU::_clear() +{ + m_iWidth = 0; + m_iHeight = 0; + m_iDepth = 0; + m_iSize = 0; + + m_hnd.d.reset(); +} + +//---------------------------------------------------------------------------------------- +// Un-initialize the object, bringing it back in the unitialized state. +void CFloat32Data3DGPU::_unInit() +{ + ASTRA_ASSERT(m_bInitialized); + + _clear(); + m_bInitialized = false; +} + +} // end namespace astra diff --git a/src/Float32Data3DMemory.cpp b/src/Float32Data3DMemory.cpp index 7e60527..5c5c310 100644 --- a/src/Float32Data3DMemory.cpp +++ b/src/Float32Data3DMemory.cpp @@ -163,7 +163,7 @@ bool CFloat32Data3DMemory::_initialize(int _iWidth, int _iHeight, int _iDepth, C ASTRA_ASSERT(_iWidth > 0); ASTRA_ASSERT(_iHeight > 0); ASTRA_ASSERT(_iDepth > 0); - ASTRA_ASSERT(_pCustomMemory != NULL); + //ASTRA_ASSERT(_pCustomMemory != NULL); if (m_bInitialized) { _unInit(); diff --git a/src/Float32ProjectionData3DGPU.cpp b/src/Float32ProjectionData3DGPU.cpp new file mode 100644 index 0000000..0e063d6 --- /dev/null +++ b/src/Float32ProjectionData3DGPU.cpp @@ -0,0 +1,71 @@ +/* +----------------------------------------------------------------------- +Copyright: 2010-2015, iMinds-Vision Lab, University of Antwerp + 2014-2015, CWI, Amsterdam + +Contact: astra@uantwerpen.be +Website: http://sf.net/projects/astra-toolbox + +This file is part of the 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 . + +----------------------------------------------------------------------- +$Id$ +*/ + +#include "astra/Float32ProjectionData3DGPU.h" + +using namespace std; + +namespace astra +{ + +//---------------------------------------------------------------------------------------- +// Default constructor +CFloat32ProjectionData3DGPU::CFloat32ProjectionData3DGPU() : + CFloat32Data3DGPU() +{ + m_pGeometry = NULL; + m_bInitialized = false; +} + +//---------------------------------------------------------------------------------------- +// Create an instance of the CFloat32ProjectionData2D class with pre-allocated data +CFloat32ProjectionData3DGPU::CFloat32ProjectionData3DGPU(CProjectionGeometry3D* _pGeometry, astraCUDA3d::MemHandle3D _hnd) +{ + m_bInitialized = false; + m_bInitialized = initialize(_pGeometry, _hnd); +} + + +//---------------------------------------------------------------------------------------- +// Destructor +CFloat32ProjectionData3DGPU::~CFloat32ProjectionData3DGPU() +{ + delete m_pGeometry; + m_pGeometry = 0; +} + +//---------------------------------------------------------------------------------------- +// Initialization +bool CFloat32ProjectionData3DGPU::initialize(CProjectionGeometry3D* _pGeometry, astraCUDA3d::MemHandle3D _hnd) +{ + m_pGeometry = _pGeometry->clone(); + m_bInitialized = _initialize(m_pGeometry->getDetectorColCount(), m_pGeometry->getProjectionCount(), m_pGeometry->getDetectorRowCount(), _hnd); + return m_bInitialized; +} + +} // end namespace astra diff --git a/src/Float32ProjectionData3DMemory.cpp b/src/Float32ProjectionData3DMemory.cpp index 81daf9e..69033d5 100644 --- a/src/Float32ProjectionData3DMemory.cpp +++ b/src/Float32ProjectionData3DMemory.cpp @@ -114,7 +114,7 @@ bool CFloat32ProjectionData3DMemory::initialize(CProjectionGeometry3D* _pGeometr //---------------------------------------------------------------------------------------- // Initialization -bool CFloat32ProjectionData3DMemory::initialize(CProjectionGeometry3D* _pGeometry, CFloat32CustomMemory* _pCustomMemory) +bool CFloat32ProjectionData3DMemory::initialize(CProjectionGeometry3D* _pGeometry, CFloat32CustomMemory* _pCustomMemory) { m_pGeometry = _pGeometry->clone(); m_bInitialized = _initialize(m_pGeometry->getDetectorColCount(), m_pGeometry->getProjectionCount(), m_pGeometry->getDetectorRowCount(), _pCustomMemory); diff --git a/src/Float32VolumeData3DGPU.cpp b/src/Float32VolumeData3DGPU.cpp new file mode 100644 index 0000000..82a222f --- /dev/null +++ b/src/Float32VolumeData3DGPU.cpp @@ -0,0 +1,71 @@ +/* +----------------------------------------------------------------------- +Copyright: 2010-2015, iMinds-Vision Lab, University of Antwerp + 2014-2015, CWI, Amsterdam + +Contact: astra@uantwerpen.be +Website: http://sf.net/projects/astra-toolbox + +This file is part of the 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 . + +----------------------------------------------------------------------- +$Id$ +*/ + +#include "astra/Float32VolumeData3DGPU.h" + +using namespace std; + +namespace astra +{ + +//---------------------------------------------------------------------------------------- +// Default constructor +CFloat32VolumeData3DGPU::CFloat32VolumeData3DGPU() : + CFloat32Data3DGPU() +{ + m_pGeometry = NULL; + m_bInitialized = false; +} + +//---------------------------------------------------------------------------------------- +// Create an instance of the CFloat32VolumeData2D class with pre-allocated data +CFloat32VolumeData3DGPU::CFloat32VolumeData3DGPU(CVolumeGeometry3D* _pGeometry, astraCUDA3d::MemHandle3D _hnd) +{ + m_bInitialized = false; + m_bInitialized = initialize(_pGeometry, _hnd); +} + + +//---------------------------------------------------------------------------------------- +// Destructor +CFloat32VolumeData3DGPU::~CFloat32VolumeData3DGPU() +{ + delete m_pGeometry; + m_pGeometry = 0; +} + +//---------------------------------------------------------------------------------------- +// Initialization +bool CFloat32VolumeData3DGPU::initialize(CVolumeGeometry3D* _pGeometry, astraCUDA3d::MemHandle3D _hnd) +{ + m_pGeometry = _pGeometry->clone(); + m_bInitialized = _initialize(m_pGeometry->getGridColCount(), m_pGeometry->getGridRowCount(), m_pGeometry->getGridSliceCount(), _hnd); + return m_bInitialized; +} + +} // end namespace astra diff --git a/src/Float32VolumeData3DMemory.cpp b/src/Float32VolumeData3DMemory.cpp index 9f81c85..27ae87b 100644 --- a/src/Float32VolumeData3DMemory.cpp +++ b/src/Float32VolumeData3DMemory.cpp @@ -114,7 +114,7 @@ bool CFloat32VolumeData3DMemory::initialize(CVolumeGeometry3D* _pGeometry, float } //---------------------------------------------------------------------------------------- // Initialization -bool CFloat32VolumeData3DMemory::initialize(CVolumeGeometry3D* _pGeometry, CFloat32CustomMemory* _pCustomMemory) +bool CFloat32VolumeData3DMemory::initialize(CVolumeGeometry3D* _pGeometry, CFloat32CustomMemory* _pCustomMemory) { m_pGeometry = _pGeometry->clone(); m_bInitialized = _initialize(m_pGeometry->getGridColCount(), m_pGeometry->getGridRowCount(), m_pGeometry->getGridSliceCount(), _pCustomMemory); -- cgit v1.2.3 From a922339a8a5a8d7a9672988551c5f15150afcd0e Mon Sep 17 00:00:00 2001 From: Willem Jan Palenstijn Date: Tue, 7 Feb 2017 15:28:26 +0100 Subject: Fix warnings --- src/CompositeGeometryManager.cpp | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) (limited to 'src') diff --git a/src/CompositeGeometryManager.cpp b/src/CompositeGeometryManager.cpp index 74466db..a4dace2 100644 --- a/src/CompositeGeometryManager.cpp +++ b/src/CompositeGeometryManager.cpp @@ -328,6 +328,7 @@ static std::pair reduceProjectionVertical(const CVolumeGeometry3 // reduce self to only cover intersection with projection of VolumePart // (Project corners of volume, take bounding box) + assert(pProjGeom->getProjectionCount() > 0); for (int i = 0; i < pProjGeom->getProjectionCount(); ++i) { double vol_u[8]; @@ -426,9 +427,9 @@ bool CCompositeGeometryManager::CPart::isFull() const { size_t x, y, z; getDims(x, y, z); - return x == pData->getWidth() && - y == pData->getHeight() && - z == pData->getDepth(); + return x == (size_t)pData->getWidth() && + y == (size_t)pData->getHeight() && + z == (size_t)pData->getDepth(); } bool CCompositeGeometryManager::CPart::canSplitAndReduce() const @@ -805,7 +806,7 @@ void CCompositeGeometryManager::CVolumePart::splitX(CCompositeGeometryManager::T size_t blockSize = computeLinearSplit(m, div, sliceCount); int rem = blockSize - (sliceCount % blockSize); - if (rem == blockSize) + if ((size_t)rem == blockSize) rem = 0; ASTRA_DEBUG("From %d to %d step %d", -(rem / 2), sliceCount, blockSize); @@ -856,7 +857,7 @@ void CCompositeGeometryManager::CVolumePart::splitY(CCompositeGeometryManager::T size_t blockSize = computeLinearSplit(m, div, sliceCount); int rem = blockSize - (sliceCount % blockSize); - if (rem == blockSize) + if ((size_t)rem == blockSize) rem = 0; ASTRA_DEBUG("From %d to %d step %d", -(rem / 2), sliceCount, blockSize); @@ -907,7 +908,7 @@ void CCompositeGeometryManager::CVolumePart::splitZ(CCompositeGeometryManager::T size_t blockSize = computeLinearSplit(m, div, sliceCount); int rem = blockSize - (sliceCount % blockSize); - if (rem == blockSize) + if ((size_t)rem == blockSize) rem = 0; ASTRA_DEBUG("From %d to %d step %d", -(rem / 2), sliceCount, blockSize); @@ -1028,7 +1029,7 @@ void CCompositeGeometryManager::CProjectionPart::splitX(CCompositeGeometryManage size_t blockSize = computeLinearSplit(m, div, sliceCount); int rem = blockSize - (sliceCount % blockSize); - if (rem == blockSize) + if ((size_t)rem == blockSize) rem = 0; ASTRA_DEBUG("From %d to %d step %d", -(rem / 2), sliceCount, blockSize); @@ -1076,7 +1077,7 @@ void CCompositeGeometryManager::CProjectionPart::splitZ(CCompositeGeometryManage size_t blockSize = computeLinearSplit(m, div, sliceCount); int rem = blockSize - (sliceCount % blockSize); - if (rem == blockSize) + if ((size_t)rem == blockSize) rem = 0; ASTRA_DEBUG("From %d to %d step %d", -(rem / 2), sliceCount, blockSize); -- cgit v1.2.3