orthanc: Core/Images/ImageProcessing.cpp comparison

comparison Core/Images/ImageProcessing.cpp @ 3682:5f64c866108a

merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 24 Feb 2020 16:26:59 +0100
parents	94f4a18a79cc
children	12253ddefe5a

comparison

equal deleted inserted replaced

-:453c0ece560a
+:5f64c866108a
 #include "PixelTraits.h"
 #include "../OrthancException.h"
 #ifdef __EMSCRIPTEN__
 /*
 Avoid this error:
 -----------------
 .../boost/math/special_functions/round.hpp:118:12: warning: implicit conversion from 'std::__2::numeric_limits<long long>::type' (aka 'long long') to 'float' changes value from 9223372036854775807 to 9223372036854775808 [-Wimplicit-int-float-conversion]
 .../mnt/c/osi/dev/orthanc/Core/Images/ImageProcessing.cpp:333:28: note: in instantiation of function template specialization 'boost::math::llround<float>' requested here
 .../mnt/c/osi/dev/orthanc/Core/Images/ImageProcessing.cpp:1006:9: note: in instantiation of function template specialization 'Orthanc::MultiplyConstantInternal<unsigned char, true>' requested here
 */
 #pragma GCC diagnostic ignored "-Wimplicit-int-float-conversion"
 #endif
 #include <boost/math/special_functions/round.hpp>
 }
 }
 }
-template <typename PixelType,
+// Computes "a * x + b" at each pixel => Note that this is not the
-bool UseRound>
+// same convention as in "ShiftScale()"
-static void ShiftScaleInternal(ImageAccessor& image,
+template <typename TargetType,
-float offset,
+typename SourceType,
-float scaling,
+bool UseRound,
-const PixelType LowestValue = std::numeric_limits<PixelType>::min())
+bool Invert>
-{
+static void ShiftScaleInternal(ImageAccessor& target,
-const PixelType minPixelValue = LowestValue;
+const ImageAccessor& source,
-const PixelType maxPixelValue = std::numeric_limits<PixelType>::max();
+float a,
+float b,
+const TargetType LowestValue)
+// This function can be applied inplace (source == target)
+{
+if (source.GetWidth() != target.GetWidth() ||
+source.GetHeight() != target.GetHeight())
+{
+throw OrthancException(ErrorCode_IncompatibleImageSize);
+}
+if (&source == &target &&
+source.GetFormat() != target.GetFormat())
+{
+throw OrthancException(ErrorCode_IncompatibleImageFormat);
+}
+const TargetType minPixelValue = LowestValue;
+const TargetType maxPixelValue = std::numeric_limits<TargetType>::max();
 const float minFloatValue = static_cast<float>(LowestValue);
 const float maxFloatValue = static_cast<float>(maxPixelValue);
-const unsigned int height = image.GetHeight();
+const unsigned int height = target.GetHeight();
-const unsigned int width = image.GetWidth();
+const unsigned int width = target.GetWidth();
 for (unsigned int y = 0; y < height; y++)
 {
-PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y));
+TargetType* p = reinterpret_cast<TargetType*>(target.GetRow(y));
+const SourceType* q = reinterpret_cast<const SourceType*>(source.GetRow(y));
-for (unsigned int x = 0; x < width; x++, p++)
-{
+for (unsigned int x = 0; x < width; x++, p++, q++)
-float v = (static_cast<float>(*p) + offset) * scaling;
+{
+float v = a * static_cast<float>(*q) + b;
 if (v >= maxFloatValue)
 {
 *p = maxPixelValue;
 }
 *p = minPixelValue;
 }
 else if (UseRound)
 {
 // The "round" operation is very costly
-*p = static_cast<PixelType>(boost::math::iround(v));
+*p = static_cast<TargetType>(boost::math::iround(v));
 }
 else
 {
-*p = static_cast<PixelType>(v);
+*p = static_cast<TargetType>(std::floor(v));
+}
+if (Invert)
+{
+*p = maxPixelValue - *p;
 }
 }
 }
 }
 float windowWidth,
 float rescaleSlope,
 float rescaleIntercept,
 bool invert)
 {
+assert(sizeof(SourceType) == source.GetBytesPerPixel() &&
+sizeof(TargetType) == target.GetBytesPerPixel());
 // WARNING - "::min()" should be replaced by "::lowest()" if
 // dealing with float or double (which is not the case so far)
 assert(sizeof(TargetType) <= 2);  // Safeguard to remember about "float/double"
 const TargetType minTargetValue = std::numeric_limits<TargetType>::min();
 const TargetType maxTargetValue = std::numeric_limits<TargetType>::max();
-const float minFloatValue = static_cast<float>(minTargetValue);
 const float maxFloatValue = static_cast<float>(maxTargetValue);
 const float windowIntercept = windowCenter - windowWidth / 2.0f;
 const float windowSlope = (maxFloatValue + 1.0f) / windowWidth;
-const unsigned int width = source.GetWidth();
+const float a = rescaleSlope * windowSlope;
-const unsigned int height = source.GetHeight();
+const float b = (rescaleIntercept - windowIntercept) * windowSlope;
-for (unsigned int y = 0; y < height; y++)
+if (invert)
 {
-TargetType* t = reinterpret_cast<TargetType*>(target.GetRow(y));
+ShiftScaleInternal<TargetType, SourceType, false, true>(target, source, a, b, minTargetValue);
-const SourceType* s = reinterpret_cast<const SourceType*>(source.GetConstRow(y));
+}
+else
-for (unsigned int x = 0; x < width; x++, t++, s++)
+{
-{
+ShiftScaleInternal<TargetType, SourceType, false, false>(target, source, a, b, minTargetValue);
-float rescaledValue = *s * rescaleSlope + rescaleIntercept;
-float v = (rescaledValue - windowIntercept) * windowSlope;
-if (v <= minFloatValue)
-{
-v = minFloatValue;
-}
-else if (v >= maxFloatValue)
-{
-v = maxFloatValue;
-}
-TargetType vv = static_cast<TargetType>(v);
-if (invert)
-{
-vv = maxTargetValue - vv;
-}
-*t = static_cast<TargetType>(vv);
-}
 }
 }
 void ImageProcessing::ApplyWindowing(ImageAccessor& target,
 const ImageAccessor& source,
 {
 case Orthanc::PixelFormat_Float32:
 {
 switch (target.GetFormat())
 {
 case Orthanc::PixelFormat_Grayscale8:
 ApplyWindowingInternal<uint8_t, float>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert);
 break;
 case Orthanc::PixelFormat_Grayscale16:
 ApplyWindowingInternal<uint16_t, float>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert);
 break;
 default:
 throw OrthancException(ErrorCode_NotImplemented);
 }
 };break;
 case Orthanc::PixelFormat_Grayscale8:
 {
 switch (target.GetFormat())
 {
 case Orthanc::PixelFormat_Grayscale8:
 ApplyWindowingInternal<uint8_t, uint8_t>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert);
 break;
 case Orthanc::PixelFormat_Grayscale16:
 ApplyWindowingInternal<uint16_t, uint8_t>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert);
 break;
 default:
 throw OrthancException(ErrorCode_NotImplemented);
 }
 };break;
 case Orthanc::PixelFormat_Grayscale16:
 {
 switch (target.GetFormat())
 {
 case Orthanc::PixelFormat_Grayscale8:
 ApplyWindowingInternal<uint8_t, uint16_t>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert);
 break;
 case Orthanc::PixelFormat_Grayscale16:
 ApplyWindowingInternal<uint16_t, uint16_t>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert);
 break;
 default:
 throw OrthancException(ErrorCode_NotImplemented);
 }
 };break;
 default:
 throw OrthancException(ErrorCode_NotImplemented);
 }
 case PixelFormat_Grayscale16:
 {
 ShiftRightInternal<uint16_t>(image, shift);
 break;
 }
 default:
 throw OrthancException(ErrorCode_NotImplemented);
 }
 }
 void ImageProcessing::ShiftLeft(ImageAccessor& image,
 case PixelFormat_Grayscale16:
 {
 ShiftLeftInternal<uint16_t>(image, shift);
 break;
 }
 default:
 throw OrthancException(ErrorCode_NotImplemented);
 }
 }
 void ImageProcessing::GetMinMaxIntegerValue(int64_t& minValue,
 void ImageProcessing::ShiftScale(ImageAccessor& image,
 float offset,
 float scaling,
 bool useRound)
 {
+// Rewrite "(x + offset) * scaling" as "a * x + b"
+const float a = scaling;
+const float b = offset * scaling;
 switch (image.GetFormat())
 {
 case PixelFormat_Grayscale8:
 if (useRound)
 {
-ShiftScaleInternal<uint8_t, true>(image, offset, scaling);
+ShiftScaleInternal<uint8_t, uint8_t, true, false>(image, image, a, b, std::numeric_limits<uint8_t>::min());
 }
 else
 {
-ShiftScaleInternal<uint8_t, false>(image, offset, scaling);
+ShiftScaleInternal<uint8_t, uint8_t, false, false>(image, image, a, b, std::numeric_limits<uint8_t>::min());
 }
 return;
 case PixelFormat_Grayscale16:
 if (useRound)
 {
-ShiftScaleInternal<uint16_t, true>(image, offset, scaling);
+ShiftScaleInternal<uint16_t, uint16_t, true, false>(image, image, a, b, std::numeric_limits<uint16_t>::min());
 }
 else
 {
-ShiftScaleInternal<uint16_t, false>(image, offset, scaling);
+ShiftScaleInternal<uint16_t, uint16_t, false, false>(image, image, a, b, std::numeric_limits<uint16_t>::min());
 }
 return;
 case PixelFormat_SignedGrayscale16:
 if (useRound)
 {
-ShiftScaleInternal<int16_t, true>(image, offset, scaling);
+ShiftScaleInternal<int16_t, int16_t, true, false>(image, image, a, b, std::numeric_limits<int16_t>::min());
 }
 else
 {
-ShiftScaleInternal<int16_t, false>(image, offset, scaling);
+ShiftScaleInternal<int16_t, int16_t, false, false>(image, image, a, b, std::numeric_limits<int16_t>::min());
 }
 return;
 case PixelFormat_Float32:
+// "::min()" must be replaced by "::lowest()" if dealing with float or double
 if (useRound)
 {
-ShiftScaleInternal<float, true>(image, offset, scaling, -std::numeric_limits<float>::max());
+ShiftScaleInternal<float, float, true, false>(image, image, a, b, std::numeric_limits<float>::lowest());
 }
 else
 {
-ShiftScaleInternal<float, false>(image, offset, scaling, -std::numeric_limits<float>::max());
+ShiftScaleInternal<float, float, false, false>(image, image, a, b, std::numeric_limits<float>::lowest());
 }
 return;
 default:
 throw OrthancException(ErrorCode_NotImplemented);
 }
 }
 // Deal with the right border
 for (unsigned int x = static_cast<unsigned int>(
 horizontalAnchor + width - horizontal.size() + 1); x < width; x++)
 {
 for (unsigned int c = 0; c < ChannelsCount; c++, p++)
 {
 *p = GetHorizontalConvolutionFloatSecure<RawPixel, ChannelsCount>
 (image, horizontal, horizontalAnchor, x, y, leftBorder[c], rightBorder[c], c);

Mercurial > hg > orthanc

comparison Core/Images/ImageProcessing.cpp @ 3682:5f64c866108a