/* // // Copyright 1997-2009 Torsten Rohlfing // // Copyright 2004-2013 SRI International // // This file is part of the Computational Morphometry Toolkit. // // http://www.nitrc.org/projects/cmtk/ // // The Computational Morphometry Toolkit 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 Computational Morphometry Toolkit 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 Computational Morphometry Toolkit. If not, see // . // // $Revision: 4982 $ // // $LastChangedDate: 2013-10-14 12:54:26 -0700 (Mon, 14 Oct 2013) $ // // $LastChangedBy: torstenrohlfing $ // */ namespace cmtk { /** \addtogroup Registration */ //@{ SplineWarpGroupwiseRegistrationRMIFunctional::ReturnType SplineWarpGroupwiseRegistrationRMIFunctional::EvaluateWithGradient ( CoordinateVector& v, CoordinateVector& g, const Types::Coordinate step ) { const size_t numberOfThreads = Threads::GetNumberOfThreads(); const size_t numberOfXforms = this->m_XformVector.size(); const Self::ReturnType baseValue = this->EvaluateAt( v ); if ( this->m_NeedsUpdateInformationByControlPoint ) { this->UpdateInformationByControlPoint(); } // allocate sufficiently many local thread data const size_t safeNumberOfThreads = std::min( numberOfThreads, this->m_ControlPointScheduleOverlapFreeMaxLength ); if ( this->m_ThreadSumOfProductsMatrix.size() < (6 * numberOfXforms * safeNumberOfThreads) ) { this->m_ThreadSumOfProductsMatrix.resize( 6 * numberOfXforms * safeNumberOfThreads ); } if ( this->m_ThreadSumsVector.size() < (6 * numberOfXforms * safeNumberOfThreads) ) { this->m_ThreadSumsVector.resize( 6 * numberOfXforms * safeNumberOfThreads ); } ThreadParameterArray threadParams( this, safeNumberOfThreads ); for ( size_t thread = 0; thread < safeNumberOfThreads; ++thread ) { threadParams[thread].m_ThreadStorageIndex = thread; threadParams[thread].m_Step = step; threadParams[thread].m_Gradient = g.Elements; threadParams[thread].m_MetricBaseValue = baseValue; } threadParams.RunInParallelFIFO( EvaluateLocalGradientThreadFunc, this->m_ControlPointSchedule.size() ); if ( this->m_PartialGradientMode ) { const Types::Coordinate gthresh = g.MaxNorm() * this->m_PartialGradientThreshold; for ( size_t param = 0; param < g.Dim; ++param ) if ( fabs( g[param] ) < gthresh ) { g[param] = this->m_ParamStepArray[param] = 0.0; } } if ( this->m_ForceZeroSum ) { this->ForceZeroSumGradient( g ); } return baseValue; } CMTK_THREAD_RETURN_TYPE SplineWarpGroupwiseRegistrationRMIFunctional::EvaluateLocalGradientThreadFunc ( void* args ) { EvaluateLocalGradientThreadParameters* threadParameters = static_cast( args ); Self* This = threadParameters->thisObject; const Self* ThisConst = threadParameters->thisObject; const size_t threadID = threadParameters->ThisThreadIndex; const size_t threadStorageIndex = threadParameters->m_ThreadStorageIndex; if ( !(threadID % 100) ) { std::cerr << threadID << " / " << ThisConst->m_ControlPointSchedule.size() << "\r"; } const size_t cpIndex = ThisConst->m_ControlPointSchedule[threadID]; std::vector::const_iterator voi = ThisConst->m_VolumeOfInfluenceArray.begin() + cpIndex; const size_t pixelsPerLineVOI = (voi->To()[0]-voi->From()[0]); std::vector vectorList( pixelsPerLineVOI ); std::vector count( pixelsPerLineVOI ); const size_t numberOfXforms = ThisConst->m_XformVector.size(); std::vector totalNumberOfSamples( 6 * numberOfXforms ); std::fill( totalNumberOfSamples.begin(), totalNumberOfSamples.end(), ThisConst->m_TotalNumberOfSamples ); const size_t parametersPerXform = ThisConst->m_ParametersPerXform; const size_t paramVectorDim = ThisConst->ParamVectorDim(); const byte paddingValue = ThisConst->m_PaddingValue; const size_t imagesFrom = ThisConst->m_ActiveImagesFrom; const size_t imagesTo = ThisConst->m_ActiveImagesTo; const size_t numberOfImages = imagesTo - imagesFrom; const UniformVolume* templateGrid = ThisConst->m_TemplateGrid; const size_t threadDataIdx = 6 * threadStorageIndex * numberOfXforms; for ( size_t image = 0; image < 6 * numberOfXforms; ++image ) { const SumsAndProductsVectorType& srcSumOfProducts = ThisConst->m_SumOfProductsMatrix; SumsAndProductsVectorType& dstSumOfProducts = This->m_ThreadSumOfProductsMatrix[threadDataIdx + image]; dstSumOfProducts.resize( srcSumOfProducts.size() ); std::copy( srcSumOfProducts.begin(), srcSumOfProducts.end(), dstSumOfProducts.begin() ); const SumsAndProductsVectorType& srcSumsVector = ThisConst->m_SumsVector; SumsAndProductsVectorType& dstSumsVector = This->m_ThreadSumsVector[threadDataIdx + image]; dstSumsVector.resize( srcSumsVector.size() ); std::copy( srcSumsVector.begin(), srcSumsVector.end(), dstSumsVector.begin() ); } for ( int z = voi->From()[2]; (z < voi->To()[2]); ++z ) { for ( int y = voi->From()[1]; (y < voi->To()[1]); ++y ) { // check which pixels in this row have a full sample count const size_t rowofs = templateGrid->GetOffsetFromIndex( voi->From()[0], y, z ); std::fill( count.begin(), count.end(), 0 ); for ( size_t img = 0; img < numberOfXforms; ++img ) { const byte* dataPtr = ThisConst->m_Data[img]+rowofs; for ( size_t x = 0; x < pixelsPerLineVOI; ++x ) { const byte dataThisPixel = dataPtr[x]; if ( dataThisPixel != paddingValue ) { ++count[x]; } } } size_t cparam = 3 * cpIndex; size_t currentParameter = 0; for ( size_t img = 0; img < numberOfXforms; ++img, cparam += parametersPerXform ) { SplineWarpXform::SmartPtr xform = This->GetXformByIndex(img); const UniformVolume* target = ThisConst->m_ImageVector[img]; const byte* targetDataPtr = static_cast( target->GetData()->GetDataPtr() ); for ( size_t dim = 0; dim < 3; ++dim ) { const size_t cdparam = cparam + dim; const size_t xfparam = 3 * cpIndex + dim; const Types::Coordinate pStep = ThisConst->m_ParamStepArray[cdparam] * threadParameters->m_Step; if ( pStep > 0 ) { const Types::Coordinate v0 = xform->GetParameter( xfparam ); for ( int delta = 0; delta < 2; ++delta, ++currentParameter ) { SumsAndProductsVectorType& dstSumOfProducts = This->m_ThreadSumOfProductsMatrix[threadDataIdx+currentParameter]; SumsAndProductsVectorType& dstSumsVector = This->m_ThreadSumsVector[threadDataIdx+currentParameter]; Types::Coordinate vTest = v0 + (2*delta-1) * pStep; xform->SetParameter( xfparam, vTest ); xform->GetTransformedGridRow( pixelsPerLineVOI, &(vectorList[0]), voi->From()[0], y, z ); byte* rowDataPtr = ThisConst->m_Data[img] + rowofs; for ( size_t x = 0; x < pixelsPerLineVOI; ++x, ++rowDataPtr ) { const byte baselineData = *rowDataPtr; if ( (count[x] == numberOfImages) || ((count[x] == numberOfImages-1) && (baselineData == paddingValue) ) ) // full count? { byte newData; if ( !target->ProbeData( newData, targetDataPtr, vectorList[x] ) ) newData = paddingValue; if ( newData != baselineData ) { if ( baselineData != paddingValue ) { dstSumsVector[img] -= baselineData; size_t midx = 0; for ( size_t img2 = imagesFrom; img2 < imagesTo; ++img2 ) { for ( size_t otherImg = imagesFrom; otherImg <= img2; ++otherImg, ++midx ) { if ( img2 == img ) { const byte otherData = ThisConst->m_Data[otherImg][rowofs+x]; dstSumOfProducts[midx] -= baselineData * otherData; } else { if ( otherImg == img ) { const byte otherData = ThisConst->m_Data[img2][rowofs+x]; dstSumOfProducts[midx] -= baselineData * otherData; } } } } } if ( newData != paddingValue ) { if ( count[x] == numberOfImages-1 ) { ++totalNumberOfSamples[currentParameter]; } dstSumsVector[img] += newData; size_t midx = 0; for ( size_t img2 = imagesFrom; img2 < imagesTo; ++img2 ) { for ( size_t otherImg = imagesFrom; otherImg <= img2; ++otherImg, ++midx ) { if ( img2 == img ) { if ( otherImg == img ) { dstSumOfProducts[midx] += newData * newData; } else { const byte otherData = ThisConst->m_Data[otherImg][rowofs+x]; dstSumOfProducts[midx] += newData * otherData; } } else { if ( otherImg == img ) { const byte otherData = ThisConst->m_Data[img2][rowofs+x]; dstSumOfProducts[midx] += newData * otherData; } } } } } else { if ( count[x] == numberOfImages ) { --totalNumberOfSamples[currentParameter]; } } } } } } xform->SetParameter( xfparam, v0 ); } else { currentParameter += 2; } } } } } Self::CovarianceMatrixType covarianceMatrix( numberOfImages ); // approximate gradient from upper and lower function evaluations size_t img = 0, currentParameter = 0; const Functional::ReturnType fBaseValue = threadParameters->m_MetricBaseValue; for ( size_t cparam = 3*cpIndex; cparam < paramVectorDim; cparam += parametersPerXform ) { for ( size_t dim = 0; dim < 3; ++dim, ++img, currentParameter += 2 ) { const Self::ReturnType fMinus = ThisConst->GetMetric( This->m_ThreadSumOfProductsMatrix[threadDataIdx+currentParameter], This->m_ThreadSumsVector[threadDataIdx+currentParameter], totalNumberOfSamples[currentParameter], covarianceMatrix ); const Self::ReturnType fPlus = ThisConst->GetMetric( This->m_ThreadSumOfProductsMatrix[threadDataIdx+currentParameter+1], This->m_ThreadSumsVector[threadDataIdx+currentParameter+1], totalNumberOfSamples[currentParameter], covarianceMatrix ); if ( (fPlus > fBaseValue) || (fMinus > fBaseValue) ) { threadParameters->m_Gradient[cparam+dim] = fPlus - fMinus; } else { threadParameters->m_Gradient[cparam+dim] = 0.0; } } } return CMTK_THREAD_RETURN_VALUE; } } // namespace cmtk