orthanc: OrthancFramework/Sources/Images/ImageProcessing.cpp comparison

comparison OrthancFramework/Sources/Images/ImageProcessing.cpp @ 4065:d6362b2c4b61 framework

export dcmdata in shared library, rounding in convolution tests

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 11 Jun 2020 18:04:28 +0200
parents	55727d85f419
children	259c33759937

comparison

equal deleted inserted replaced

-:e00f3d089991
+:d6362b2c4b61
 for (unsigned int x = 0; x < width; x++, p++)
 {
 int64_t v;
 if (UseRound)
 {
+assert(sizeof(long long) == sizeof(int64_t));
 // The "round" operation is very costly
 v = boost::math::llround(static_cast<float>(*p) * factor);
 }
 else
 {
 else if (v <= minFloatValue)
 {
 *p = minPixelValue;
 }
 else if (UseRound)
 {
 // The "round" operation is very costly
+assert(sizeof(TargetType) < sizeof(int));
 *p = static_cast<TargetType>(boost::math::iround(v));
 }
 else
 {
 *p = static_cast<TargetType>(std::floor(v));
 // This is an implementation of separable convolution that uses
 // floating-point arithmetics, and an intermediate Float32
 // image. The out-of-image values are taken as the border
 // value. Further optimization is possible.
-template <typename RawPixel, unsigned int ChannelsCount>
+template <typename RawPixel, unsigned int ChannelsCount, bool UseRound>
 static void SeparableConvolutionFloat(ImageAccessor& image /* inplace */,
 const std::vector<float>& horizontal,
 size_t horizontalAnchor,
 const std::vector<float>& vertical,
 size_t verticalAnchor,
 {
 *p = std::numeric_limits<RawPixel>::max();
 }
 else
 {
-*p = static_cast<RawPixel>(accumulator);
+if (UseRound)
+{
+assert(sizeof(RawPixel) < sizeof(int));
+*p = static_cast<RawPixel>(boost::math::iround(accumulator));
+}
+else
+{
+*p = static_cast<RawPixel>(accumulator);
+}
 }
 }
 }
 }
 }
 void ImageProcessing::SeparableConvolution(ImageAccessor& image /* inplace */,
 const std::vector<float>& horizontal,
 size_t horizontalAnchor,
 const std::vector<float>& vertical,
-size_t verticalAnchor)
+size_t verticalAnchor,
+bool useRound)
 {
 if (horizontal.size() == 0 ||
 vertical.size() == 0 ||
 horizontalAnchor >= horizontal.size() ||
 verticalAnchor >= vertical.size())
 const float normalization = 1.0f / (sumHorizontal * sumVertical);
 switch (image.GetFormat())
 {
 case PixelFormat_Grayscale8:
-SeparableConvolutionFloat<uint8_t, 1u>
+if (useRound)
-(image, horizontal, horizontalAnchor, vertical, verticalAnchor, normalization);
+{
+SeparableConvolutionFloat<uint8_t, 1u, true>
+(image, horizontal, horizontalAnchor, vertical, verticalAnchor, normalization);
+}
+else
+{
+SeparableConvolutionFloat<uint8_t, 1u, false>
+(image, horizontal, horizontalAnchor, vertical, verticalAnchor, normalization);
+}
 break;
 case PixelFormat_RGB24:
-SeparableConvolutionFloat<uint8_t, 3u>
+if (useRound)
-(image, horizontal, horizontalAnchor, vertical, verticalAnchor, normalization);
+{
+SeparableConvolutionFloat<uint8_t, 3u, true>
+(image, horizontal, horizontalAnchor, vertical, verticalAnchor, normalization);
+}
+else
+{
+SeparableConvolutionFloat<uint8_t, 3u, false>
+(image, horizontal, horizontalAnchor, vertical, verticalAnchor, normalization);
+}
 break;
 default:
 throw OrthancException(ErrorCode_NotImplemented);
 }
 }
-void ImageProcessing::SmoothGaussian5x5(ImageAccessor& image)
+void ImageProcessing::SmoothGaussian5x5(ImageAccessor& image,
+bool useRound)
 {
 std::vector<float> kernel(5);
 kernel[0] = 1;
 kernel[1] = 4;
 kernel[2] = 6;
 kernel[3] = 4;
 kernel[4] = 1;
-SeparableConvolution(image, kernel, 2, kernel, 2);
+SeparableConvolution(image, kernel, 2, kernel, 2, useRound);
 }
 void ImageProcessing::FitSize(ImageAccessor& target,
 const ImageAccessor& source)
 static_cast<float>(target.GetWidth()) / cw,
 static_cast<float>(target.GetHeight()) / ch);
 unsigned int sw = std::min(static_cast<unsigned int>(boost::math::iround(cw * r)), target.GetWidth());
 unsigned int sh = std::min(static_cast<unsigned int>(boost::math::iround(ch * r)), target.GetHeight());
 Image resized(target.GetFormat(), sw, sh, false);
 //ImageProcessing::SmoothGaussian5x5(source);
 ImageProcessing::Resize(resized, source);

Mercurial > hg > orthanc

comparison OrthancFramework/Sources/Images/ImageProcessing.cpp @ 4065:d6362b2c4b61 framework