Mercurial > hg > orthanc
annotate OrthancFramework/Sources/Images/ImageProcessing.cpp @ 4831:7053502fbf97
added copyright UCLouvain
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Thu, 25 Nov 2021 19:01:11 +0100 |
| parents | ebb801d44e06 |
| children | 43e613a7756b |
| rev | line source |
|---|---|
| 853 | 1 /** |
| 2 * Orthanc - A Lightweight, RESTful DICOM Store | |
| 1900 | 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics |
|
1288
6e7e5ed91c2d
upgrade to year 2015
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
993
diff
changeset
|
4 * Department, University Hospital of Liege, Belgium |
|
4437
d9473bd5ed43
upgrade to year 2021
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4300
diff
changeset
|
5 * Copyright (C) 2017-2021 Osimis S.A., Belgium |
|
4831
7053502fbf97
added copyright UCLouvain
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4780
diff
changeset
|
6 * Copyright (C) 2021-2021 Sebastien Jodogne, ICTEAM UCLouvain, Belgium |
| 853 | 7 * |
| 8 * This program is free software: you can redistribute it and/or | |
|
4119
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4083
diff
changeset
|
9 * modify it under the terms of the GNU Lesser General Public License |
|
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4083
diff
changeset
|
10 * as published by the Free Software Foundation, either version 3 of |
|
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4083
diff
changeset
|
11 * the License, or (at your option) any later version. |
| 3227 | 12 * |
| 853 | 13 * This program is distributed in the hope that it will be useful, but |
| 14 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
|
4119
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4083
diff
changeset
|
16 * Lesser General Public License for more details. |
| 853 | 17 * |
|
4119
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4083
diff
changeset
|
18 * You should have received a copy of the GNU Lesser General Public |
|
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4083
diff
changeset
|
19 * License along with this program. If not, see |
|
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4083
diff
changeset
|
20 * <http://www.gnu.org/licenses/>. |
| 853 | 21 **/ |
| 22 | |
| 23 | |
| 24 #include "../PrecompiledHeaders.h" | |
| 25 #include "ImageProcessing.h" | |
| 26 | |
|
3502
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
27 #include "Image.h" |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
28 #include "ImageTraits.h" |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
29 #include "PixelTraits.h" |
| 2895 | 30 #include "../OrthancException.h" |
| 853 | 31 |
|
3585
113a9643e8bb
Suppressed a few warnings when building with emscripten (clang) + numeric truncation warnings
Benjamin Golinvaux <bgo@osimis.io>
parents:
3565
diff
changeset
|
32 #ifdef __EMSCRIPTEN__ |
|
113a9643e8bb
Suppressed a few warnings when building with emscripten (clang) + numeric truncation warnings
Benjamin Golinvaux <bgo@osimis.io>
parents:
3565
diff
changeset
|
33 /* |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
34 Avoid this error: |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
35 ----------------- |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
36 .../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] |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
37 .../mnt/c/osi/dev/orthanc/Core/Images/ImageProcessing.cpp:333:28: note: in instantiation of function template specialization 'boost::math::llround<float>' requested here |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
38 .../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 |
|
3585
113a9643e8bb
Suppressed a few warnings when building with emscripten (clang) + numeric truncation warnings
Benjamin Golinvaux <bgo@osimis.io>
parents:
3565
diff
changeset
|
39 */ |
|
113a9643e8bb
Suppressed a few warnings when building with emscripten (clang) + numeric truncation warnings
Benjamin Golinvaux <bgo@osimis.io>
parents:
3565
diff
changeset
|
40 #pragma GCC diagnostic ignored "-Wimplicit-int-float-conversion" |
|
113a9643e8bb
Suppressed a few warnings when building with emscripten (clang) + numeric truncation warnings
Benjamin Golinvaux <bgo@osimis.io>
parents:
3565
diff
changeset
|
41 #endif |
|
113a9643e8bb
Suppressed a few warnings when building with emscripten (clang) + numeric truncation warnings
Benjamin Golinvaux <bgo@osimis.io>
parents:
3565
diff
changeset
|
42 |
| 863 | 43 #include <boost/math/special_functions/round.hpp> |
| 44 | |
| 853 | 45 #include <cassert> |
| 46 #include <string.h> | |
|
859
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
47 #include <limits> |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
48 #include <stdint.h> |
| 3258 | 49 #include <algorithm> |
|
859
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
50 |
| 853 | 51 namespace Orthanc |
| 52 { | |
| 4300 | 53 ImageProcessing::ImagePoint::ImagePoint(int32_t x, |
| 54 int32_t y) : | |
| 55 x_(x), | |
| 56 y_(y) | |
| 57 { | |
| 58 } | |
| 59 | |
| 60 int32_t ImageProcessing::ImagePoint::GetX() const | |
| 61 { | |
| 62 return x_; | |
| 63 } | |
| 64 | |
| 65 int32_t ImageProcessing::ImagePoint::GetY() const | |
| 66 { | |
| 67 return y_; | |
| 68 } | |
| 69 | |
| 70 void ImageProcessing::ImagePoint::Set(int32_t x, int32_t y) | |
| 71 { | |
| 72 x_ = x; | |
| 73 y_ = y; | |
| 74 } | |
| 75 | |
| 4056 | 76 void ImageProcessing::ImagePoint::ClipTo(int32_t minX, int32_t maxX, int32_t minY, int32_t maxY) |
| 77 { | |
| 78 x_ = std::max(minX, std::min(maxX, x_)); | |
| 79 y_ = std::max(minY, std::min(maxY, y_)); | |
| 80 } | |
| 81 | |
|
3265
59a184cbb596
ImagePoint::Set + GetDistanceTo
Alain Mazy <alain@mazy.be>
parents:
3259
diff
changeset
|
82 double ImageProcessing::ImagePoint::GetDistanceTo(const ImagePoint& other) const |
|
59a184cbb596
ImagePoint::Set + GetDistanceTo
Alain Mazy <alain@mazy.be>
parents:
3259
diff
changeset
|
83 { |
|
59a184cbb596
ImagePoint::Set + GetDistanceTo
Alain Mazy <alain@mazy.be>
parents:
3259
diff
changeset
|
84 double dx = (double)(other.GetX() - GetX()); |
|
59a184cbb596
ImagePoint::Set + GetDistanceTo
Alain Mazy <alain@mazy.be>
parents:
3259
diff
changeset
|
85 double dy = (double)(other.GetY() - GetY()); |
|
59a184cbb596
ImagePoint::Set + GetDistanceTo
Alain Mazy <alain@mazy.be>
parents:
3259
diff
changeset
|
86 return sqrt(dx * dx + dy * dy); |
|
59a184cbb596
ImagePoint::Set + GetDistanceTo
Alain Mazy <alain@mazy.be>
parents:
3259
diff
changeset
|
87 } |
|
59a184cbb596
ImagePoint::Set + GetDistanceTo
Alain Mazy <alain@mazy.be>
parents:
3259
diff
changeset
|
88 |
|
3565
2999a6e9456b
ImageProcessing::ImagePoint::GetDistanceToLine
Alain Mazy <alain@mazy.be>
parents:
3550
diff
changeset
|
89 double ImageProcessing::ImagePoint::GetDistanceToLine(double a, double b, double c) const // where ax + by + c = 0 is the equation of the line |
|
2999a6e9456b
ImageProcessing::ImagePoint::GetDistanceToLine
Alain Mazy <alain@mazy.be>
parents:
3550
diff
changeset
|
90 { |
|
2999a6e9456b
ImageProcessing::ImagePoint::GetDistanceToLine
Alain Mazy <alain@mazy.be>
parents:
3550
diff
changeset
|
91 return std::abs(a * static_cast<double>(GetX()) + b * static_cast<double>(GetY()) + c) / pow(a * a + b * b, 0.5); |
|
2999a6e9456b
ImageProcessing::ImagePoint::GetDistanceToLine
Alain Mazy <alain@mazy.be>
parents:
3550
diff
changeset
|
92 } |
|
2999a6e9456b
ImageProcessing::ImagePoint::GetDistanceToLine
Alain Mazy <alain@mazy.be>
parents:
3550
diff
changeset
|
93 |
|
859
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
94 template <typename TargetType, typename SourceType> |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
95 static void ConvertInternal(ImageAccessor& target, |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
96 const ImageAccessor& source) |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
97 { |
|
3525
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
98 // WARNING - "::min()" should be replaced by "::lowest()" if |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
99 // dealing with float or double (which is not the case so far) |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
100 assert(sizeof(TargetType) <= 2); // Safeguard to remember about "float/double" |
|
859
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
101 const TargetType minValue = std::numeric_limits<TargetType>::min(); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
102 const TargetType maxValue = std::numeric_limits<TargetType>::max(); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
103 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
104 const unsigned int width = source.GetWidth(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
105 const unsigned int height = source.GetHeight(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
106 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
107 for (unsigned int y = 0; y < height; y++) |
|
859
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
108 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
109 TargetType* t = reinterpret_cast<TargetType*>(target.GetRow(y)); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
110 const SourceType* s = reinterpret_cast<const SourceType*>(source.GetConstRow(y)); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
111 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
112 for (unsigned int x = 0; x < width; x++, t++, s++) |
|
859
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
113 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
114 if (static_cast<int32_t>(*s) < static_cast<int32_t>(minValue)) |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
115 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
116 *t = minValue; |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
117 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
118 else if (static_cast<int32_t>(*s) > static_cast<int32_t>(maxValue)) |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
119 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
120 *t = maxValue; |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
121 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
122 else |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
123 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
124 *t = static_cast<TargetType>(*s); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
125 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
126 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
127 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
128 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
129 |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
130 |
|
1993
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
131 template <typename SourceType> |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
132 static void ConvertGrayscaleToFloat(ImageAccessor& target, |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
133 const ImageAccessor& source) |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
134 { |
|
1994
4d099fee5eca
ImageProcessing::Set for float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1993
diff
changeset
|
135 assert(sizeof(float) == 4); |
|
4d099fee5eca
ImageProcessing::Set for float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1993
diff
changeset
|
136 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
137 const unsigned int width = source.GetWidth(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
138 const unsigned int height = source.GetHeight(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
139 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
140 for (unsigned int y = 0; y < height; y++) |
|
1993
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
141 { |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
142 float* t = reinterpret_cast<float*>(target.GetRow(y)); |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
143 const SourceType* s = reinterpret_cast<const SourceType*>(source.GetConstRow(y)); |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
144 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
145 for (unsigned int x = 0; x < width; x++, t++, s++) |
|
1993
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
146 { |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
147 *t = static_cast<float>(*s); |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
148 } |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
149 } |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
150 } |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
151 |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
152 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
153 template <PixelFormat TargetFormat> |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
154 static void ConvertFloatToGrayscale(ImageAccessor& target, |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
155 const ImageAccessor& source) |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
156 { |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
157 typedef typename PixelTraits<TargetFormat>::PixelType TargetType; |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
158 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
159 assert(sizeof(float) == 4); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
160 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
161 const unsigned int width = source.GetWidth(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
162 const unsigned int height = source.GetHeight(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
163 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
164 for (unsigned int y = 0; y < height; y++) |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
165 { |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
166 TargetType* q = reinterpret_cast<TargetType*>(target.GetRow(y)); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
167 const float* p = reinterpret_cast<const float*>(source.GetConstRow(y)); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
168 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
169 for (unsigned int x = 0; x < width; x++, p++, q++) |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
170 { |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
171 PixelTraits<TargetFormat>::FloatToPixel(*q, *p); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
172 } |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
173 } |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
174 } |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
175 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
176 |
|
993
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
177 template <typename TargetType> |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
178 static void ConvertColorToGrayscale(ImageAccessor& target, |
|
1993
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
179 const ImageAccessor& source) |
|
993
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
180 { |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
181 assert(source.GetFormat() == PixelFormat_RGB24); |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
182 |
|
3525
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
183 // WARNING - "::min()" should be replaced by "::lowest()" if |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
184 // dealing with float or double (which is not the case so far) |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
185 assert(sizeof(TargetType) <= 2); // Safeguard to remember about "float/double" |
|
993
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
186 const TargetType minValue = std::numeric_limits<TargetType>::min(); |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
187 const TargetType maxValue = std::numeric_limits<TargetType>::max(); |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
188 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
189 const unsigned int width = source.GetWidth(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
190 const unsigned int height = source.GetHeight(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
191 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
192 for (unsigned int y = 0; y < height; y++) |
|
993
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
193 { |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
194 TargetType* t = reinterpret_cast<TargetType*>(target.GetRow(y)); |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
195 const uint8_t* s = reinterpret_cast<const uint8_t*>(source.GetConstRow(y)); |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
196 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
197 for (unsigned int x = 0; x < width; x++, t++, s += 3) |
|
993
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
198 { |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
199 // Y = 0.2126 R + 0.7152 G + 0.0722 B |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
200 int32_t v = (2126 * static_cast<int32_t>(s[0]) + |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
201 7152 * static_cast<int32_t>(s[1]) + |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
202 0722 * static_cast<int32_t>(s[2])) / 10000; |
|
993
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
203 |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
204 if (static_cast<int32_t>(v) < static_cast<int32_t>(minValue)) |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
205 { |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
206 *t = minValue; |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
207 } |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
208 else if (static_cast<int32_t>(v) > static_cast<int32_t>(maxValue)) |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
209 { |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
210 *t = maxValue; |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
211 } |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
212 else |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
213 { |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
214 *t = static_cast<TargetType>(v); |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
215 } |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
216 } |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
217 } |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
218 } |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
219 |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
220 |
|
2902
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
221 static void MemsetZeroInternal(ImageAccessor& image) |
| 3227 | 222 { |
|
2902
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
223 const unsigned int height = image.GetHeight(); |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
224 const size_t lineSize = image.GetBytesPerPixel() * image.GetWidth(); |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
225 const size_t pitch = image.GetPitch(); |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
226 |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
227 uint8_t *p = reinterpret_cast<uint8_t*>(image.GetBuffer()); |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
228 |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
229 for (unsigned int y = 0; y < height; y++) |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
230 { |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
231 memset(p, 0, lineSize); |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
232 p += pitch; |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
233 } |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
234 } |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
235 |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
236 |
| 863 | 237 template <typename PixelType> |
| 238 static void SetInternal(ImageAccessor& image, | |
| 239 int64_t constant) | |
| 240 { | |
|
2902
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
241 if (constant == 0 && |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
242 (image.GetFormat() == PixelFormat_Grayscale8 || |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
243 image.GetFormat() == PixelFormat_Grayscale16 || |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
244 image.GetFormat() == PixelFormat_Grayscale32 || |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
245 image.GetFormat() == PixelFormat_Grayscale64 || |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
246 image.GetFormat() == PixelFormat_SignedGrayscale16)) |
| 863 | 247 { |
|
2902
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
248 MemsetZeroInternal(image); |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
249 } |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
250 else |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
251 { |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
252 const unsigned int width = image.GetWidth(); |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
253 const unsigned int height = image.GetHeight(); |
| 863 | 254 |
|
2902
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
255 for (unsigned int y = 0; y < height; y++) |
| 863 | 256 { |
|
2902
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
257 PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y)); |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
258 |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
259 for (unsigned int x = 0; x < width; x++, p++) |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
260 { |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
261 *p = static_cast<PixelType>(constant); |
|
e80b38fb22c6
fix ImageProcessing::Set() for subregions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
262 } |
| 863 | 263 } |
| 264 } | |
| 265 } | |
| 266 | |
| 267 | |
| 268 template <typename PixelType> | |
| 269 static void GetMinMaxValueInternal(PixelType& minValue, | |
| 270 PixelType& maxValue, | |
|
3525
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
271 const ImageAccessor& source, |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
272 const PixelType LowestValue = std::numeric_limits<PixelType>::min()) |
| 863 | 273 { |
| 274 // Deal with the special case of empty image | |
| 275 if (source.GetWidth() == 0 || | |
| 276 source.GetHeight() == 0) | |
| 277 { | |
| 278 minValue = 0; | |
| 279 maxValue = 0; | |
| 280 return; | |
| 281 } | |
| 282 | |
| 283 minValue = std::numeric_limits<PixelType>::max(); | |
|
3525
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
284 maxValue = LowestValue; |
| 863 | 285 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
286 const unsigned int height = source.GetHeight(); |
|
2482
509041cb57db
speedup by truncating instead of rounding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
287 const unsigned int width = source.GetWidth(); |
|
509041cb57db
speedup by truncating instead of rounding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
288 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
289 for (unsigned int y = 0; y < height; y++) |
| 863 | 290 { |
| 291 const PixelType* p = reinterpret_cast<const PixelType*>(source.GetConstRow(y)); | |
| 292 | |
|
2482
509041cb57db
speedup by truncating instead of rounding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
293 for (unsigned int x = 0; x < width; x++, p++) |
| 863 | 294 { |
| 295 if (*p < minValue) | |
| 296 { | |
| 297 minValue = *p; | |
| 298 } | |
| 299 | |
| 300 if (*p > maxValue) | |
| 301 { | |
| 302 maxValue = *p; | |
| 303 } | |
| 304 } | |
| 305 } | |
| 306 } | |
| 307 | |
| 308 | |
| 309 | |
| 310 template <typename PixelType> | |
| 311 static void AddConstantInternal(ImageAccessor& image, | |
| 312 int64_t constant) | |
| 313 { | |
| 314 if (constant == 0) | |
| 315 { | |
| 316 return; | |
| 317 } | |
| 318 | |
|
3525
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
319 // WARNING - "::min()" should be replaced by "::lowest()" if |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
320 // dealing with float or double (which is not the case so far) |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
321 assert(sizeof(PixelType) <= 2); // Safeguard to remember about "float/double" |
| 863 | 322 const int64_t minValue = std::numeric_limits<PixelType>::min(); |
| 323 const int64_t maxValue = std::numeric_limits<PixelType>::max(); | |
| 324 | |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
325 const unsigned int width = image.GetWidth(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
326 const unsigned int height = image.GetHeight(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
327 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
328 for (unsigned int y = 0; y < height; y++) |
| 863 | 329 { |
| 330 PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y)); | |
| 331 | |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
332 for (unsigned int x = 0; x < width; x++, p++) |
| 863 | 333 { |
| 334 int64_t v = static_cast<int64_t>(*p) + constant; | |
| 335 | |
| 336 if (v > maxValue) | |
| 337 { | |
| 876 | 338 *p = std::numeric_limits<PixelType>::max(); |
| 863 | 339 } |
| 340 else if (v < minValue) | |
| 341 { | |
| 876 | 342 *p = std::numeric_limits<PixelType>::min(); |
| 863 | 343 } |
| 344 else | |
| 345 { | |
| 346 *p = static_cast<PixelType>(v); | |
| 347 } | |
| 348 } | |
| 349 } | |
| 350 } | |
| 351 | |
| 352 | |
| 353 | |
|
2488
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
354 template <typename PixelType, |
|
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
355 bool UseRound> |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
356 static void MultiplyConstantInternal(ImageAccessor& image, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
357 float factor) |
| 863 | 358 { |
| 1334 | 359 if (std::abs(factor - 1.0f) <= std::numeric_limits<float>::epsilon()) |
| 863 | 360 { |
| 361 return; | |
| 362 } | |
| 363 | |
|
3525
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
364 // WARNING - "::min()" should be replaced by "::lowest()" if |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
365 // dealing with float or double (which is not the case so far) |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
366 assert(sizeof(PixelType) <= 2); // Safeguard to remember about "float/double" |
| 863 | 367 const int64_t minValue = std::numeric_limits<PixelType>::min(); |
| 368 const int64_t maxValue = std::numeric_limits<PixelType>::max(); | |
| 369 | |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
370 const unsigned int width = image.GetWidth(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
371 const unsigned int height = image.GetHeight(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
372 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
373 for (unsigned int y = 0; y < height; y++) |
| 863 | 374 { |
| 375 PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y)); | |
| 376 | |
|
2482
509041cb57db
speedup by truncating instead of rounding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
377 for (unsigned int x = 0; x < width; x++, p++) |
| 863 | 378 { |
|
2488
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
379 int64_t v; |
|
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
380 if (UseRound) |
|
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
381 { |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
382 assert(sizeof(long long) == sizeof(int64_t)); |
|
2488
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
383 // The "round" operation is very costly |
|
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
384 v = boost::math::llround(static_cast<float>(*p) * factor); |
|
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
385 } |
|
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
386 else |
|
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
387 { |
|
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
388 v = static_cast<int64_t>(static_cast<float>(*p) * factor); |
|
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
389 } |
| 863 | 390 |
| 391 if (v > maxValue) | |
| 392 { | |
| 876 | 393 *p = std::numeric_limits<PixelType>::max(); |
| 863 | 394 } |
| 395 else if (v < minValue) | |
| 396 { | |
| 876 | 397 *p = std::numeric_limits<PixelType>::min(); |
| 863 | 398 } |
| 399 else | |
| 400 { | |
| 401 *p = static_cast<PixelType>(v); | |
| 402 } | |
| 403 } | |
| 404 } | |
| 405 } | |
| 406 | |
| 407 | |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
408 // Computes "a * x + b" at each pixel => Note that this is not the |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
409 // same convention as in "ShiftScale()", but it is the convention of |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
410 // "ShiftScale2()" |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
411 template <typename TargetType, |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
412 typename SourceType, |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
413 bool UseRound, |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
414 bool Invert> |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
415 static void ShiftScaleInternal(ImageAccessor& target, |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
416 const ImageAccessor& source, |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
417 float a, |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
418 float b, |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
419 const TargetType LowestValue) |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
420 // This function can be applied inplace (source == target) |
| 863 | 421 { |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
422 if (source.GetWidth() != target.GetWidth() || |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
423 source.GetHeight() != target.GetHeight()) |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
424 { |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
425 throw OrthancException(ErrorCode_IncompatibleImageSize); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
426 } |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
427 |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
428 if (&source == &target && |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
429 source.GetFormat() != target.GetFormat()) |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
430 { |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
431 throw OrthancException(ErrorCode_IncompatibleImageFormat); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
432 } |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
433 |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
434 const TargetType minPixelValue = LowestValue; |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
435 const TargetType maxPixelValue = std::numeric_limits<TargetType>::max(); |
|
3525
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
436 const float minFloatValue = static_cast<float>(LowestValue); |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
437 const float maxFloatValue = static_cast<float>(maxPixelValue); |
| 863 | 438 |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
439 const unsigned int height = target.GetHeight(); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
440 const unsigned int width = target.GetWidth(); |
|
2482
509041cb57db
speedup by truncating instead of rounding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
441 |
|
509041cb57db
speedup by truncating instead of rounding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
442 for (unsigned int y = 0; y < height; y++) |
| 863 | 443 { |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
444 TargetType* p = reinterpret_cast<TargetType*>(target.GetRow(y)); |
| 4201 | 445 const SourceType* q = reinterpret_cast<const SourceType*>(source.GetConstRow(y)); |
| 863 | 446 |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
447 for (unsigned int x = 0; x < width; x++, p++, q++) |
| 863 | 448 { |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
449 float v = a * static_cast<float>(*q) + b; |
| 863 | 450 |
|
3505
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
451 if (v >= maxFloatValue) |
| 863 | 452 { |
|
2482
509041cb57db
speedup by truncating instead of rounding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
453 *p = maxPixelValue; |
| 863 | 454 } |
|
3505
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
455 else if (v <= minFloatValue) |
| 863 | 456 { |
|
2482
509041cb57db
speedup by truncating instead of rounding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
457 *p = minPixelValue; |
| 863 | 458 } |
|
2488
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
459 else if (UseRound) |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
460 { |
|
2488
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
461 // The "round" operation is very costly |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
462 assert(sizeof(TargetType) < sizeof(int)); |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
463 *p = static_cast<TargetType>(boost::math::iround(v)); |
|
2488
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
464 } |
| 863 | 465 else |
| 466 { | |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
467 *p = static_cast<TargetType>(std::floor(v)); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
468 } |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
469 |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
470 if (Invert) |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
471 { |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
472 *p = maxPixelValue - *p; |
| 863 | 473 } |
| 474 } | |
| 475 } | |
| 476 } | |
| 477 | |
| 3545 | 478 template <typename PixelType> |
| 479 static void ShiftRightInternal(ImageAccessor& image, | |
| 480 unsigned int shift) | |
| 481 { | |
| 482 const unsigned int height = image.GetHeight(); | |
| 483 const unsigned int width = image.GetWidth(); | |
| 484 | |
| 485 for (unsigned int y = 0; y < height; y++) | |
| 486 { | |
| 487 PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y)); | |
| 488 | |
| 489 for (unsigned int x = 0; x < width; x++, p++) | |
| 490 { | |
| 491 *p = *p >> shift; | |
| 492 } | |
| 493 } | |
| 494 } | |
| 495 | |
| 496 template <typename PixelType> | |
| 497 static void ShiftLeftInternal(ImageAccessor& image, | |
| 498 unsigned int shift) | |
| 499 { | |
| 500 const unsigned int height = image.GetHeight(); | |
| 501 const unsigned int width = image.GetWidth(); | |
| 502 | |
| 503 for (unsigned int y = 0; y < height; y++) | |
| 504 { | |
| 505 PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y)); | |
| 506 | |
| 507 for (unsigned int x = 0; x < width; x++, p++) | |
| 508 { | |
| 509 *p = *p << shift; | |
| 510 } | |
| 511 } | |
| 512 } | |
|
859
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
513 |
| 853 | 514 void ImageProcessing::Copy(ImageAccessor& target, |
| 515 const ImageAccessor& source) | |
| 516 { | |
| 517 if (target.GetWidth() != source.GetWidth() || | |
| 518 target.GetHeight() != source.GetHeight()) | |
| 519 { | |
| 520 throw OrthancException(ErrorCode_IncompatibleImageSize); | |
| 521 } | |
| 522 | |
| 523 if (target.GetFormat() != source.GetFormat()) | |
| 524 { | |
| 525 throw OrthancException(ErrorCode_IncompatibleImageFormat); | |
| 526 } | |
| 527 | |
|
4278
9279de56a405
avoid multiple calls to GetWidth() and GetHeight() on pixel loops
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
528 const unsigned int lineSize = source.GetBytesPerPixel() * source.GetWidth(); |
| 853 | 529 assert(source.GetPitch() >= lineSize && target.GetPitch() >= lineSize); |
| 530 | |
|
4278
9279de56a405
avoid multiple calls to GetWidth() and GetHeight() on pixel loops
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
531 const unsigned int height = source.GetHeight(); |
|
9279de56a405
avoid multiple calls to GetWidth() and GetHeight() on pixel loops
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
532 for (unsigned int y = 0; y < height; y++) |
| 853 | 533 { |
|
854
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
534 memcpy(target.GetRow(y), source.GetConstRow(y), lineSize); |
| 853 | 535 } |
| 536 } | |
| 537 | |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
538 template <typename TargetType, typename SourceType> |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
539 static void ApplyWindowingInternal(ImageAccessor& target, |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
540 const ImageAccessor& source, |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
541 float windowCenter, |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
542 float windowWidth, |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
543 float rescaleSlope, |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
544 float rescaleIntercept, |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
545 bool invert) |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
546 { |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
547 assert(sizeof(SourceType) == source.GetBytesPerPixel() && |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
548 sizeof(TargetType) == target.GetBytesPerPixel()); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
549 |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
550 // WARNING - "::min()" should be replaced by "::lowest()" if |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
551 // dealing with float or double (which is not the case so far) |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
552 assert(sizeof(TargetType) <= 2); // Safeguard to remember about "float/double" |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
553 const TargetType minTargetValue = std::numeric_limits<TargetType>::min(); |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
554 const TargetType maxTargetValue = std::numeric_limits<TargetType>::max(); |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
555 const float maxFloatValue = static_cast<float>(maxTargetValue); |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
556 |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
557 const float windowIntercept = windowCenter - windowWidth / 2.0f; |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
558 const float windowSlope = (maxFloatValue + 1.0f) / windowWidth; |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
559 |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
560 const float a = rescaleSlope * windowSlope; |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
561 const float b = (rescaleIntercept - windowIntercept) * windowSlope; |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
562 |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
563 if (invert) |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
564 { |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
565 ShiftScaleInternal<TargetType, SourceType, false, true>(target, source, a, b, minTargetValue); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
566 } |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
567 else |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
568 { |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
569 ShiftScaleInternal<TargetType, SourceType, false, false>(target, source, a, b, minTargetValue); |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
570 } |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
571 } |
|
854
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
572 |
|
3683
12253ddefe5a
skeleton for new route: /instances/{id}/rendered
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3682
diff
changeset
|
573 void ImageProcessing::ApplyWindowing_Deprecated(ImageAccessor& target, |
|
12253ddefe5a
skeleton for new route: /instances/{id}/rendered
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3682
diff
changeset
|
574 const ImageAccessor& source, |
|
12253ddefe5a
skeleton for new route: /instances/{id}/rendered
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3682
diff
changeset
|
575 float windowCenter, |
|
12253ddefe5a
skeleton for new route: /instances/{id}/rendered
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3682
diff
changeset
|
576 float windowWidth, |
|
12253ddefe5a
skeleton for new route: /instances/{id}/rendered
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3682
diff
changeset
|
577 float rescaleSlope, |
|
12253ddefe5a
skeleton for new route: /instances/{id}/rendered
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3682
diff
changeset
|
578 float rescaleIntercept, |
|
12253ddefe5a
skeleton for new route: /instances/{id}/rendered
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3682
diff
changeset
|
579 bool invert) |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
580 { |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
581 if (target.GetWidth() != source.GetWidth() || |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
582 target.GetHeight() != source.GetHeight()) |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
583 { |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
584 throw OrthancException(ErrorCode_IncompatibleImageSize); |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
585 } |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
586 |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
587 switch (source.GetFormat()) |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
588 { |
| 4297 | 589 case PixelFormat_Float32: |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
590 { |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
591 switch (target.GetFormat()) |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
592 { |
| 4297 | 593 case PixelFormat_Grayscale8: |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
594 ApplyWindowingInternal<uint8_t, float>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
595 break; |
| 4297 | 596 case PixelFormat_Grayscale16: |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
597 ApplyWindowingInternal<uint16_t, float>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
598 break; |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
599 default: |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
600 throw OrthancException(ErrorCode_NotImplemented); |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
601 } |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
602 };break; |
| 4297 | 603 case PixelFormat_Grayscale8: |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
604 { |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
605 switch (target.GetFormat()) |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
606 { |
| 4297 | 607 case PixelFormat_Grayscale8: |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
608 ApplyWindowingInternal<uint8_t, uint8_t>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
609 break; |
| 4297 | 610 case PixelFormat_Grayscale16: |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
611 ApplyWindowingInternal<uint16_t, uint8_t>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
612 break; |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
613 default: |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
614 throw OrthancException(ErrorCode_NotImplemented); |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
615 } |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
616 };break; |
| 4297 | 617 case PixelFormat_Grayscale16: |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
618 { |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
619 switch (target.GetFormat()) |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
620 { |
| 4297 | 621 case PixelFormat_Grayscale8: |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
622 ApplyWindowingInternal<uint8_t, uint16_t>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
623 break; |
| 4297 | 624 case PixelFormat_Grayscale16: |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
625 ApplyWindowingInternal<uint16_t, uint16_t>(target, source, windowCenter, windowWidth, rescaleSlope, rescaleIntercept, invert); |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
626 break; |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
627 default: |
|
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
628 throw OrthancException(ErrorCode_NotImplemented); |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
629 } |
|
3600
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
630 };break; |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
631 default: |
|
4066998150ef
/instances/{id}/preview route now takes the windowing into account
Alain Mazy <alain@mazy.be>
parents:
3585
diff
changeset
|
632 throw OrthancException(ErrorCode_NotImplemented); |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
633 } |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
634 } |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
635 |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
636 |
| 853 | 637 void ImageProcessing::Convert(ImageAccessor& target, |
| 638 const ImageAccessor& source) | |
| 639 { | |
| 640 if (target.GetWidth() != source.GetWidth() || | |
| 641 target.GetHeight() != source.GetHeight()) | |
| 642 { | |
| 643 throw OrthancException(ErrorCode_IncompatibleImageSize); | |
| 644 } | |
| 645 | |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
646 const unsigned int width = source.GetWidth(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
647 const unsigned int height = source.GetHeight(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
648 |
| 853 | 649 if (source.GetFormat() == target.GetFormat()) |
| 650 { | |
| 651 Copy(target, source); | |
| 652 return; | |
| 653 } | |
|
854
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
654 |
|
859
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
655 if (target.GetFormat() == PixelFormat_Grayscale16 && |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
656 source.GetFormat() == PixelFormat_Grayscale8) |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
657 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
658 ConvertInternal<uint16_t, uint8_t>(target, source); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
659 return; |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
660 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
661 |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
662 if (target.GetFormat() == PixelFormat_SignedGrayscale16 && |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
663 source.GetFormat() == PixelFormat_Grayscale8) |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
664 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
665 ConvertInternal<int16_t, uint8_t>(target, source); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
666 return; |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
667 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
668 |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
669 if (target.GetFormat() == PixelFormat_Grayscale8 && |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
670 source.GetFormat() == PixelFormat_Grayscale16) |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
671 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
672 ConvertInternal<uint8_t, uint16_t>(target, source); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
673 return; |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
674 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
675 |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
676 if (target.GetFormat() == PixelFormat_SignedGrayscale16 && |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
677 source.GetFormat() == PixelFormat_Grayscale16) |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
678 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
679 ConvertInternal<int16_t, uint16_t>(target, source); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
680 return; |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
681 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
682 |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
683 if (target.GetFormat() == PixelFormat_Grayscale8 && |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
684 source.GetFormat() == PixelFormat_SignedGrayscale16) |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
685 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
686 ConvertInternal<uint8_t, int16_t>(target, source); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
687 return; |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
688 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
689 |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
690 if (target.GetFormat() == PixelFormat_Grayscale16 && |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
691 source.GetFormat() == PixelFormat_SignedGrayscale16) |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
692 { |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
693 ConvertInternal<uint16_t, int16_t>(target, source); |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
694 return; |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
695 } |
|
610a9a1ed855
ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
854
diff
changeset
|
696 |
|
993
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
697 if (target.GetFormat() == PixelFormat_Grayscale8 && |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
698 source.GetFormat() == PixelFormat_RGB24) |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
699 { |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
700 ConvertColorToGrayscale<uint8_t>(target, source); |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
701 return; |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
702 } |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
703 |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
704 if (target.GetFormat() == PixelFormat_Grayscale16 && |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
705 source.GetFormat() == PixelFormat_RGB24) |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
706 { |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
707 ConvertColorToGrayscale<uint16_t>(target, source); |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
708 return; |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
709 } |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
710 |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
711 if (target.GetFormat() == PixelFormat_SignedGrayscale16 && |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
712 source.GetFormat() == PixelFormat_RGB24) |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
713 { |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
714 ConvertColorToGrayscale<int16_t>(target, source); |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
715 return; |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
716 } |
|
501880d76474
improvements to GDCM plugin
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
876
diff
changeset
|
717 |
|
1993
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
718 if (target.GetFormat() == PixelFormat_Float32 && |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
719 source.GetFormat() == PixelFormat_Grayscale8) |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
720 { |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
721 ConvertGrayscaleToFloat<uint8_t>(target, source); |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
722 return; |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
723 } |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
724 |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
725 if (target.GetFormat() == PixelFormat_Float32 && |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
726 source.GetFormat() == PixelFormat_Grayscale16) |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
727 { |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
728 ConvertGrayscaleToFloat<uint16_t>(target, source); |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
729 return; |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
730 } |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
731 |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
732 if (target.GetFormat() == PixelFormat_Float32 && |
|
2415
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
733 source.GetFormat() == PixelFormat_Grayscale32) |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
734 { |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
735 ConvertGrayscaleToFloat<uint32_t>(target, source); |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
736 return; |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
737 } |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
738 |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
739 if (target.GetFormat() == PixelFormat_Float32 && |
|
1993
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
740 source.GetFormat() == PixelFormat_SignedGrayscale16) |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
741 { |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
742 ConvertGrayscaleToFloat<int16_t>(target, source); |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
743 return; |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
744 } |
|
e2a3ff770b48
introducing float32 images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1992
diff
changeset
|
745 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
746 |
|
1610
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
747 if (target.GetFormat() == PixelFormat_Grayscale8 && |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
748 source.GetFormat() == PixelFormat_RGBA32) |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
749 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
750 for (unsigned int y = 0; y < height; y++) |
|
1610
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
751 { |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
752 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y)); |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
753 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
754 for (unsigned int x = 0; x < width; x++, q++) |
|
1610
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
755 { |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
756 *q = static_cast<uint8_t>((2126 * static_cast<uint32_t>(p[0]) + |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
757 7152 * static_cast<uint32_t>(p[1]) + |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
758 0722 * static_cast<uint32_t>(p[2])) / 10000); |
|
1610
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
759 p += 4; |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
760 } |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
761 } |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
762 |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
763 return; |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
764 } |
|
2dff2bdffdb8
font support within Orthanc
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1608
diff
changeset
|
765 |
|
2840
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
766 if (target.GetFormat() == PixelFormat_Grayscale8 && |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
767 source.GetFormat() == PixelFormat_BGRA32) |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
768 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
769 for (unsigned int y = 0; y < height; y++) |
|
2840
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
770 { |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
771 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y)); |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
772 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
773 for (unsigned int x = 0; x < width; x++, q++) |
|
2840
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
774 { |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
775 *q = static_cast<uint8_t>((2126 * static_cast<uint32_t>(p[2]) + |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
776 7152 * static_cast<uint32_t>(p[1]) + |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
777 0722 * static_cast<uint32_t>(p[0])) / 10000); |
|
2840
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
778 p += 4; |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
779 } |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
780 } |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
781 |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
782 return; |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
783 } |
|
f4c232bba1eb
bgra32 to grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2783
diff
changeset
|
784 |
|
1608
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
785 if (target.GetFormat() == PixelFormat_RGB24 && |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
786 source.GetFormat() == PixelFormat_RGBA32) |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
787 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
788 for (unsigned int y = 0; y < height; y++) |
|
1608
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
789 { |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
790 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y)); |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
791 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
792 for (unsigned int x = 0; x < width; x++) |
|
1608
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
793 { |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
794 q[0] = p[0]; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
795 q[1] = p[1]; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
796 q[2] = p[2]; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
797 p += 4; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
798 q += 3; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
799 } |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
800 } |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
801 |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
802 return; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
803 } |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
804 |
|
2252
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
805 if (target.GetFormat() == PixelFormat_RGB24 && |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
806 source.GetFormat() == PixelFormat_BGRA32) |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
807 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
808 for (unsigned int y = 0; y < height; y++) |
|
2252
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
809 { |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
810 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y)); |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
811 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
812 for (unsigned int x = 0; x < width; x++) |
|
2252
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
813 { |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
814 q[0] = p[2]; |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
815 q[1] = p[1]; |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
816 q[2] = p[0]; |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
817 p += 4; |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
818 q += 3; |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
819 } |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
820 } |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
821 |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
822 return; |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
823 } |
|
002b94046c69
colorspace conversion from BGRA32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
824 |
|
1608
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
825 if (target.GetFormat() == PixelFormat_RGBA32 && |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
826 source.GetFormat() == PixelFormat_RGB24) |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
827 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
828 for (unsigned int y = 0; y < height; y++) |
|
1608
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
829 { |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
830 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y)); |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
831 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
832 for (unsigned int x = 0; x < width; x++) |
|
1608
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
833 { |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
834 q[0] = p[0]; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
835 q[1] = p[1]; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
836 q[2] = p[2]; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
837 q[3] = 255; // Set the alpha channel to full opacity |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
838 p += 3; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
839 q += 4; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
840 } |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
841 } |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
842 |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
843 return; |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
844 } |
|
adc6a5704cdb
OrthancPluginConvertPixelFormat
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1334
diff
changeset
|
845 |
|
1992
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
846 if (target.GetFormat() == PixelFormat_RGB24 && |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
847 source.GetFormat() == PixelFormat_Grayscale8) |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
848 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
849 for (unsigned int y = 0; y < height; y++) |
|
1992
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
850 { |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
851 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y)); |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
852 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
853 for (unsigned int x = 0; x < width; x++) |
|
1992
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
854 { |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
855 q[0] = *p; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
856 q[1] = *p; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
857 q[2] = *p; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
858 p += 1; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
859 q += 3; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
860 } |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
861 } |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
862 |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
863 return; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
864 } |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
865 |
| 2650 | 866 if ((target.GetFormat() == PixelFormat_RGBA32 || |
| 867 target.GetFormat() == PixelFormat_BGRA32) && | |
|
1992
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
868 source.GetFormat() == PixelFormat_Grayscale8) |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
869 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
870 for (unsigned int y = 0; y < height; y++) |
|
1992
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
871 { |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
872 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y)); |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
873 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
874 for (unsigned int x = 0; x < width; x++) |
|
1992
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
875 { |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
876 q[0] = *p; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
877 q[1] = *p; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
878 q[2] = *p; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
879 q[3] = 255; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
880 p += 1; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
881 q += 4; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
882 } |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
883 } |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
884 |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
885 return; |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
886 } |
|
9161e3ef0d17
new conversions in ImageProcessing::Convert
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
887 |
|
2100
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
888 if (target.GetFormat() == PixelFormat_BGRA32 && |
|
2495
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
889 source.GetFormat() == PixelFormat_Grayscale16) |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
890 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
891 for (unsigned int y = 0; y < height; y++) |
|
2495
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
892 { |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
893 const uint16_t* p = reinterpret_cast<const uint16_t*>(source.GetConstRow(y)); |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
894 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
895 for (unsigned int x = 0; x < width; x++) |
|
2495
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
896 { |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
897 uint8_t value = (*p < 256 ? *p : 255); |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
898 q[0] = value; |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
899 q[1] = value; |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
900 q[2] = value; |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
901 q[3] = 255; |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
902 p += 1; |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
903 q += 4; |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
904 } |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
905 } |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
906 |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
907 return; |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
908 } |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
909 |
|
cd7b854dbc05
convert grayscale16 to bgra32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2491
diff
changeset
|
910 if (target.GetFormat() == PixelFormat_BGRA32 && |
|
2496
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
911 source.GetFormat() == PixelFormat_SignedGrayscale16) |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
912 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
913 for (unsigned int y = 0; y < height; y++) |
|
2496
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
914 { |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
915 const int16_t* p = reinterpret_cast<const int16_t*>(source.GetConstRow(y)); |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
916 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
917 for (unsigned int x = 0; x < width; x++) |
|
2496
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
918 { |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
919 uint8_t value; |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
920 if (*p < 0) |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
921 { |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
922 value = 0; |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
923 } |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
924 else if (*p > 255) |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
925 { |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
926 value = 255; |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
927 } |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
928 else |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
929 { |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
930 value = static_cast<uint8_t>(*p); |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
931 } |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
932 |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
933 q[0] = value; |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
934 q[1] = value; |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
935 q[2] = value; |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
936 q[3] = 255; |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
937 p += 1; |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
938 q += 4; |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
939 } |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
940 } |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
941 |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
942 return; |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
943 } |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
944 |
|
3d65adee289a
int16_t to rgba32 conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2495
diff
changeset
|
945 if (target.GetFormat() == PixelFormat_BGRA32 && |
|
2100
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
946 source.GetFormat() == PixelFormat_RGB24) |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
947 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
948 for (unsigned int y = 0; y < height; y++) |
|
2100
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
949 { |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
950 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y)); |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
951 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
952 for (unsigned int x = 0; x < width; x++) |
|
2100
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
953 { |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
954 q[0] = p[2]; |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
955 q[1] = p[1]; |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
956 q[2] = p[0]; |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
957 q[3] = 255; |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
958 p += 3; |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
959 q += 4; |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
960 } |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
961 } |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
962 |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
963 return; |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
964 } |
|
1554fc153a93
conversion RGB24 to BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2089
diff
changeset
|
965 |
|
3547
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
966 if ((target.GetFormat() == PixelFormat_BGRA32 && |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
967 source.GetFormat() == PixelFormat_RGBA32) |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
968 || (target.GetFormat() == PixelFormat_RGBA32 && |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
969 source.GetFormat() == PixelFormat_BGRA32)) |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
970 { |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
971 for (unsigned int y = 0; y < height; y++) |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
972 { |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
973 const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y)); |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
974 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
975 for (unsigned int x = 0; x < width; x++) |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
976 { |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
977 q[0] = p[2]; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
978 q[1] = p[1]; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
979 q[2] = p[0]; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
980 q[3] = p[3]; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
981 p += 4; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
982 q += 4; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
983 } |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
984 } |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
985 |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
986 return; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
987 } |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
988 |
|
2423
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
989 if (target.GetFormat() == PixelFormat_RGB24 && |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
990 source.GetFormat() == PixelFormat_RGB48) |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
991 { |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
992 for (unsigned int y = 0; y < height; y++) |
|
2423
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
993 { |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
994 const uint16_t* p = reinterpret_cast<const uint16_t*>(source.GetConstRow(y)); |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
995 uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y)); |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
996 for (unsigned int x = 0; x < width; x++) |
|
2423
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
997 { |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
998 q[0] = p[0] >> 8; |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
999 q[1] = p[1] >> 8; |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
1000 q[2] = p[2] >> 8; |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
1001 p += 3; |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
1002 q += 3; |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
1003 } |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
1004 } |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
1005 |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
1006 return; |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
1007 } |
|
5a7c5c541a1d
Built-in decoding of palette images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2415
diff
changeset
|
1008 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1009 if (target.GetFormat() == PixelFormat_Grayscale16 && |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1010 source.GetFormat() == PixelFormat_Float32) |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1011 { |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1012 ConvertFloatToGrayscale<PixelFormat_Grayscale16>(target, source); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1013 return; |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1014 } |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1015 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1016 if (target.GetFormat() == PixelFormat_Grayscale8 && |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1017 source.GetFormat() == PixelFormat_Float32) |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1018 { |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1019 ConvertFloatToGrayscale<PixelFormat_Grayscale8>(target, source); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1020 return; |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1021 } |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1022 |
|
4664
f9eda86f9045
ImageProcessing::Convert() from Float32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4529
diff
changeset
|
1023 if (target.GetFormat() == PixelFormat_RGB24 && |
|
f9eda86f9045
ImageProcessing::Convert() from Float32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4529
diff
changeset
|
1024 source.GetFormat() == PixelFormat_Float32) |
|
f9eda86f9045
ImageProcessing::Convert() from Float32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4529
diff
changeset
|
1025 { |
|
f9eda86f9045
ImageProcessing::Convert() from Float32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4529
diff
changeset
|
1026 ConvertFloatToGrayscale<PixelFormat_RGB24>(target, source); |
|
f9eda86f9045
ImageProcessing::Convert() from Float32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4529
diff
changeset
|
1027 return; |
|
f9eda86f9045
ImageProcessing::Convert() from Float32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4529
diff
changeset
|
1028 } |
|
f9eda86f9045
ImageProcessing::Convert() from Float32 to RGB24
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4529
diff
changeset
|
1029 |
|
854
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1030 throw OrthancException(ErrorCode_NotImplemented); |
| 853 | 1031 } |
|
854
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1032 |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1033 |
| 863 | 1034 |
| 1035 void ImageProcessing::Set(ImageAccessor& image, | |
| 1036 int64_t value) | |
| 1037 { | |
| 1038 switch (image.GetFormat()) | |
| 1039 { | |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1040 case PixelFormat_Grayscale8: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1041 SetInternal<uint8_t>(image, value); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1042 return; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1043 |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1044 case PixelFormat_Grayscale16: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1045 SetInternal<uint16_t>(image, value); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1046 return; |
| 863 | 1047 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1048 case PixelFormat_Grayscale32: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1049 SetInternal<uint32_t>(image, value); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1050 return; |
| 863 | 1051 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1052 case PixelFormat_Grayscale64: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1053 SetInternal<uint64_t>(image, value); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1054 return; |
|
2415
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1055 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1056 case PixelFormat_SignedGrayscale16: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1057 SetInternal<int16_t>(image, value); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1058 return; |
|
2645
89b789366596
Grayscale64 pixel format
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2496
diff
changeset
|
1059 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1060 case PixelFormat_Float32: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1061 assert(sizeof(float) == 4); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1062 SetInternal<float>(image, value); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1063 return; |
| 863 | 1064 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1065 case PixelFormat_RGBA32: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1066 case PixelFormat_BGRA32: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1067 case PixelFormat_RGB24: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1068 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1069 uint8_t v = static_cast<uint8_t>(value); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1070 Set(image, v, v, v, v); // Use the color version |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1071 return; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1072 } |
|
1994
4d099fee5eca
ImageProcessing::Set for float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1993
diff
changeset
|
1073 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1074 default: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1075 throw OrthancException(ErrorCode_NotImplemented); |
| 863 | 1076 } |
| 1077 } | |
| 1078 | |
| 1079 | |
|
2089
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1080 void ImageProcessing::Set(ImageAccessor& image, |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1081 uint8_t red, |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1082 uint8_t green, |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1083 uint8_t blue, |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1084 uint8_t alpha) |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1085 { |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1086 uint8_t p[4]; |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1087 unsigned int size; |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1088 |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1089 switch (image.GetFormat()) |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1090 { |
|
4446
19e8540064d8
ImageProcessing::Set(image, r, g, b, a) applicable to grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4443
diff
changeset
|
1091 case PixelFormat_Grayscale8: |
|
19e8540064d8
ImageProcessing::Set(image, r, g, b, a) applicable to grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4443
diff
changeset
|
1092 { |
|
19e8540064d8
ImageProcessing::Set(image, r, g, b, a) applicable to grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4443
diff
changeset
|
1093 // New in Orthanc 1.9.0 |
|
19e8540064d8
ImageProcessing::Set(image, r, g, b, a) applicable to grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4443
diff
changeset
|
1094 uint8_t grayscale = (2126 * static_cast<uint16_t>(red) + |
|
19e8540064d8
ImageProcessing::Set(image, r, g, b, a) applicable to grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4443
diff
changeset
|
1095 7152 * static_cast<uint16_t>(green) + |
|
19e8540064d8
ImageProcessing::Set(image, r, g, b, a) applicable to grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4443
diff
changeset
|
1096 0722 * static_cast<uint16_t>(blue)) / 10000; |
|
19e8540064d8
ImageProcessing::Set(image, r, g, b, a) applicable to grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4443
diff
changeset
|
1097 Orthanc::ImageProcessing::Set(image, grayscale); |
| 4447 | 1098 return; |
|
4446
19e8540064d8
ImageProcessing::Set(image, r, g, b, a) applicable to grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4443
diff
changeset
|
1099 } |
|
19e8540064d8
ImageProcessing::Set(image, r, g, b, a) applicable to grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4443
diff
changeset
|
1100 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1101 case PixelFormat_RGBA32: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1102 p[0] = red; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1103 p[1] = green; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1104 p[2] = blue; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1105 p[3] = alpha; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1106 size = 4; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1107 break; |
|
2089
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1108 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1109 case PixelFormat_BGRA32: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1110 p[0] = blue; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1111 p[1] = green; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1112 p[2] = red; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1113 p[3] = alpha; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1114 size = 4; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1115 break; |
|
2089
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1116 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1117 case PixelFormat_RGB24: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1118 p[0] = red; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1119 p[1] = green; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1120 p[2] = blue; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1121 size = 3; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1122 break; |
|
2089
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1123 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1124 default: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1125 throw OrthancException(ErrorCode_NotImplemented); |
| 3227 | 1126 } |
|
2089
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1127 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1128 const unsigned int width = image.GetWidth(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1129 const unsigned int height = image.GetHeight(); |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1130 |
|
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1131 for (unsigned int y = 0; y < height; y++) |
|
2089
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1132 { |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1133 uint8_t* q = reinterpret_cast<uint8_t*>(image.GetRow(y)); |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1134 |
|
2904
0dd54ee073db
float to integer grayscale conversion
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2902
diff
changeset
|
1135 for (unsigned int x = 0; x < width; x++) |
|
2089
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1136 { |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1137 for (unsigned int i = 0; i < size; i++) |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1138 { |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1139 q[i] = p[i]; |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1140 } |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1141 |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1142 q += size; |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1143 } |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1144 } |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1145 } |
|
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1146 |
|
3547
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1147 void ImageProcessing::Set(ImageAccessor& image, |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
1148 uint8_t red, |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
1149 uint8_t green, |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
1150 uint8_t blue, |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
1151 ImageAccessor& alpha) |
|
3547
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1152 { |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1153 uint8_t p[4]; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1154 |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1155 if (alpha.GetWidth() != image.GetWidth() || alpha.GetHeight() != image.GetHeight()) |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1156 { |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1157 throw OrthancException(ErrorCode_IncompatibleImageSize); |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1158 } |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1159 |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1160 if (alpha.GetFormat() != PixelFormat_Grayscale8) |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1161 { |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1162 throw OrthancException(ErrorCode_NotImplemented); |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1163 } |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1164 |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1165 switch (image.GetFormat()) |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1166 { |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1167 case PixelFormat_RGBA32: |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1168 p[0] = red; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1169 p[1] = green; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1170 p[2] = blue; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1171 break; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1172 |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1173 case PixelFormat_BGRA32: |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1174 p[0] = blue; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1175 p[1] = green; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1176 p[2] = red; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1177 break; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1178 |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1179 default: |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1180 throw OrthancException(ErrorCode_NotImplemented); |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1181 } |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1182 |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1183 const unsigned int width = image.GetWidth(); |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1184 const unsigned int height = image.GetHeight(); |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1185 |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1186 for (unsigned int y = 0; y < height; y++) |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1187 { |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1188 uint8_t* q = reinterpret_cast<uint8_t*>(image.GetRow(y)); |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1189 uint8_t* a = reinterpret_cast<uint8_t*>(alpha.GetRow(y)); |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1190 |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1191 for (unsigned int x = 0; x < width; x++) |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1192 { |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1193 for (unsigned int i = 0; i < 3; i++) |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1194 { |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1195 q[i] = p[i]; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1196 } |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1197 q[3] = *a; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1198 q += 4; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1199 ++a; |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1200 } |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1201 } |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1202 } |
|
dabe17e23e23
Copy RGBA to BGRA & Set with alpha
Alain Mazy <alain@mazy.be>
parents:
3545
diff
changeset
|
1203 |
|
2089
7a969f235adf
PixelFormat_BGRA32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1994
diff
changeset
|
1204 |
|
854
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1205 void ImageProcessing::ShiftRight(ImageAccessor& image, |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1206 unsigned int shift) |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1207 { |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1208 if (image.GetWidth() == 0 || |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1209 image.GetHeight() == 0 || |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1210 shift == 0) |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1211 { |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1212 // Nothing to do |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1213 return; |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1214 } |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1215 |
| 3545 | 1216 switch (image.GetFormat()) |
| 1217 { | |
| 1218 case PixelFormat_Grayscale8: | |
| 1219 { | |
| 1220 ShiftRightInternal<uint8_t>(image, shift); | |
| 1221 break; | |
| 1222 } | |
| 1223 | |
| 1224 case PixelFormat_Grayscale16: | |
| 1225 { | |
| 1226 ShiftRightInternal<uint16_t>(image, shift); | |
| 1227 break; | |
| 1228 } | |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1229 default: |
| 3545 | 1230 throw OrthancException(ErrorCode_NotImplemented); |
| 1231 } | |
|
854
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1232 } |
|
ff530685e46a
fast version of image copy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
853
diff
changeset
|
1233 |
| 3545 | 1234 void ImageProcessing::ShiftLeft(ImageAccessor& image, |
| 1235 unsigned int shift) | |
| 1236 { | |
| 1237 if (image.GetWidth() == 0 || | |
| 1238 image.GetHeight() == 0 || | |
| 1239 shift == 0) | |
| 1240 { | |
| 1241 // Nothing to do | |
| 1242 return; | |
| 1243 } | |
| 1244 | |
| 1245 switch (image.GetFormat()) | |
| 1246 { | |
| 1247 case PixelFormat_Grayscale8: | |
| 1248 { | |
| 1249 ShiftLeftInternal<uint8_t>(image, shift); | |
| 1250 break; | |
| 1251 } | |
| 1252 | |
| 1253 case PixelFormat_Grayscale16: | |
| 1254 { | |
| 1255 ShiftLeftInternal<uint16_t>(image, shift); | |
| 1256 break; | |
| 1257 } | |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1258 default: |
| 3545 | 1259 throw OrthancException(ErrorCode_NotImplemented); |
| 1260 } | |
| 1261 } | |
| 863 | 1262 |
|
2415
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1263 void ImageProcessing::GetMinMaxIntegerValue(int64_t& minValue, |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1264 int64_t& maxValue, |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1265 const ImageAccessor& image) |
| 863 | 1266 { |
| 1267 switch (image.GetFormat()) | |
| 1268 { | |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1269 case PixelFormat_Grayscale8: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1270 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1271 uint8_t a, b; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1272 GetMinMaxValueInternal<uint8_t>(a, b, image); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1273 minValue = a; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1274 maxValue = b; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1275 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1276 } |
| 863 | 1277 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1278 case PixelFormat_Grayscale16: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1279 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1280 uint16_t a, b; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1281 GetMinMaxValueInternal<uint16_t>(a, b, image); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1282 minValue = a; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1283 maxValue = b; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1284 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1285 } |
| 863 | 1286 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1287 case PixelFormat_Grayscale32: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1288 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1289 uint32_t a, b; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1290 GetMinMaxValueInternal<uint32_t>(a, b, image); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1291 minValue = a; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1292 maxValue = b; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1293 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1294 } |
|
2415
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1295 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1296 case PixelFormat_SignedGrayscale16: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1297 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1298 int16_t a, b; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1299 GetMinMaxValueInternal<int16_t>(a, b, image); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1300 minValue = a; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1301 maxValue = b; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1302 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1303 } |
| 863 | 1304 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1305 default: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1306 throw OrthancException(ErrorCode_NotImplemented); |
| 863 | 1307 } |
| 1308 } | |
| 1309 | |
| 1310 | |
|
2415
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1311 void ImageProcessing::GetMinMaxFloatValue(float& minValue, |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1312 float& maxValue, |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1313 const ImageAccessor& image) |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1314 { |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1315 switch (image.GetFormat()) |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1316 { |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1317 case PixelFormat_Float32: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1318 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1319 assert(sizeof(float) == 4); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1320 float a, b; |
|
3525
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
1321 |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
1322 /** |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
1323 * WARNING - On floating-point types, the minimal value is |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
1324 * "-FLT_MAX" (as implemented by "::lowest()"), not "FLT_MIN" |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
1325 * (as implemented by "::min()") |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
1326 * https://en.cppreference.com/w/cpp/types/numeric_limits |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
1327 **/ |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
1328 GetMinMaxValueInternal<float>(a, b, image, -std::numeric_limits<float>::max()); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1329 minValue = a; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1330 maxValue = b; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1331 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1332 } |
|
2415
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1333 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1334 default: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1335 throw OrthancException(ErrorCode_NotImplemented); |
|
2415
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1336 } |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1337 } |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1338 |
|
7e217a1cc63f
PixelFormat_Float32
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2281
diff
changeset
|
1339 |
| 863 | 1340 |
| 1341 void ImageProcessing::AddConstant(ImageAccessor& image, | |
| 1342 int64_t value) | |
| 1343 { | |
| 1344 switch (image.GetFormat()) | |
| 1345 { | |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1346 case PixelFormat_Grayscale8: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1347 AddConstantInternal<uint8_t>(image, value); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1348 return; |
| 863 | 1349 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1350 case PixelFormat_Grayscale16: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1351 AddConstantInternal<uint16_t>(image, value); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1352 return; |
| 863 | 1353 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1354 case PixelFormat_SignedGrayscale16: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1355 AddConstantInternal<int16_t>(image, value); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1356 return; |
| 863 | 1357 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1358 default: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1359 throw OrthancException(ErrorCode_NotImplemented); |
| 863 | 1360 } |
| 1361 } | |
| 1362 | |
| 1363 | |
| 1364 void ImageProcessing::MultiplyConstant(ImageAccessor& image, | |
|
2488
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
1365 float factor, |
|
345725b9350c
back to rounding to fix integration tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2487
diff
changeset
|
1366 bool useRound) |
| 863 | 1367 { |
| 1368 switch (image.GetFormat()) | |
| 1369 { | |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1370 case PixelFormat_Grayscale8: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1371 if (useRound) |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1372 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1373 MultiplyConstantInternal<uint8_t, true>(image, factor); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1374 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1375 else |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1376 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1377 MultiplyConstantInternal<uint8_t, false>(image, factor); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1378 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1379 return; |
| 863 | 1380 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1381 case PixelFormat_Grayscale16: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1382 if (useRound) |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1383 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1384 MultiplyConstantInternal<uint16_t, true>(image, factor); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1385 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1386 else |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1387 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1388 MultiplyConstantInternal<uint16_t, false>(image, factor); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1389 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1390 return; |
| 863 | 1391 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1392 case PixelFormat_SignedGrayscale16: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1393 if (useRound) |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1394 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1395 MultiplyConstantInternal<int16_t, true>(image, factor); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1396 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1397 else |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1398 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1399 MultiplyConstantInternal<int16_t, false>(image, factor); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1400 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1401 return; |
| 863 | 1402 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1403 default: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1404 throw OrthancException(ErrorCode_NotImplemented); |
| 863 | 1405 } |
| 1406 } | |
| 1407 | |
| 1408 | |
|
4780
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1409 static bool IsIdentityRescaling(float offset, |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1410 float scaling) |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1411 { |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1412 return (std::abs(offset) <= 10.0f * std::numeric_limits<float>::epsilon() && |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1413 std::abs(scaling - 1.0f) <= 10.0f * std::numeric_limits<float>::epsilon()); |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1414 } |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1415 |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1416 |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1417 void ImageProcessing::ShiftScale2(ImageAccessor& image, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1418 float offset, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1419 float scaling, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1420 bool useRound) |
| 863 | 1421 { |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1422 // We compute "a * x + b" |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1423 const float a = scaling; |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1424 const float b = offset; |
|
4780
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1425 |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1426 if (IsIdentityRescaling(offset, scaling)) |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1427 { |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1428 return; |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1429 } |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1430 |
| 863 | 1431 switch (image.GetFormat()) |
| 1432 { | |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1433 case PixelFormat_Grayscale8: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1434 if (useRound) |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1435 { |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1436 ShiftScaleInternal<uint8_t, uint8_t, true, false>(image, image, a, b, std::numeric_limits<uint8_t>::min()); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1437 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1438 else |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1439 { |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1440 ShiftScaleInternal<uint8_t, uint8_t, false, false>(image, image, a, b, std::numeric_limits<uint8_t>::min()); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1441 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1442 return; |
| 863 | 1443 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1444 case PixelFormat_Grayscale16: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1445 if (useRound) |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1446 { |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1447 ShiftScaleInternal<uint16_t, uint16_t, true, false>(image, image, a, b, std::numeric_limits<uint16_t>::min()); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1448 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1449 else |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1450 { |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1451 ShiftScaleInternal<uint16_t, uint16_t, false, false>(image, image, a, b, std::numeric_limits<uint16_t>::min()); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1452 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1453 return; |
| 863 | 1454 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1455 case PixelFormat_SignedGrayscale16: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1456 if (useRound) |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1457 { |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1458 ShiftScaleInternal<int16_t, int16_t, true, false>(image, image, a, b, std::numeric_limits<int16_t>::min()); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1459 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1460 else |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1461 { |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1462 ShiftScaleInternal<int16_t, int16_t, false, false>(image, image, a, b, std::numeric_limits<int16_t>::min()); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1463 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1464 return; |
| 863 | 1465 |
|
3505
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
1466 case PixelFormat_Float32: |
|
3684
3971ec6b1f72
fix for older compilers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3683
diff
changeset
|
1467 // "::min()" must be replaced by "::lowest()" or "-::max()" if dealing with float or double. |
|
3505
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
1468 if (useRound) |
|
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
1469 { |
|
3684
3971ec6b1f72
fix for older compilers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3683
diff
changeset
|
1470 ShiftScaleInternal<float, float, true, false>(image, image, a, b, -std::numeric_limits<float>::max()); |
|
3505
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
1471 } |
|
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
1472 else |
|
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
1473 { |
|
3684
3971ec6b1f72
fix for older compilers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3683
diff
changeset
|
1474 ShiftScaleInternal<float, float, false, false>(image, image, a, b, -std::numeric_limits<float>::max()); |
|
3505
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
1475 } |
|
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
1476 return; |
|
b2d4dd16dae8
removed C++11 primitive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3504
diff
changeset
|
1477 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1478 default: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1479 throw OrthancException(ErrorCode_NotImplemented); |
| 863 | 1480 } |
| 1481 } | |
|
2281
e002430baa41
Fix issue #44 (Bad interpretation of photometric interpretation MONOCHROME1)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2252
diff
changeset
|
1482 |
|
e002430baa41
Fix issue #44 (Bad interpretation of photometric interpretation MONOCHROME1)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2252
diff
changeset
|
1483 |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1484 void ImageProcessing::ShiftScale2(ImageAccessor& target, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1485 const ImageAccessor& source, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1486 float offset, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1487 float scaling, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1488 bool useRound) |
|
3690
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1489 { |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1490 // We compute "a * x + b" |
|
3690
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1491 const float a = scaling; |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1492 const float b = offset; |
|
3690
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1493 |
|
4780
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1494 if (target.GetFormat() == source.GetFormat() && |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1495 IsIdentityRescaling(offset, scaling)) |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1496 { |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1497 Copy(target, source); |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1498 return; |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1499 } |
|
ebb801d44e06
optimization in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4664
diff
changeset
|
1500 |
|
3690
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1501 switch (target.GetFormat()) |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1502 { |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1503 case PixelFormat_Grayscale8: |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1504 |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1505 switch (source.GetFormat()) |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1506 { |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1507 case PixelFormat_Float32: |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1508 if (useRound) |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1509 { |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1510 ShiftScaleInternal<uint8_t, float, true, false>( |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1511 target, source, a, b, std::numeric_limits<uint8_t>::min()); |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1512 } |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1513 else |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1514 { |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1515 ShiftScaleInternal<uint8_t, float, false, false>( |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1516 target, source, a, b, std::numeric_limits<uint8_t>::min()); |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1517 } |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1518 return; |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1519 |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1520 default: |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1521 throw OrthancException(ErrorCode_NotImplemented); |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1522 } |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1523 |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1524 default: |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1525 throw OrthancException(ErrorCode_NotImplemented); |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1526 } |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1527 } |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1528 |
|
a9ce35d67c3c
implementation of "/instances/.../rendered" for grayscale images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3684
diff
changeset
|
1529 |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1530 void ImageProcessing::ShiftScale(ImageAccessor& image, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1531 float offset, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1532 float scaling, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1533 bool useRound) |
|
4079
73c22208272f
ImageProcessing::ShiftScale2()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1534 { |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1535 // Rewrite "(x + offset) * scaling" as "a * x + b" |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1536 |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1537 const float a = scaling; |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1538 const float b = offset * scaling; |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1539 ShiftScale2(image, b, a, useRound); |
|
4079
73c22208272f
ImageProcessing::ShiftScale2()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1540 } |
|
73c22208272f
ImageProcessing::ShiftScale2()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1541 |
|
73c22208272f
ImageProcessing::ShiftScale2()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1542 |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1543 void ImageProcessing::ShiftScale(ImageAccessor& target, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1544 const ImageAccessor& source, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1545 float offset, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1546 float scaling, |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1547 bool useRound) |
|
4079
73c22208272f
ImageProcessing::ShiftScale2()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1548 { |
|
4080
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1549 // Rewrite "(x + offset) * scaling" as "a * x + b" |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1550 |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1551 const float a = scaling; |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1552 const float b = offset * scaling; |
|
f18eaade6153
simplification in ImageProcessing::ShiftScale()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4079
diff
changeset
|
1553 ShiftScale2(target, source, b, a, useRound); |
|
4079
73c22208272f
ImageProcessing::ShiftScale2()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1554 } |
|
73c22208272f
ImageProcessing::ShiftScale2()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1555 |
|
73c22208272f
ImageProcessing::ShiftScale2()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1556 |
|
73c22208272f
ImageProcessing::ShiftScale2()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1557 |
| 3227 | 1558 void ImageProcessing::Invert(ImageAccessor& image, int64_t maxValue) |
| 1559 { | |
| 1560 const unsigned int width = image.GetWidth(); | |
| 1561 const unsigned int height = image.GetHeight(); | |
| 1562 | |
| 1563 switch (image.GetFormat()) | |
| 1564 { | |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1565 case PixelFormat_Grayscale16: |
| 3227 | 1566 { |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1567 uint16_t maxValueUint16 = (uint16_t)(std::min(maxValue, static_cast<int64_t>(std::numeric_limits<uint16_t>::max()))); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1568 |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1569 for (unsigned int y = 0; y < height; y++) |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1570 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1571 uint16_t* p = reinterpret_cast<uint16_t*>(image.GetRow(y)); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1572 |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1573 for (unsigned int x = 0; x < width; x++, p++) |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1574 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1575 *p = maxValueUint16 - (*p); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1576 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1577 } |
| 3227 | 1578 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1579 return; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1580 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1581 case PixelFormat_Grayscale8: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1582 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1583 uint8_t maxValueUint8 = (uint8_t)(std::min(maxValue, static_cast<int64_t>(std::numeric_limits<uint8_t>::max()))); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1584 |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1585 for (unsigned int y = 0; y < height; y++) |
| 3227 | 1586 { |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1587 uint8_t* p = reinterpret_cast<uint8_t*>(image.GetRow(y)); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1588 |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1589 for (unsigned int x = 0; x < width; x++, p++) |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1590 { |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1591 *p = maxValueUint8 - (*p); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1592 } |
| 3227 | 1593 } |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1594 |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1595 return; |
| 3227 | 1596 } |
| 1597 | |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1598 default: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1599 throw OrthancException(ErrorCode_NotImplemented); |
| 3227 | 1600 } |
| 1601 | |
| 1602 } | |
| 1603 | |
|
2281
e002430baa41
Fix issue #44 (Bad interpretation of photometric interpretation MONOCHROME1)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2252
diff
changeset
|
1604 void ImageProcessing::Invert(ImageAccessor& image) |
|
e002430baa41
Fix issue #44 (Bad interpretation of photometric interpretation MONOCHROME1)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2252
diff
changeset
|
1605 { |
|
e002430baa41
Fix issue #44 (Bad interpretation of photometric interpretation MONOCHROME1)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2252
diff
changeset
|
1606 switch (image.GetFormat()) |
|
e002430baa41
Fix issue #44 (Bad interpretation of photometric interpretation MONOCHROME1)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2252
diff
changeset
|
1607 { |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1608 case PixelFormat_Grayscale8: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1609 return Invert(image, 255); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1610 default: |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1611 throw OrthancException(ErrorCode_NotImplemented); // you should use the Invert(image, maxValue) overload |
| 3227 | 1612 } |
|
2281
e002430baa41
Fix issue #44 (Bad interpretation of photometric interpretation MONOCHROME1)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2252
diff
changeset
|
1613 } |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1614 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1615 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1616 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1617 namespace |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1618 { |
| 4297 | 1619 template <PixelFormat Format> |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1620 class BresenhamPixelWriter |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1621 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1622 private: |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1623 typedef typename PixelTraits<Format>::PixelType PixelType; |
| 3227 | 1624 |
| 4297 | 1625 ImageAccessor& image_; |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1626 PixelType value_; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1627 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1628 void PlotLineLow(int x0, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1629 int y0, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1630 int x1, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1631 int y1) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1632 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1633 int dx = x1 - x0; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1634 int dy = y1 - y0; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1635 int yi = 1; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1636 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1637 if (dy < 0) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1638 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1639 yi = -1; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1640 dy = -dy; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1641 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1642 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1643 int d = 2 * dy - dx; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1644 int y = y0; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1645 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1646 for (int x = x0; x <= x1; x++) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1647 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1648 Write(x, y); |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1649 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1650 if (d > 0) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1651 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1652 y = y + yi; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1653 d = d - 2 * dx; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1654 } |
| 3227 | 1655 |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1656 d = d + 2*dy; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1657 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1658 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1659 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1660 void PlotLineHigh(int x0, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1661 int y0, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1662 int x1, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1663 int y1) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1664 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1665 int dx = x1 - x0; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1666 int dy = y1 - y0; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1667 int xi = 1; |
| 3227 | 1668 |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1669 if (dx < 0) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1670 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1671 xi = -1; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1672 dx = -dx; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1673 } |
| 3227 | 1674 |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1675 int d = 2 * dx - dy; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1676 int x = x0; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1677 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1678 for (int y = y0; y <= y1; y++) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1679 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1680 Write(x, y); |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1681 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1682 if (d > 0) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1683 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1684 x = x + xi; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1685 d = d - 2 * dy; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1686 } |
| 3227 | 1687 |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1688 d = d + 2 * dx; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1689 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1690 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1691 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1692 public: |
| 4297 | 1693 BresenhamPixelWriter(ImageAccessor& image, |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1694 int64_t value) : |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1695 image_(image), |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1696 value_(PixelTraits<Format>::IntegerToPixel(value)) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1697 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1698 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1699 |
| 4297 | 1700 BresenhamPixelWriter(ImageAccessor& image, |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1701 const PixelType& value) : |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1702 image_(image), |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1703 value_(value) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1704 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1705 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1706 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1707 void Write(int x, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1708 int y) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1709 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1710 if (x >= 0 && |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1711 y >= 0 && |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1712 static_cast<unsigned int>(x) < image_.GetWidth() && |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1713 static_cast<unsigned int>(y) < image_.GetHeight()) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1714 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1715 PixelType* p = reinterpret_cast<PixelType*>(image_.GetRow(y)); |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1716 p[x] = value_; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1717 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1718 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1719 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1720 void DrawSegment(int x0, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1721 int y0, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1722 int x1, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1723 int y1) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1724 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1725 // This is an implementation of Bresenham's line algorithm |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1726 // https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm#All_cases |
| 3227 | 1727 |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1728 if (abs(y1 - y0) < abs(x1 - x0)) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1729 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1730 if (x0 > x1) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1731 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1732 PlotLineLow(x1, y1, x0, y0); |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1733 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1734 else |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1735 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1736 PlotLineLow(x0, y0, x1, y1); |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1737 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1738 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1739 else |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1740 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1741 if (y0 > y1) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1742 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1743 PlotLineHigh(x1, y1, x0, y0); |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1744 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1745 else |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1746 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1747 PlotLineHigh(x0, y0, x1, y1); |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1748 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1749 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1750 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1751 }; |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1752 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1753 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1754 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1755 void ImageProcessing::DrawLineSegment(ImageAccessor& image, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1756 int x0, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1757 int y0, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1758 int x1, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1759 int y1, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1760 int64_t value) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1761 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1762 switch (image.GetFormat()) |
| 3227 | 1763 { |
| 4297 | 1764 case PixelFormat_Grayscale8: |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1765 { |
| 4297 | 1766 BresenhamPixelWriter<PixelFormat_Grayscale8> writer(image, value); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1767 writer.DrawSegment(x0, y0, x1, y1); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1768 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1769 } |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1770 |
| 4297 | 1771 case PixelFormat_Grayscale16: |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1772 { |
| 4297 | 1773 BresenhamPixelWriter<PixelFormat_Grayscale16> writer(image, value); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1774 writer.DrawSegment(x0, y0, x1, y1); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1775 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1776 } |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1777 |
| 4297 | 1778 case PixelFormat_SignedGrayscale16: |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1779 { |
| 4297 | 1780 BresenhamPixelWriter<PixelFormat_SignedGrayscale16> writer(image, value); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1781 writer.DrawSegment(x0, y0, x1, y1); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1782 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1783 } |
| 3227 | 1784 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1785 default: |
| 4297 | 1786 throw OrthancException(ErrorCode_NotImplemented); |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1787 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1788 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1789 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1790 |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1791 void ImageProcessing::DrawLineSegment(ImageAccessor& image, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1792 int x0, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1793 int y0, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1794 int x1, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1795 int y1, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1796 uint8_t red, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1797 uint8_t green, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1798 uint8_t blue, |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1799 uint8_t alpha) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1800 { |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1801 switch (image.GetFormat()) |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1802 { |
| 4297 | 1803 case PixelFormat_BGRA32: |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1804 { |
| 4297 | 1805 PixelTraits<PixelFormat_BGRA32>::PixelType pixel; |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1806 pixel.red_ = red; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1807 pixel.green_ = green; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1808 pixel.blue_ = blue; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1809 pixel.alpha_ = alpha; |
| 3227 | 1810 |
| 4297 | 1811 BresenhamPixelWriter<PixelFormat_BGRA32> writer(image, pixel); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1812 writer.DrawSegment(x0, y0, x1, y1); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1813 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1814 } |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1815 |
| 4297 | 1816 case PixelFormat_RGBA32: |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1817 { |
| 4297 | 1818 PixelTraits<PixelFormat_RGBA32>::PixelType pixel; |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1819 pixel.red_ = red; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1820 pixel.green_ = green; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1821 pixel.blue_ = blue; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1822 pixel.alpha_ = alpha; |
| 3227 | 1823 |
| 4297 | 1824 BresenhamPixelWriter<PixelFormat_RGBA32> writer(image, pixel); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1825 writer.DrawSegment(x0, y0, x1, y1); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1826 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1827 } |
|
2783
65699fcb4e99
PixelTraits<PixelFormat_RGBA32>
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2650
diff
changeset
|
1828 |
| 4297 | 1829 case PixelFormat_RGB24: |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1830 { |
| 4297 | 1831 PixelTraits<PixelFormat_RGB24>::PixelType pixel; |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1832 pixel.red_ = red; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1833 pixel.green_ = green; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1834 pixel.blue_ = blue; |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1835 |
| 4297 | 1836 BresenhamPixelWriter<PixelFormat_RGB24> writer(image, pixel); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1837 writer.DrawSegment(x0, y0, x1, y1); |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1838 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1839 } |
| 3227 | 1840 |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1841 default: |
| 4297 | 1842 throw OrthancException(ErrorCode_NotImplemented); |
|
2489
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1843 } |
|
e91bab2d8c75
Bresenham's line algorithm
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2488
diff
changeset
|
1844 } |
| 3258 | 1845 |
| 1846 void ComputePolygonExtent(int32_t& left, int32_t& right, int32_t& top, int32_t& bottom, const std::vector<ImageProcessing::ImagePoint>& points) | |
| 1847 { | |
| 1848 left = std::numeric_limits<int32_t>::max(); | |
| 1849 right = std::numeric_limits<int32_t>::min(); | |
| 1850 top = std::numeric_limits<int32_t>::max(); | |
| 1851 bottom = std::numeric_limits<int32_t>::min(); | |
| 1852 | |
| 1853 for (size_t i = 0; i < points.size(); i++) | |
| 1854 { | |
| 1855 const ImageProcessing::ImagePoint& p = points[i]; | |
| 1856 left = std::min(p.GetX(), left); | |
| 1857 right = std::max(p.GetX(), right); | |
| 1858 bottom = std::max(p.GetY(), bottom); | |
| 1859 top = std::min(p.GetY(), top); | |
| 1860 } | |
| 1861 } | |
| 1862 | |
| 1863 template <PixelFormat TargetFormat> | |
| 1864 void FillPolygon_(ImageAccessor& image, | |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1865 const std::vector<ImageProcessing::ImagePoint>& points, |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1866 int64_t value_) |
| 3258 | 1867 { |
| 1868 typedef typename PixelTraits<TargetFormat>::PixelType TargetType; | |
| 1869 | |
| 1870 TargetType value = PixelTraits<TargetFormat>::IntegerToPixel(value_); | |
|
3323
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1871 int imageWidth = static_cast<int>(image.GetWidth()); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1872 int imageHeight = static_cast<int>(image.GetHeight()); |
| 3258 | 1873 int32_t left; |
| 1874 int32_t right; | |
| 1875 int32_t top; | |
| 1876 int32_t bottom; | |
| 1877 | |
|
3323
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1878 // TODO: test clipping in UT (in Trello board) |
| 3258 | 1879 ComputePolygonExtent(left, right, top, bottom, points); |
| 1880 | |
|
3323
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1881 // clip the computed extent with the target image |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1882 // L and R |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1883 left = std::max(0, left); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1884 left = std::min(imageWidth, left); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1885 right = std::max(0, right); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1886 right = std::min(imageWidth, right); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1887 if (left > right) |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1888 std::swap(left, right); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1889 |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1890 // T and B |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1891 top = std::max(0, top); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1892 top = std::min(imageHeight, top); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1893 bottom = std::max(0, bottom); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1894 bottom = std::min(imageHeight, bottom); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1895 if (top > bottom) |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1896 std::swap(top, bottom); |
|
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1897 |
| 3258 | 1898 // from http://alienryderflex.com/polygon_fill/ |
| 1899 | |
| 1900 // convert all "corner" points to double only once | |
| 1901 std::vector<double> cpx; | |
| 1902 std::vector<double> cpy; | |
| 1903 size_t cpSize = points.size(); | |
| 1904 for (size_t i = 0; i < points.size(); i++) | |
| 1905 { | |
| 3365 | 1906 if (points[i].GetX() < 0 || points[i].GetX() >= imageWidth |
| 1907 || points[i].GetY() < 0 || points[i].GetY() >= imageHeight) | |
| 1908 { | |
| 4297 | 1909 throw OrthancException(ErrorCode_ParameterOutOfRange); |
| 3365 | 1910 } |
| 3258 | 1911 cpx.push_back((double)points[i].GetX()); |
| 1912 cpy.push_back((double)points[i].GetY()); | |
| 1913 } | |
| 1914 | |
| 3431 | 1915 // Draw the lines segments |
| 1916 for (size_t i = 0; i < (points.size() -1); i++) | |
| 1917 { | |
| 1918 ImageProcessing::DrawLineSegment(image, points[i].GetX(), points[i].GetY(), points[i+1].GetX(), points[i+1].GetY(), value_); | |
| 1919 } | |
| 1920 ImageProcessing::DrawLineSegment(image, points[points.size() -1].GetX(), points[points.size() -1].GetY(), points[0].GetX(), points[0].GetY(), value_); | |
| 1921 | |
| 3258 | 1922 std::vector<int32_t> nodeX; |
| 1923 nodeX.resize(cpSize); | |
| 4201 | 1924 int pixelX, pixelY, i, swap ; |
| 3258 | 1925 |
| 1926 // Loop through the rows of the image. | |
| 1927 for (pixelY = top; pixelY < bottom; pixelY++) | |
| 1928 { | |
| 1929 double y = (double)pixelY; | |
| 1930 // Build a list of nodes. | |
| 4201 | 1931 int nodes = 0; |
| 1932 int j = static_cast<int>(cpSize) - 1; | |
| 3258 | 1933 |
|
3259
6f9398eb902d
unit test Toolbox.SubstituteVariables
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3258
diff
changeset
|
1934 for (i = 0; i < static_cast<int>(cpSize); i++) |
| 3258 | 1935 { |
| 1936 if ((cpy[i] < y && cpy[j] >= y) || (cpy[j] < y && cpy[i] >= y)) | |
| 1937 { | |
| 1938 nodeX[nodes++] = (int32_t)(cpx[i] + (y - cpy[i])/(cpy[j] - cpy[i]) * (cpx[j] - cpx[i])); | |
| 1939 } | |
| 1940 j=i; | |
| 1941 } | |
| 1942 | |
| 1943 // Sort the nodes, via a simple “Bubble” sort. | |
| 1944 i=0; | |
| 1945 while (i < nodes-1) | |
| 1946 { | |
| 1947 if (nodeX[i] > nodeX[i+1]) | |
| 1948 { | |
| 1949 swap = nodeX[i]; | |
| 1950 nodeX[i] = nodeX[i+1]; | |
| 1951 nodeX[i+1] = swap; | |
| 1952 if (i > 0) | |
| 1953 { | |
| 1954 i--; | |
| 1955 } | |
| 1956 } | |
| 1957 else | |
| 1958 { | |
| 1959 i++; | |
| 1960 } | |
| 1961 } | |
| 1962 | |
| 1963 TargetType* row = reinterpret_cast<TargetType*>(image.GetRow(pixelY)); | |
| 1964 // Fill the pixels between node pairs. | |
|
3323
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1965 for (i = 0; i < nodes; i += 2) |
| 3258 | 1966 { |
| 1967 if (nodeX[i] >= right) | |
| 1968 break; | |
| 1969 | |
|
3323
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1970 if (nodeX[i + 1] >= left) |
| 3258 | 1971 { |
|
3323
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1972 if (nodeX[i] < left) |
| 3258 | 1973 { |
| 1974 nodeX[i] = left; | |
| 1975 } | |
| 1976 | |
|
3323
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1977 if (nodeX[i + 1] > right) |
| 3258 | 1978 { |
|
3323
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1979 nodeX[i + 1] = right; |
| 3258 | 1980 } |
| 1981 | |
|
3323
a15a4b9d8c00
Added image clipping to <T> FillPolygon_ to prevent out-of-memory access
Benjamin Golinvaux <bgo@osimis.io>
parents:
3265
diff
changeset
|
1982 for (pixelX = nodeX[i]; pixelX <= nodeX[i + 1]; pixelX++) |
| 3258 | 1983 { |
| 1984 *(row + pixelX) = value; | |
| 1985 } | |
| 1986 } | |
| 1987 } | |
| 1988 } | |
| 1989 } | |
| 1990 | |
| 1991 void ImageProcessing::FillPolygon(ImageAccessor& image, | |
| 1992 const std::vector<ImagePoint>& points, | |
| 1993 int64_t value) | |
| 1994 { | |
| 1995 switch (image.GetFormat()) | |
| 1996 { | |
| 4297 | 1997 case PixelFormat_Grayscale8: |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
1998 { |
| 4297 | 1999 FillPolygon_<PixelFormat_Grayscale8>(image, points, value); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
2000 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
2001 } |
| 4297 | 2002 case PixelFormat_Grayscale16: |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
2003 { |
| 4297 | 2004 FillPolygon_<PixelFormat_Grayscale16>(image, points, value); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
2005 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
2006 } |
| 4297 | 2007 case PixelFormat_SignedGrayscale16: |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
2008 { |
| 4297 | 2009 FillPolygon_<PixelFormat_SignedGrayscale16>(image, points, value); |
|
3499
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
2010 break; |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
2011 } |
|
d8f7c3970e25
more tolerance in ImageProcessing::Set()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3431
diff
changeset
|
2012 default: |
| 4297 | 2013 throw OrthancException(ErrorCode_NotImplemented); |
| 3258 | 2014 } |
| 2015 } | |
|
3502
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2016 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2017 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2018 template <PixelFormat Format> |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2019 static void ResizeInternal(ImageAccessor& target, |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2020 const ImageAccessor& source) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2021 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2022 assert(target.GetFormat() == source.GetFormat() && |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2023 target.GetFormat() == Format); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2024 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2025 const unsigned int sourceWidth = source.GetWidth(); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2026 const unsigned int sourceHeight = source.GetHeight(); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2027 const unsigned int targetWidth = target.GetWidth(); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2028 const unsigned int targetHeight = target.GetHeight(); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2029 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2030 if (targetWidth == 0 || targetHeight == 0) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2031 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2032 return; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2033 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2034 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2035 if (sourceWidth == 0 || sourceHeight == 0) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2036 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2037 // Avoids division by zero below |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2038 ImageProcessing::Set(target, 0); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2039 return; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2040 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2041 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2042 const float scaleX = static_cast<float>(sourceWidth) / static_cast<float>(targetWidth); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2043 const float scaleY = static_cast<float>(sourceHeight) / static_cast<float>(targetHeight); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2044 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2045 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2046 /** |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2047 * Create two lookup tables to quickly know the (x,y) position |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2048 * in the source image, given the (x,y) position in the target |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2049 * image. |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2050 **/ |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2051 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2052 std::vector<unsigned int> lookupX(targetWidth); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2053 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2054 for (unsigned int x = 0; x < targetWidth; x++) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2055 { |
|
3585
113a9643e8bb
Suppressed a few warnings when building with emscripten (clang) + numeric truncation warnings
Benjamin Golinvaux <bgo@osimis.io>
parents:
3565
diff
changeset
|
2056 int sourceX = static_cast<int>(std::floor((static_cast<float>(x) + 0.5f) * scaleX)); |
|
3502
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2057 if (sourceX < 0) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2058 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2059 sourceX = 0; // Should never happen |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2060 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2061 else if (sourceX >= static_cast<int>(sourceWidth)) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2062 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2063 sourceX = sourceWidth - 1; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2064 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2065 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2066 lookupX[x] = static_cast<unsigned int>(sourceX); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2067 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2068 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2069 std::vector<unsigned int> lookupY(targetHeight); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2070 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2071 for (unsigned int y = 0; y < targetHeight; y++) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2072 { |
|
3585
113a9643e8bb
Suppressed a few warnings when building with emscripten (clang) + numeric truncation warnings
Benjamin Golinvaux <bgo@osimis.io>
parents:
3565
diff
changeset
|
2073 int sourceY = static_cast<int>(std::floor((static_cast<float>(y) + 0.5f) * scaleY)); |
|
3502
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2074 if (sourceY < 0) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2075 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2076 sourceY = 0; // Should never happen |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2077 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2078 else if (sourceY >= static_cast<int>(sourceHeight)) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2079 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2080 sourceY = sourceHeight - 1; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2081 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2082 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2083 lookupY[y] = static_cast<unsigned int>(sourceY); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2084 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2085 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2086 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2087 /** |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2088 * Actual resizing |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2089 **/ |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2090 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2091 for (unsigned int targetY = 0; targetY < targetHeight; targetY++) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2092 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2093 unsigned int sourceY = lookupY[targetY]; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2094 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2095 for (unsigned int targetX = 0; targetX < targetWidth; targetX++) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2096 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2097 unsigned int sourceX = lookupX[targetX]; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2098 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2099 typename ImageTraits<Format>::PixelType pixel; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2100 ImageTraits<Format>::GetPixel(pixel, source, sourceX, sourceY); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2101 ImageTraits<Format>::SetPixel(target, pixel, targetX, targetY); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2102 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2103 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2104 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2105 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2106 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2107 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2108 void ImageProcessing::Resize(ImageAccessor& target, |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2109 const ImageAccessor& source) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2110 { |
| 4201 | 2111 if (source.GetFormat() != target.GetFormat()) |
|
3502
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2112 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2113 throw OrthancException(ErrorCode_IncompatibleImageFormat); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2114 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2115 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2116 if (source.GetWidth() == target.GetWidth() && |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2117 source.GetHeight() == target.GetHeight()) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2118 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2119 Copy(target, source); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2120 return; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2121 } |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
2122 |
|
3502
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2123 switch (source.GetFormat()) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2124 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2125 case PixelFormat_Grayscale8: |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2126 ResizeInternal<PixelFormat_Grayscale8>(target, source); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2127 break; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2128 |
|
3548
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
2129 case PixelFormat_Float32: |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
2130 ResizeInternal<PixelFormat_Float32>(target, source); |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
2131 break; |
|
e1ce68692069
ImageProcessing::ApplyWindowing
Alain Mazy <alain@mazy.be>
parents:
3547
diff
changeset
|
2132 |
|
3502
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2133 case PixelFormat_RGB24: |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2134 ResizeInternal<PixelFormat_RGB24>(target, source); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2135 break; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2136 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2137 default: |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2138 throw OrthancException(ErrorCode_NotImplemented); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2139 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2140 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2141 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2142 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2143 ImageAccessor* ImageProcessing::Halve(const ImageAccessor& source, |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2144 bool forceMinimalPitch) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2145 { |
|
3712
2a170a8f1faf
replacing std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3690
diff
changeset
|
2146 std::unique_ptr<Image> target(new Image(source.GetFormat(), source.GetWidth() / 2, |
|
2a170a8f1faf
replacing std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3690
diff
changeset
|
2147 source.GetHeight() / 2, forceMinimalPitch)); |
|
3502
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2148 Resize(*target, source); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2149 return target.release(); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2150 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2151 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2152 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2153 template <PixelFormat Format> |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2154 static void FlipXInternal(ImageAccessor& image) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2155 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2156 const unsigned int height = image.GetHeight(); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2157 const unsigned int width = image.GetWidth(); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2158 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2159 for (unsigned int y = 0; y < height; y++) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2160 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2161 for (unsigned int x1 = 0; x1 < width / 2; x1++) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2162 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2163 unsigned int x2 = width - 1 - x1; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2164 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2165 typename ImageTraits<Format>::PixelType a, b; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2166 ImageTraits<Format>::GetPixel(a, image, x1, y); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2167 ImageTraits<Format>::GetPixel(b, image, x2, y); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2168 ImageTraits<Format>::SetPixel(image, a, x2, y); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2169 ImageTraits<Format>::SetPixel(image, b, x1, y); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2170 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2171 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2172 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2173 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2174 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2175 void ImageProcessing::FlipX(ImageAccessor& image) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2176 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2177 switch (image.GetFormat()) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2178 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2179 case PixelFormat_Grayscale8: |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2180 FlipXInternal<PixelFormat_Grayscale8>(image); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2181 break; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2182 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2183 case PixelFormat_RGB24: |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2184 FlipXInternal<PixelFormat_RGB24>(image); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2185 break; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2186 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2187 default: |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2188 throw OrthancException(ErrorCode_NotImplemented); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2189 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2190 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2191 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2192 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2193 template <PixelFormat Format> |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2194 static void FlipYInternal(ImageAccessor& image) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2195 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2196 const unsigned int height = image.GetHeight(); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2197 const unsigned int width = image.GetWidth(); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2198 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2199 for (unsigned int y1 = 0; y1 < height / 2; y1++) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2200 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2201 unsigned int y2 = height - 1 - y1; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2202 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2203 for (unsigned int x = 0; x < width; x++) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2204 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2205 typename ImageTraits<Format>::PixelType a, b; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2206 ImageTraits<Format>::GetPixel(a, image, x, y1); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2207 ImageTraits<Format>::GetPixel(b, image, x, y2); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2208 ImageTraits<Format>::SetPixel(image, a, x, y2); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2209 ImageTraits<Format>::SetPixel(image, b, x, y1); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2210 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2211 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2212 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2213 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2214 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2215 void ImageProcessing::FlipY(ImageAccessor& image) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2216 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2217 switch (image.GetFormat()) |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2218 { |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2219 case PixelFormat_Grayscale8: |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2220 FlipYInternal<PixelFormat_Grayscale8>(image); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2221 break; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2222 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2223 case PixelFormat_RGB24: |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2224 FlipYInternal<PixelFormat_RGB24>(image); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2225 break; |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2226 |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2227 default: |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2228 throw OrthancException(ErrorCode_NotImplemented); |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2229 } |
|
c160eafc42a9
new functions in ImageProcessing toolbox: FlipX/Y(), Resize(), Halve()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3499
diff
changeset
|
2230 } |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2231 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2232 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2233 // This is a slow implementation of horizontal convolution on one |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2234 // individual channel, that checks for out-of-image values |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2235 template <typename RawPixel, unsigned int ChannelsCount> |
| 4297 | 2236 static float GetHorizontalConvolutionFloatSecure(const ImageAccessor& source, |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2237 const std::vector<float>& horizontal, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2238 size_t horizontalAnchor, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2239 unsigned int x, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2240 unsigned int y, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2241 float leftBorder, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2242 float rightBorder, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2243 unsigned int channel) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2244 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2245 const RawPixel* row = reinterpret_cast<const RawPixel*>(source.GetConstRow(y)) + channel; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2246 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2247 float p = 0; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2248 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2249 for (unsigned int k = 0; k < horizontal.size(); k++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2250 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2251 float value; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2252 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2253 if (x + k < horizontalAnchor) // Negation of "x - horizontalAnchor + k >= 0" |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2254 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2255 value = leftBorder; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2256 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2257 else if (x + k >= source.GetWidth() + horizontalAnchor) // Negation of "x - horizontalAnchor + k < width" |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2258 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2259 value = rightBorder; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2260 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2261 else |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2262 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2263 // The value lies within the image |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2264 value = row[(x - horizontalAnchor + k) * ChannelsCount]; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2265 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2266 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2267 p += value * horizontal[k]; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2268 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2269 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2270 return p; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2271 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2272 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2273 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2274 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2275 // This is an implementation of separable convolution that uses |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2276 // floating-point arithmetics, and an intermediate Float32 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2277 // image. The out-of-image values are taken as the border |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2278 // value. Further optimization is possible. |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2279 template <typename RawPixel, unsigned int ChannelsCount, bool UseRound> |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2280 static void SeparableConvolutionFloat(ImageAccessor& image /* inplace */, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2281 const std::vector<float>& horizontal, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2282 size_t horizontalAnchor, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2283 const std::vector<float>& vertical, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2284 size_t verticalAnchor, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2285 float normalization) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2286 { |
|
3525
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
2287 // WARNING - "::min()" should be replaced by "::lowest()" if |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
2288 // dealing with float or double (which is not the case so far) |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
2289 assert(sizeof(RawPixel) <= 2); // Safeguard to remember about "float/double" |
|
8c66c9c2257b
fix ImageProcessing::ShiftScale() on float images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3505
diff
changeset
|
2290 |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2291 const unsigned int width = image.GetWidth(); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2292 const unsigned int height = image.GetHeight(); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2293 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2294 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2295 /** |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2296 * Horizontal convolution |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2297 **/ |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2298 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2299 Image tmp(PixelFormat_Float32, ChannelsCount * width, height, false); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2300 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2301 for (unsigned int y = 0; y < height; y++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2302 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2303 const RawPixel* row = reinterpret_cast<const RawPixel*>(image.GetConstRow(y)); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2304 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2305 float leftBorder[ChannelsCount], rightBorder[ChannelsCount]; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2306 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2307 for (unsigned int c = 0; c < ChannelsCount; c++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2308 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2309 leftBorder[c] = row[c]; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2310 rightBorder[c] = row[ChannelsCount * (width - 1) + c]; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2311 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2312 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2313 float* p = static_cast<float*>(tmp.GetRow(y)); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2314 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2315 if (width < horizontal.size()) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2316 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2317 // It is not possible to have the full kernel within the image, use the direct implementation |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2318 for (unsigned int x = 0; x < width; x++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2319 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2320 for (unsigned int c = 0; c < ChannelsCount; c++, p++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2321 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2322 *p = GetHorizontalConvolutionFloatSecure<RawPixel, ChannelsCount> |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2323 (image, horizontal, horizontalAnchor, x, y, leftBorder[c], rightBorder[c], c); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2324 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2325 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2326 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2327 else |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2328 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2329 // Deal with the left border |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2330 for (unsigned int x = 0; x < horizontalAnchor; x++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2331 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2332 for (unsigned int c = 0; c < ChannelsCount; c++, p++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2333 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2334 *p = GetHorizontalConvolutionFloatSecure<RawPixel, ChannelsCount> |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2335 (image, horizontal, horizontalAnchor, x, y, leftBorder[c], rightBorder[c], c); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2336 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2337 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2338 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2339 // Deal with the central portion of the image (all pixel values |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2340 // scanned by the kernel lie inside the image) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2341 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2342 for (unsigned int x = 0; x < width - horizontal.size() + 1; x++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2343 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2344 for (unsigned int c = 0; c < ChannelsCount; c++, p++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2345 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2346 *p = 0; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2347 for (unsigned int k = 0; k < horizontal.size(); k++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2348 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2349 *p += static_cast<float>(row[(x + k) * ChannelsCount + c]) * horizontal[k]; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2350 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2351 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2352 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2353 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2354 // Deal with the right border |
|
3585
113a9643e8bb
Suppressed a few warnings when building with emscripten (clang) + numeric truncation warnings
Benjamin Golinvaux <bgo@osimis.io>
parents:
3565
diff
changeset
|
2355 for (unsigned int x = static_cast<unsigned int>( |
|
3682
5f64c866108a
merging implementations of ImageProcessing::ShiftScale() and ApplyWindowing()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
2356 horizontalAnchor + width - horizontal.size() + 1); x < width; x++) |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2357 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2358 for (unsigned int c = 0; c < ChannelsCount; c++, p++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2359 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2360 *p = GetHorizontalConvolutionFloatSecure<RawPixel, ChannelsCount> |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2361 (image, horizontal, horizontalAnchor, x, y, leftBorder[c], rightBorder[c], c); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2362 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2363 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2364 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2365 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2366 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2367 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2368 /** |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2369 * Vertical convolution |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2370 **/ |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2371 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2372 std::vector<const float*> rows(vertical.size()); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2373 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2374 for (unsigned int y = 0; y < height; y++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2375 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2376 for (unsigned int k = 0; k < vertical.size(); k++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2377 { |
|
3504
18566f9e1831
unit testing new functions in ImageProcessing
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3503
diff
changeset
|
2378 if (y + k < verticalAnchor) |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2379 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2380 rows[k] = reinterpret_cast<const float*>(tmp.GetConstRow(0)); // Use top border |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2381 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2382 else if (y + k >= height + verticalAnchor) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2383 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2384 rows[k] = reinterpret_cast<const float*>(tmp.GetConstRow(height - 1)); // Use bottom border |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2385 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2386 else |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2387 { |
|
3585
113a9643e8bb
Suppressed a few warnings when building with emscripten (clang) + numeric truncation warnings
Benjamin Golinvaux <bgo@osimis.io>
parents:
3565
diff
changeset
|
2388 rows[k] = reinterpret_cast<const float*>(tmp.GetConstRow(static_cast<unsigned int>(y + k - verticalAnchor))); |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2389 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2390 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2391 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2392 RawPixel* p = reinterpret_cast<RawPixel*>(image.GetRow(y)); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2393 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2394 for (unsigned int x = 0; x < width; x++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2395 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2396 for (unsigned int c = 0; c < ChannelsCount; c++, p++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2397 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2398 float accumulator = 0; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2399 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2400 for (unsigned int k = 0; k < vertical.size(); k++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2401 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2402 accumulator += rows[k][ChannelsCount * x + c] * vertical[k]; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2403 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2404 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2405 accumulator *= normalization; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2406 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2407 if (accumulator <= static_cast<float>(std::numeric_limits<RawPixel>::min())) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2408 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2409 *p = std::numeric_limits<RawPixel>::min(); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2410 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2411 else if (accumulator >= static_cast<float>(std::numeric_limits<RawPixel>::max())) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2412 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2413 *p = std::numeric_limits<RawPixel>::max(); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2414 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2415 else |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2416 { |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2417 if (UseRound) |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2418 { |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2419 assert(sizeof(RawPixel) < sizeof(int)); |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2420 *p = static_cast<RawPixel>(boost::math::iround(accumulator)); |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2421 } |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2422 else |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2423 { |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2424 *p = static_cast<RawPixel>(accumulator); |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2425 } |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2426 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2427 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2428 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2429 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2430 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2431 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2432 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2433 void ImageProcessing::SeparableConvolution(ImageAccessor& image /* inplace */, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2434 const std::vector<float>& horizontal, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2435 size_t horizontalAnchor, |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2436 const std::vector<float>& vertical, |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2437 size_t verticalAnchor, |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2438 bool useRound) |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2439 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2440 if (horizontal.size() == 0 || |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2441 vertical.size() == 0 || |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2442 horizontalAnchor >= horizontal.size() || |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2443 verticalAnchor >= vertical.size()) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2444 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2445 throw OrthancException(ErrorCode_ParameterOutOfRange); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2446 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2447 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2448 if (image.GetWidth() == 0 || |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2449 image.GetHeight() == 0) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2450 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2451 return; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2452 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2453 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2454 /** |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2455 * Compute normalization |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2456 **/ |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2457 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2458 float sumHorizontal = 0; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2459 for (size_t i = 0; i < horizontal.size(); i++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2460 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2461 sumHorizontal += horizontal[i]; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2462 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2463 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2464 float sumVertical = 0; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2465 for (size_t i = 0; i < vertical.size(); i++) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2466 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2467 sumVertical += vertical[i]; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2468 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2469 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2470 if (fabsf(sumHorizontal) <= std::numeric_limits<float>::epsilon() || |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2471 fabsf(sumVertical) <= std::numeric_limits<float>::epsilon()) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2472 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2473 throw OrthancException(ErrorCode_ParameterOutOfRange, "Singular convolution kernel"); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2474 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2475 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2476 const float normalization = 1.0f / (sumHorizontal * sumVertical); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2477 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2478 switch (image.GetFormat()) |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2479 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2480 case PixelFormat_Grayscale8: |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2481 if (useRound) |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2482 { |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2483 SeparableConvolutionFloat<uint8_t, 1u, true> |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2484 (image, horizontal, horizontalAnchor, vertical, verticalAnchor, normalization); |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2485 } |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2486 else |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2487 { |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2488 SeparableConvolutionFloat<uint8_t, 1u, false> |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2489 (image, horizontal, horizontalAnchor, vertical, verticalAnchor, normalization); |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2490 } |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2491 break; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2492 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2493 case PixelFormat_RGB24: |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2494 if (useRound) |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2495 { |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2496 SeparableConvolutionFloat<uint8_t, 3u, true> |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2497 (image, horizontal, horizontalAnchor, vertical, verticalAnchor, normalization); |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2498 } |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2499 else |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2500 { |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2501 SeparableConvolutionFloat<uint8_t, 3u, false> |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2502 (image, horizontal, horizontalAnchor, vertical, verticalAnchor, normalization); |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2503 } |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2504 break; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2505 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2506 default: |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2507 throw OrthancException(ErrorCode_NotImplemented); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2508 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2509 } |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2510 |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2511 |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2512 void ImageProcessing::SmoothGaussian5x5(ImageAccessor& image, |
|
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2513 bool useRound) |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2514 { |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2515 std::vector<float> kernel(5); |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2516 kernel[0] = 1; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2517 kernel[1] = 4; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2518 kernel[2] = 6; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2519 kernel[3] = 4; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2520 kernel[4] = 1; |
|
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2521 |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2522 SeparableConvolution(image, kernel, 2, kernel, 2, useRound); |
|
3503
46cf170ba121
ImageProcessing::SeparableConvolution()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3502
diff
changeset
|
2523 } |
|
3549
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2524 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2525 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2526 void ImageProcessing::FitSize(ImageAccessor& target, |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2527 const ImageAccessor& source) |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2528 { |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2529 if (target.GetWidth() == 0 || |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2530 target.GetHeight() == 0) |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2531 { |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2532 return; |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2533 } |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2534 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2535 if (source.GetWidth() == target.GetWidth() && |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2536 source.GetHeight() == target.GetHeight()) |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2537 { |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2538 Copy(target, source); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2539 return; |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2540 } |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2541 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2542 Set(target, 0); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2543 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2544 // Preserve the aspect ratio |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2545 float cw = static_cast<float>(source.GetWidth()); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2546 float ch = static_cast<float>(source.GetHeight()); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2547 float r = std::min( |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2548 static_cast<float>(target.GetWidth()) / cw, |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2549 static_cast<float>(target.GetHeight()) / ch); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2550 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2551 unsigned int sw = std::min(static_cast<unsigned int>(boost::math::iround(cw * r)), target.GetWidth()); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2552 unsigned int sh = std::min(static_cast<unsigned int>(boost::math::iround(ch * r)), target.GetHeight()); |
|
4065
d6362b2c4b61
export dcmdata in shared library, rounding in convolution tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4056
diff
changeset
|
2553 |
|
3549
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2554 Image resized(target.GetFormat(), sw, sh, false); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2555 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2556 //ImageProcessing::SmoothGaussian5x5(source); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2557 ImageProcessing::Resize(resized, source); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2558 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2559 assert(target.GetWidth() >= resized.GetWidth() && |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2560 target.GetHeight() >= resized.GetHeight()); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2561 unsigned int offsetX = (target.GetWidth() - resized.GetWidth()) / 2; |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2562 unsigned int offsetY = (target.GetHeight() - resized.GetHeight()) / 2; |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2563 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2564 ImageAccessor region; |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2565 target.GetRegion(region, offsetX, offsetY, resized.GetWidth(), resized.GetHeight()); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2566 ImageProcessing::Copy(region, resized); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2567 } |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2568 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2569 |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2570 ImageAccessor* ImageProcessing::FitSize(const ImageAccessor& source, |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2571 unsigned int width, |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2572 unsigned int height) |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2573 { |
|
3712
2a170a8f1faf
replacing std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3690
diff
changeset
|
2574 std::unique_ptr<ImageAccessor> target(new Image(source.GetFormat(), width, height, false)); |
|
3549
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2575 FitSize(*target, source); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2576 return target.release(); |
|
fab5777f4dd4
ImageProcessing::FitSize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3547
diff
changeset
|
2577 } |
|
4082
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2578 |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2579 |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2580 ImageAccessor* ImageProcessing::FitSizeKeepAspectRatio(const ImageAccessor& source, |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2581 unsigned int width, |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2582 unsigned int height) |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2583 { |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2584 std::unique_ptr<ImageAccessor> target(new Image(source.GetFormat(), width, height, false)); |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2585 Set(*target, 0); |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2586 |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2587 if (width != 0 && |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2588 height != 0 && |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2589 source.GetWidth() != 0 && |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2590 source.GetHeight() != 0) |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2591 { |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2592 float ratio = std::min(static_cast<float>(width) / static_cast<float>(source.GetWidth()), |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2593 static_cast<float>(height) / static_cast<float>(source.GetHeight())); |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2594 |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2595 unsigned int resizedWidth = static_cast<unsigned int>( |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2596 boost::math::iround(ratio * static_cast<float>(source.GetWidth()))); |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2597 |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2598 unsigned int resizedHeight = static_cast<unsigned int>( |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2599 boost::math::iround(ratio * static_cast<float>(source.GetHeight()))); |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2600 |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2601 std::unique_ptr<ImageAccessor> resized(FitSize(source, resizedWidth, resizedHeight)); |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2602 |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2603 ImageAccessor region; |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2604 target->GetRegion(region, (width - resizedWidth) / 2, |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2605 (height - resizedHeight) / 2, resizedWidth, resizedHeight); |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2606 Copy(region, *resized); |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2607 } |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2608 |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2609 return target.release(); |
|
2e1564f57542
ImageProcessing::FitSizeKeepAspectRatio()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4080
diff
changeset
|
2610 } |
|
4443
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2611 |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2612 |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2613 void ImageProcessing::ConvertJpegYCbCrToRgb(ImageAccessor& image) |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2614 { |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2615 // http://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.7.6.3.html#sect_C.7.6.3.1.2 |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2616 // https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2617 |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2618 // TODO - Check out the outcome of Mathieu's discussion about |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2619 // truncation of YCbCr-to-RGB conversion: |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2620 // https://groups.google.com/forum/#!msg/comp.protocols.dicom/JHuGeyWbTz8/ARoTWrJzAQAJ |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2621 |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2622 const unsigned int width = image.GetWidth(); |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2623 const unsigned int height = image.GetHeight(); |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2624 const unsigned int pitch = image.GetPitch(); |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2625 uint8_t* buffer = reinterpret_cast<uint8_t*>(image.GetBuffer()); |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2626 |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2627 if (image.GetFormat() != PixelFormat_RGB24 || |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2628 pitch < 3 * width) |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2629 { |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2630 throw OrthancException(ErrorCode_IncompatibleImageFormat); |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2631 } |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2632 |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2633 for (unsigned int y = 0; y < height; y++) |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2634 { |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2635 uint8_t* p = buffer + y * pitch; |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2636 |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2637 for (unsigned int x = 0; x < width; x++, p += 3) |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2638 { |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2639 const float Y = p[0]; |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2640 const float Cb = p[1]; |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2641 const float Cr = p[2]; |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2642 |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2643 const float result[3] = { |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2644 Y + 1.402f * (Cr - 128.0f), |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2645 Y - 0.344136f * (Cb - 128.0f) - 0.714136f * (Cr - 128.0f), |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2646 Y + 1.772f * (Cb - 128.0f) |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2647 }; |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2648 |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2649 for (uint8_t i = 0; i < 3 ; i++) |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2650 { |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2651 if (result[i] < 0) |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2652 { |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2653 p[i] = 0; |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2654 } |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2655 else if (result[i] > 255) |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2656 { |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2657 p[i] = 255; |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2658 } |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2659 else |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2660 { |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2661 p[i] = static_cast<uint8_t>(result[i]); |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2662 } |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2663 } |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2664 } |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2665 } |
|
fd958175c5b9
ImageProcessing::ConvertJpegYCbCrToRgb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4437
diff
changeset
|
2666 } |
|
4529
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2667 |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2668 |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2669 void ImageProcessing::SwapEndianness(ImageAccessor& image /* inplace */) |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2670 { |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2671 const unsigned int width = image.GetWidth(); |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2672 const unsigned int height = image.GetHeight(); |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2673 |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2674 switch (image.GetFormat()) |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2675 { |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2676 case PixelFormat_Grayscale8: |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2677 case PixelFormat_RGB24: |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2678 case PixelFormat_RGBA32: |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2679 case PixelFormat_BGRA32: |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2680 // No swapping required |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2681 break; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2682 |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2683 case PixelFormat_Grayscale16: |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2684 case PixelFormat_SignedGrayscale16: |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2685 for (unsigned int y = 0; y < height; y++) |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2686 { |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2687 uint8_t* t = reinterpret_cast<uint8_t*>(image.GetRow(y)); |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2688 for (unsigned int x = 0; x < width; x++) |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2689 { |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2690 uint8_t a = t[0]; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2691 t[0] = t[1]; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2692 t[1] = a; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2693 t += 2; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2694 } |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2695 } |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2696 break; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2697 |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2698 case PixelFormat_Grayscale32: |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2699 case PixelFormat_Float32: |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2700 for (unsigned int y = 0; y < height; y++) |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2701 { |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2702 uint8_t* t = reinterpret_cast<uint8_t*>(image.GetRow(y)); |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2703 for (unsigned int x = 0; x < width; x++) |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2704 { |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2705 uint8_t a = t[0]; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2706 uint8_t b = t[1]; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2707 t[0] = t[3]; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2708 t[1] = t[2]; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2709 t[2] = b; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2710 t[3] = a; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2711 t += 4; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2712 } |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2713 } |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2714 break; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2715 |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2716 case PixelFormat_RGB48: // uint16_t per channel |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2717 for (unsigned int y = 0; y < height; y++) |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2718 { |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2719 uint8_t* t = reinterpret_cast<uint8_t*>(image.GetRow(y)); |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2720 for (unsigned int x = 0; x < 3 * width; x++) |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2721 { |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2722 uint8_t a = t[0]; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2723 t[0] = t[1]; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2724 t[1] = a; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2725 t += 2; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2726 } |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2727 } |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2728 break; |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2729 |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2730 default: |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2731 throw OrthancException(ErrorCode_NotImplemented); |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2732 } |
|
5774fe497ff2
fix decoding of images on big-endian architectures
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4447
diff
changeset
|
2733 } |
| 853 | 2734 } |