18 #ifndef itkBoxUtilities_h
19 #define itkBoxUtilities_h
44 template <
typename TIterator>
49 typename TIterator::OffsetType offset;
50 it->ClearActiveList();
59 it->ActivateOffset(offset);
67 unsigned int centerIndex = it->GetCenterNeighborhoodIndex();
68 for (
unsigned int d = 0; d < centerIndex; ++d)
70 offset = it->GetOffset(d);
83 it->ActivateOffset(offset);
87 it->DeactivateOffset(offset);
97 template <
typename TInputImage,
typename TOutputImage>
100 const TOutputImage * outputImage,
103 #
if defined(ITKV4_COMPATIBILITY)
111 using InputImageType = TInputImage;
112 using OffsetType =
typename TInputImage::OffsetType;
113 using OutputImageType = TOutputImage;
114 using OutputPixelType =
typename TOutputImage::PixelType;
119 InputIterator inIt(inputImage, inputRegion);
121 kernelRadius.
Fill(1);
123 NOutputIterator noutIt(kernelRadius, outputImage, outputRegion);
129 noutIt.OverrideBoundaryCondition(&oBC);
139 std::vector<int> weights;
140 typename NOutputIterator::ConstIterator sIt;
141 for (
auto idxIt = noutIt.GetActiveIndexList().begin(); idxIt != noutIt.GetActiveIndexList().end(); ++idxIt)
143 OffsetType offset = noutIt.GetOffset(*idxIt);
145 for (
unsigned int k = 0; k < InputImageType::ImageDimension; ++k)
153 weights.push_back(w);
156 for (inIt.GoToBegin(), noutIt.GoToBegin(); !noutIt.IsAtEnd(); ++inIt, ++noutIt)
158 OutputPixelType sum = 0;
160 for (k = 0, sIt = noutIt.Begin(); !sIt.IsAtEnd(); ++sIt, ++k)
162 sum += sIt.Get() * weights[k];
164 noutIt.SetCenterPixel(sum + inIt.Get());
165 #if defined(ITKV4_COMPATIBILITY)
172 template <
typename TImage>
173 std::vector<typename TImage::OffsetType>
179 NIterator n1(unitradius, im, im->GetRequestedRegion());
180 unsigned int centerIndex = n1.GetCenterNeighborhoodIndex();
181 typename NIterator::OffsetType offset;
182 std::vector<typename TImage::OffsetType> result;
183 for (
unsigned int d = 0; d < centerIndex * 2 + 1; ++d)
185 offset = n1.GetOffset(d);
188 for (
unsigned int k = 0; k < TImage::ImageDimension; ++k)
198 result.push_back(offset);
204 template <
typename TInputImage,
typename TOutputImage>
207 TOutputImage * outputImage,
211 #
if defined(ITKV4_COMPATIBILITY)
219 using InputImageType = TInputImage;
223 using OffsetType =
typename TInputImage::OffsetType;
224 using OutputImageType = TOutputImage;
225 using OutputPixelType =
typename TOutputImage::PixelType;
228 using FaceListType =
typename FaceCalculatorType::FaceListType;
229 FaceCalculatorType faceCalculator;
240 for (
unsigned int i = 0; i < TInputImage::ImageDimension; ++i)
242 kernelSize[i] = radius[i] * 2 + 1;
243 internalRadius[i] = radius[i] + 1;
244 regionLimit[i] = inputRegion.GetSize()[i] + regionStart[i] - 1;
249 std::vector<OffsetType> unitCorners = CornerOffsets<TInputImage>(accImage);
250 std::vector<OffsetType> realCorners;
251 std::vector<AccPixType> weights;
253 for (
unsigned int k = 0; k < unitCorners.size(); ++k)
256 OffsetType thisCorner;
257 for (
unsigned int i = 0; i < TInputImage::ImageDimension; ++i)
259 prod *= unitCorners[k][i];
260 if (unitCorners[k][i] > 0)
262 thisCorner[i] = radius[i];
266 thisCorner[i] = -(static_cast<OffsetValueType>(radius[i]) + 1);
269 weights.push_back((AccPixType)prod);
270 realCorners.push_back(thisCorner);
273 FaceListType faceList = faceCalculator(accImage, outputRegion, internalRadius);
275 for (
const auto & face : faceList)
277 if (&face == &faceList.front())
282 AccPixType pixelscount = 1;
283 for (
unsigned int i = 0; i < TInputImage::ImageDimension; ++i)
285 pixelscount *= (AccPixType)(2 * radius[i] + 1);
291 using CornerItVecType = std::vector<InputIteratorType>;
292 CornerItVecType cornerItVec;
294 for (
unsigned int k = 0; k < realCorners.size(); ++k)
297 tReg.
SetIndex(tReg.GetIndex() + realCorners[k]);
298 InputIteratorType tempIt(accImage, tReg);
300 cornerItVec.push_back(tempIt);
303 OutputIteratorType oIt(outputImage, face);
305 for (oIt.GoToBegin(); !oIt.IsAtEnd(); ++oIt)
309 for (
unsigned int k = 0; k < cornerItVec.size(); ++k)
311 sum += weights[k] * cornerItVec[k].Get();
315 oIt.Set(static_cast<OutputPixelType>(sum / pixelscount));
316 #if defined(ITKV4_COMPATIBILITY)
325 OutputIteratorType oIt(outputImage, face);
327 for (oIt.GoToBegin(); !oIt.IsAtEnd(); ++oIt)
333 currentKernelRegion.
SetSize(kernelSize);
337 for (
unsigned int i = 0; i < TInputImage::ImageDimension; ++i)
339 kernelRegionIdx[i] -= radius[i];
341 currentKernelRegion.
SetIndex(kernelRegionIdx);
342 currentKernelRegion.Crop(inputRegion);
343 OffsetValueType edgepixelscount = currentKernelRegion.GetNumberOfPixels();
353 for (
unsigned int k = 0; k < realCorners.size(); ++k)
355 IndexType thisCorner = centIndex + realCorners[k];
356 bool includeCorner =
true;
357 for (
unsigned int j = 0; j < TInputImage::ImageDimension; ++j)
359 if (unitCorners[k][j] > 0)
362 if (thisCorner[j] > static_cast<OffsetValueType>(regionLimit[j]))
364 thisCorner[j] = static_cast<OffsetValueType>(regionLimit[j]);
370 if (thisCorner[j] < regionStart[j])
372 includeCorner =
false;
379 sum += accImage->GetPixel(thisCorner) * weights[k];
383 oIt.Set(static_cast<OutputPixelType>(sum / (AccPixType)edgepixelscount));
384 #if defined(ITKV4_COMPATIBILITY)
392 template <
typename TInputImage,
typename TOutputImage>
395 TOutputImage * outputImage,
399 #
if defined(ITKV4_COMPATIBILITY)
407 using InputImageType = TInputImage;
411 using OffsetType =
typename TInputImage::OffsetType;
412 using OutputImageType = TOutputImage;
413 using OutputPixelType =
typename TOutputImage::PixelType;
414 using InputPixelType =
typename TInputImage::PixelType;
417 using FaceListType =
typename FaceCalculatorType::FaceListType;
418 FaceCalculatorType faceCalculator;
428 for (
unsigned int i = 0; i < TInputImage::ImageDimension; ++i)
430 kernelSize[i] = radius[i] * 2 + 1;
431 internalRadius[i] = radius[i] + 1;
432 regionLimit[i] = inputRegion.GetSize()[i] + regionStart[i] - 1;
437 std::vector<OffsetType> unitCorners = CornerOffsets<TInputImage>(accImage);
438 std::vector<OffsetType> realCorners;
439 std::vector<AccPixType> weights;
441 for (
unsigned int k = 0; k < unitCorners.size(); ++k)
444 OffsetType thisCorner;
445 for (
unsigned int i = 0; i < TInputImage::ImageDimension; ++i)
447 prod *= unitCorners[k][i];
448 if (unitCorners[k][i] > 0)
450 thisCorner[i] = radius[i];
454 thisCorner[i] = -(static_cast<OffsetValueType>(radius[i]) + 1);
457 weights.push_back((AccPixType)prod);
458 realCorners.push_back(thisCorner);
461 FaceListType faceList = faceCalculator(accImage, outputRegion, internalRadius);
463 for (
const auto & face : faceList)
465 if (&face == &faceList.front())
470 AccPixType pixelscount = 1;
471 for (
unsigned int i = 0; i < TInputImage::ImageDimension; ++i)
473 pixelscount *= (AccPixType)(2 * radius[i] + 1);
479 using CornerItVecType = std::vector<InputIteratorType>;
480 CornerItVecType cornerItVec;
482 for (
unsigned int k = 0; k < realCorners.size(); ++k)
485 tReg.
SetIndex(tReg.GetIndex() + realCorners[k]);
486 InputIteratorType tempIt(accImage, tReg);
488 cornerItVec.push_back(tempIt);
491 OutputIteratorType oIt(outputImage, face);
493 for (oIt.GoToBegin(); !oIt.IsAtEnd(); ++oIt)
496 AccPixType squareSum = 0;
498 for (
unsigned int k = 0; k < cornerItVec.size(); ++k)
500 const InputPixelType & i = cornerItVec[k].Get();
501 sum += weights[k] * i[0];
502 squareSum += weights[k] * i[1];
507 oIt.Set(static_cast<OutputPixelType>(std::sqrt((squareSum - sum * sum / pixelscount) / (pixelscount - 1))));
508 #if defined(ITKV4_COMPATIBILITY)
517 OutputIteratorType oIt(outputImage, face);
519 for (oIt.GoToBegin(); !oIt.IsAtEnd(); ++oIt)
525 currentKernelRegion.
SetSize(kernelSize);
529 for (
unsigned int i = 0; i < TInputImage::ImageDimension; ++i)
531 kernelRegionIdx[i] -= radius[i];
533 currentKernelRegion.
SetIndex(kernelRegionIdx);
534 currentKernelRegion.Crop(inputRegion);
535 SizeValueType edgepixelscount = currentKernelRegion.GetNumberOfPixels();
537 AccPixType squareSum = 0;
546 for (
unsigned int k = 0; k < realCorners.size(); ++k)
548 IndexType thisCorner = centIndex + realCorners[k];
549 bool includeCorner =
true;
550 for (
unsigned int j = 0; j < TInputImage::ImageDimension; ++j)
552 if (unitCorners[k][j] > 0)
555 if (thisCorner[j] > static_cast<OffsetValueType>(regionLimit[j]))
557 thisCorner[j] = static_cast<OffsetValueType>(regionLimit[j]);
563 if (thisCorner[j] < regionStart[j])
565 includeCorner =
false;
572 const InputPixelType & i = accImage->GetPixel(thisCorner);
573 sum += weights[k] * i[0];
574 squareSum += weights[k] * i[1];
579 static_cast<OutputPixelType>(std::sqrt((squareSum - sum * sum / edgepixelscount) / (edgepixelscount - 1))));
580 #if defined(ITKV4_COMPATIBILITY)
588 template <
typename TInputImage,
typename TOutputImage>
591 TOutputImage * outputImage,
594 #
if defined(ITKV4_COMPATIBILITY)
602 using InputImageType = TInputImage;
603 using OffsetType =
typename TInputImage::OffsetType;
604 using OutputImageType = TOutputImage;
605 using OutputPixelType =
typename TOutputImage::PixelType;
606 using ValueType =
typename OutputPixelType::ValueType;
607 using InputPixelType =
typename TInputImage::PixelType;
612 InputIterator inIt(inputImage, inputRegion);
614 kernelRadius.
Fill(1);
616 NOutputIterator noutIt(kernelRadius, outputImage, outputRegion);
622 noutIt.OverrideBoundaryCondition(&oBC);
632 std::vector<int> weights;
633 typename NOutputIterator::ConstIterator sIt;
634 for (
auto idxIt = noutIt.GetActiveIndexList().begin(); idxIt != noutIt.GetActiveIndexList().end(); ++idxIt)
636 OffsetType offset = noutIt.GetOffset(*idxIt);
638 for (
unsigned int k = 0; k < InputImageType::ImageDimension; ++k)
645 weights.push_back(w);
648 for (inIt.GoToBegin(), noutIt.GoToBegin(); !noutIt.IsAtEnd(); ++inIt, ++noutIt)
651 ValueType squareSum = 0;
653 for (k = 0, sIt = noutIt.Begin(); !sIt.IsAtEnd(); ++sIt, ++k)
655 const OutputPixelType & v = sIt.Get();
656 sum += v[0] * weights[k];
657 squareSum += v[1] * weights[k];
660 const InputPixelType & i = inIt.Get();
662 o[1] = squareSum + i * i;
663 noutIt.SetCenterPixel(o);
664 #if defined(ITKV4_COMPATIBILITY)