Mercurial > hg > orthanc-wsi
annotate Framework/Jpeg2000Reader.cpp @ 280:34b507959e32 iiif
integration mainline->iiif
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Wed, 12 Jul 2023 18:08:27 +0200 |
| parents | 20a730889ae2 |
| children | 7020852a8fa9 |
| rev | line source |
|---|---|
| 0 | 1 /** |
| 2 * Orthanc - A Lightweight, RESTful DICOM Store | |
| 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
| 4 * Department, University Hospital of Liege, Belgium | |
| 254 | 5 * Copyright (C) 2017-2023 Osimis S.A., Belgium |
| 6 * Copyright (C) 2021-2023 Sebastien Jodogne, ICTEAM UCLouvain, Belgium | |
| 0 | 7 * |
| 8 * This program is free software: you can redistribute it and/or | |
| 9 * modify it under the terms of the GNU Affero General Public License | |
| 10 * as published by the Free Software Foundation, either version 3 of | |
| 11 * the License, or (at your option) any later version. | |
| 12 * | |
| 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 | |
| 16 * Affero General Public License for more details. | |
| 17 * | |
| 18 * You should have received a copy of the GNU Affero General Public License | |
| 19 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 20 **/ | |
| 21 | |
| 22 | |
|
16
7a88c614be04
preparing for precompiled headers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
23 #include "PrecompiledHeadersWSI.h" |
| 0 | 24 #include "Jpeg2000Reader.h" |
| 25 | |
|
199
a1c265cb2174
replacing deprecated std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
192
diff
changeset
|
26 #include "ImageToolbox.h" |
|
a1c265cb2174
replacing deprecated std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
192
diff
changeset
|
27 |
|
a1c265cb2174
replacing deprecated std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
192
diff
changeset
|
28 #include <Compatibility.h> // For std::unique_ptr |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
29 #include <Images/ImageProcessing.h> |
| 192 | 30 #include <OrthancException.h> |
| 31 #include <SystemToolbox.h> | |
| 0 | 32 |
| 33 #include <cassert> | |
| 34 #include <string.h> | |
| 35 #include <openjpeg.h> | |
| 36 | |
| 37 #if ORTHANC_OPENJPEG_MAJOR_VERSION == 1 | |
| 38 # define OPJ_CLRSPC_GRAY CLRSPC_GRAY | |
| 39 # define OPJ_CLRSPC_SRGB CLRSPC_SRGB | |
| 40 # define OPJ_CODEC_J2K CODEC_J2K | |
| 41 # define OPJ_CODEC_JP2 CODEC_JP2 | |
| 42 typedef opj_dinfo_t opj_codec_t; | |
| 43 typedef opj_cio_t opj_stream_t; | |
| 44 #elif ORTHANC_OPENJPEG_MAJOR_VERSION == 2 | |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
45 // OK, no need for compatibility macros |
| 0 | 46 #else |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
47 # error Unsupported version of OpenJpeg |
| 0 | 48 #endif |
| 49 | |
| 50 | |
| 51 namespace OrthancWSI | |
| 52 { | |
| 53 namespace | |
| 54 { | |
| 55 // Check out opj_dparameters_t::decod_format | |
| 56 enum InputFormat | |
| 57 { | |
| 58 InputFormat_J2K = 0, | |
| 59 InputFormat_JP2 = 1, | |
| 60 InputFormat_JPT = 2 | |
| 61 }; | |
| 62 | |
| 63 enum OutputFormat | |
| 64 { | |
| 65 #if ORTHANC_OPENJPEG_MAJOR_VERSION == 1 | |
| 66 OutputFormat_PGX = 1 | |
| 67 #else | |
| 68 OutputFormat_PGX = 11 | |
| 69 #endif | |
| 70 }; | |
| 71 | |
| 72 class OpenJpegDecoder : public boost::noncopyable | |
| 73 { | |
| 74 private: | |
| 75 opj_dparameters_t parameters_; | |
| 76 opj_codec_t* dinfo_; | |
| 77 | |
| 78 void SetupParameters(InputFormat format) | |
| 79 { | |
| 80 opj_set_default_decoder_parameters(¶meters_); | |
| 81 | |
| 82 parameters_.decod_format = format; | |
| 83 parameters_.cod_format = OutputFormat_PGX; | |
| 84 | |
| 85 #if OPENJPEG_MAJOR_VERSION == 1 | |
| 86 parameters_.cp_layer = 0; | |
| 87 parameters_.cp_reduce = 0; | |
| 88 #endif | |
| 89 } | |
| 90 | |
| 91 void Finalize() | |
| 92 { | |
| 93 if (dinfo_ != NULL) | |
| 94 { | |
| 95 #if ORTHANC_OPENJPEG_MAJOR_VERSION == 1 | |
| 96 opj_destroy_decompress(dinfo_); | |
| 97 #else | |
| 98 opj_destroy_codec(dinfo_); | |
| 99 #endif | |
| 100 dinfo_ = NULL; | |
| 101 } | |
| 102 } | |
| 103 | |
| 104 public: | |
| 145 | 105 explicit OpenJpegDecoder(Jpeg2000Format format) : |
| 106 dinfo_(NULL) | |
| 0 | 107 { |
| 108 switch (format) | |
| 109 { | |
| 110 case Jpeg2000Format_J2K: | |
| 111 SetupParameters(InputFormat_J2K); | |
| 112 dinfo_ = opj_create_decompress(OPJ_CODEC_J2K); | |
| 113 break; | |
| 114 | |
| 115 case Jpeg2000Format_JP2: | |
| 116 SetupParameters(InputFormat_JP2); | |
| 117 dinfo_ = opj_create_decompress(OPJ_CODEC_JP2); | |
| 118 break; | |
| 119 | |
| 120 default: | |
| 121 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
| 122 } | |
| 123 | |
| 124 if (!dinfo_) | |
| 125 { | |
| 126 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
| 127 } | |
| 128 | |
| 129 #if ORTHANC_OPENJPEG_MAJOR_VERSION == 1 | |
| 130 opj_setup_decoder(dinfo_, ¶meters_); | |
| 131 #else | |
| 132 if (!opj_setup_decoder(dinfo_, ¶meters_)) | |
| 133 { | |
| 134 Finalize(); | |
| 135 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
| 136 } | |
| 137 #endif | |
| 138 } | |
| 139 | |
| 140 ~OpenJpegDecoder() | |
| 141 { | |
| 142 Finalize(); | |
| 143 } | |
| 144 | |
| 145 opj_codec_t* GetObject() | |
| 146 { | |
| 147 return dinfo_; | |
| 148 } | |
| 149 | |
| 150 const opj_dparameters_t& GetParameters() const | |
| 151 { | |
| 152 return parameters_; | |
| 153 } | |
| 154 }; | |
| 155 | |
| 156 | |
| 157 class OpenJpegInput : public boost::noncopyable | |
| 158 { | |
| 159 private: | |
| 160 opj_stream_t* cio_; | |
| 161 | |
| 162 const uint8_t* buffer_; | |
| 163 size_t size_; | |
| 164 size_t position_; | |
| 165 | |
| 166 #if ORTHANC_OPENJPEG_MAJOR_VERSION == 2 | |
| 167 static void Free(void *userData) | |
| 168 { | |
| 169 } | |
| 170 | |
| 171 static OPJ_SIZE_T Read(void *target, | |
| 172 OPJ_SIZE_T size, | |
| 173 void *userData) | |
| 174 { | |
| 175 OpenJpegInput& that = *reinterpret_cast<OpenJpegInput*>(userData); | |
|
179
f80631f632ad
cppcheck, upgrade to Orthanc framework 1.7.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
175
diff
changeset
|
176 assert(that.position_ <= that.size_); |
| 0 | 177 assert(size >= 0); |
| 178 | |
| 179 if (that.position_ == that.size_) | |
| 180 { | |
| 181 // End of file | |
| 182 return -1; | |
| 183 } | |
| 184 else | |
| 185 { | |
| 186 if (that.position_ + size > that.size_) | |
| 187 { | |
| 188 size = that.size_ - that.position_; | |
| 189 } | |
| 190 | |
| 191 if (size > 0) | |
| 192 { | |
| 193 memcpy(target, that.buffer_ + that.position_, size); | |
| 194 } | |
| 195 | |
| 196 that.position_ += size; | |
| 197 return size; | |
| 198 } | |
| 199 } | |
| 200 | |
| 201 static OPJ_OFF_T Skip(OPJ_OFF_T skip, | |
| 202 void *userData) | |
| 203 { | |
| 204 assert(skip >= 0); | |
| 205 OpenJpegInput& that = *reinterpret_cast<OpenJpegInput*>(userData); | |
| 206 | |
| 207 if (that.position_ == that.size_) | |
| 208 { | |
| 209 // End of file | |
| 210 return -1; | |
| 211 } | |
| 212 else if (that.position_ + skip > that.size_) | |
| 213 { | |
| 214 size_t offset = that.size_ - that.position_; | |
| 215 that.position_ = that.size_; | |
| 216 return offset; | |
| 217 } | |
| 218 else | |
| 219 { | |
| 220 that.position_ += skip; | |
| 221 return skip; | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 static OPJ_BOOL Seek(OPJ_OFF_T position, | |
| 226 void *userData) | |
| 227 { | |
| 228 assert(position >= 0); | |
| 229 OpenJpegInput& that = *reinterpret_cast<OpenJpegInput*>(userData); | |
| 230 | |
| 231 if (static_cast<size_t>(position) > that.size_) | |
| 232 { | |
| 233 that.position_ = that.size_; | |
| 234 return false; | |
| 235 } | |
| 236 else | |
| 237 { | |
| 238 that.position_ = position; | |
| 239 return true; | |
| 240 } | |
| 241 } | |
| 242 #endif | |
| 243 | |
| 244 public: | |
| 245 OpenJpegInput(OpenJpegDecoder& decoder, | |
| 246 const void* buffer, | |
| 247 size_t size) : | |
| 248 buffer_(reinterpret_cast<const uint8_t*>(buffer)), | |
| 249 size_(size), | |
| 250 position_(0) | |
| 251 { | |
| 252 #if ORTHANC_OPENJPEG_MAJOR_VERSION == 1 | |
| 253 cio_ = opj_cio_open(reinterpret_cast<opj_common_ptr>(decoder.GetObject()), | |
| 254 reinterpret_cast<unsigned char*>(const_cast<void*>(buffer)), | |
| 255 size); | |
| 256 #else | |
| 257 cio_ = opj_stream_create(size_, 1 /* input stream */); | |
| 258 if (!cio_) | |
| 259 { | |
| 260 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
| 261 } | |
| 262 | |
| 263 // http://openjpeg.narkive.com/zHqG2fMe/opj-stream-set-user-data-length | |
| 264 // "I'd suggest to precise in the documentation that the skip | |
| 265 // and read callback functions should return -1 on end of | |
| 266 // stream, and the seek callback function should return false | |
| 267 // on end of stream." | |
| 268 | |
| 269 opj_stream_set_user_data(cio_, this, Free); | |
| 270 opj_stream_set_user_data_length(cio_, size); | |
| 271 opj_stream_set_read_function(cio_, Read); | |
| 272 opj_stream_set_skip_function(cio_, Skip); | |
| 273 opj_stream_set_seek_function(cio_, Seek); | |
| 274 #endif | |
| 275 } | |
| 276 | |
| 277 ~OpenJpegInput() | |
| 278 { | |
| 279 if (cio_) | |
| 280 { | |
| 281 #if ORTHANC_OPENJPEG_MAJOR_VERSION == 1 | |
| 282 opj_cio_close(cio_); | |
| 283 #else | |
| 284 opj_stream_destroy(cio_); | |
| 285 #endif | |
| 286 cio_ = NULL; | |
| 287 } | |
| 288 } | |
| 289 | |
| 290 opj_stream_t* GetObject() | |
| 291 { | |
| 292 return cio_; | |
| 293 } | |
| 294 }; | |
| 295 | |
| 296 | |
| 297 class OpenJpegImage | |
| 298 { | |
| 299 private: | |
| 300 opj_image_t* image_; | |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
301 |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
302 Orthanc::ImageAccessor* ExtractChannel(unsigned int channel) |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
303 { |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
304 const unsigned int width = image_->comps[channel].w; |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
305 const unsigned int height = image_->comps[channel].h; |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
306 |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
307 std::unique_ptr<Orthanc::ImageAccessor> target( |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
308 new Orthanc::Image(Orthanc::PixelFormat_Grayscale8, width, height, false)); |
| 0 | 309 |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
310 const int32_t* q = image_->comps[channel].data; |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
311 assert(q != NULL); |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
312 |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
313 for (unsigned int y = 0; y < height; y++) |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
314 { |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
315 uint8_t *p = reinterpret_cast<uint8_t*>(target->GetRow(y)); |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
316 |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
317 for (unsigned int x = 0; x < width; x++, p++, q++) |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
318 { |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
319 *p = *q; |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
320 } |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
321 } |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
322 |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
323 return target.release(); |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
324 } |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
325 |
| 0 | 326 void CopyChannel(Orthanc::ImageAccessor& target, |
| 327 unsigned int channel, | |
| 328 unsigned int targetIncrement) | |
| 329 { | |
| 209 | 330 const unsigned int width = target.GetWidth(); |
| 331 const unsigned int height = target.GetHeight(); | |
| 332 | |
| 227 | 333 if (width == static_cast<unsigned int>(image_->comps[channel].w) && |
| 334 height == static_cast<unsigned int>(image_->comps[channel].h)) | |
| 0 | 335 { |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
336 const int32_t* q = image_->comps[channel].data; |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
337 assert(q != NULL); |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
338 |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
339 for (unsigned int y = 0; y < height; y++) |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
340 { |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
341 uint8_t *p = reinterpret_cast<uint8_t*>(target.GetRow(y)) + channel; |
| 0 | 342 |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
343 for (unsigned int x = 0; x < width; x++, p += targetIncrement) |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
344 { |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
345 *p = *q; |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
346 q++; |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
347 } |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
348 } |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
349 } |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
350 else |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
351 { |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
352 // This component is subsampled |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
353 std::unique_ptr<Orthanc::ImageAccessor> source(ExtractChannel(channel)); |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
354 Orthanc::Image resized(Orthanc::PixelFormat_Grayscale8, width, height, false); |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
355 Orthanc::ImageProcessing::Resize(resized, *source); |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
356 |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
357 assert(resized.GetWidth() == target.GetWidth() && |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
358 resized.GetHeight() == target.GetHeight() && |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
359 resized.GetFormat() == Orthanc::PixelFormat_Grayscale8 && |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
360 source->GetFormat() == Orthanc::PixelFormat_Grayscale8); |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
361 |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
362 for (unsigned int y = 0; y < height; y++) |
| 0 | 363 { |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
364 const uint8_t *q = reinterpret_cast<const uint8_t*>(resized.GetConstRow(y)); |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
365 uint8_t *p = reinterpret_cast<uint8_t*>(target.GetRow(y)) + channel; |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
366 |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
367 for (unsigned int x = 0; x < width; x++, p += targetIncrement) |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
368 { |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
369 *p = *q; |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
370 q++; |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
371 } |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
372 } |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
373 } |
| 0 | 374 } |
| 375 | |
| 376 public: | |
| 377 OpenJpegImage(OpenJpegDecoder& decoder, | |
| 378 OpenJpegInput& input) : | |
| 379 image_(NULL) | |
| 380 { | |
| 381 #if ORTHANC_OPENJPEG_MAJOR_VERSION == 1 | |
| 382 image_ = opj_decode(decoder.GetObject(), input.GetObject()); | |
| 383 if (image_ == NULL) | |
| 384 { | |
| 385 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
| 386 } | |
| 387 #else | |
| 388 if (!opj_read_header(input.GetObject(), decoder.GetObject(), &image_) || | |
| 389 image_ == NULL) | |
| 390 { | |
| 391 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
| 392 } | |
| 393 | |
| 394 if (!opj_set_decode_area(decoder.GetObject(), image_, | |
| 395 static_cast<int32_t>(decoder.GetParameters().DA_x0), | |
| 396 static_cast<int32_t>(decoder.GetParameters().DA_y0), | |
| 397 static_cast<int32_t>(decoder.GetParameters().DA_x1), | |
| 398 static_cast<int32_t>(decoder.GetParameters().DA_y1)) || // Decode the whole image | |
| 399 !opj_decode(decoder.GetObject(), input.GetObject(), image_) || | |
| 400 !opj_end_decompress(decoder.GetObject(), input.GetObject())) | |
| 401 { | |
| 402 opj_image_destroy(image_); | |
| 403 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
| 404 } | |
| 405 #endif | |
| 406 } | |
| 407 | |
| 408 ~OpenJpegImage() | |
| 409 { | |
| 410 if (image_ != NULL) | |
| 411 { | |
| 412 opj_image_destroy(image_); | |
| 413 image_ = NULL; | |
| 414 } | |
| 415 } | |
| 416 | |
| 417 Orthanc::ImageAccessor* ProvideImage() | |
| 418 { | |
| 419 if (image_->x1 < 0 || | |
| 420 image_->y1 < 0) | |
| 421 { | |
| 422 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
| 423 } | |
| 424 | |
| 425 if (image_->x0 != 0 || | |
| 426 image_->y0 != 0) | |
| 427 { | |
| 428 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
| 429 } | |
| 430 | |
| 431 for (unsigned int c = 0; c < static_cast<unsigned int>(image_->numcomps); c++) | |
| 432 { | |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
433 if (image_->comps[c].x0 != 0 || |
| 0 | 434 image_->comps[c].y0 != 0 || |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
435 image_->comps[c].dx * image_->comps[c].w != image_->x1 || |
|
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
436 image_->comps[c].dy * image_->comps[c].h != image_->y1 || |
| 0 | 437 image_->comps[c].prec != 8 || |
| 438 image_->comps[c].sgnd != 0) | |
| 439 { | |
| 440 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
| 441 } | |
| 442 } | |
| 443 | |
| 444 unsigned int width = static_cast<unsigned int>(image_->x1); | |
| 445 unsigned int height = static_cast<unsigned int>(image_->y1); | |
| 446 | |
| 447 Orthanc::PixelFormat format; | |
|
124
24bd36849c56
Support more colorspaces with JPEG2k
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
115
diff
changeset
|
448 if (image_->numcomps == 1 /*&& image_->color_space != OPJ_CLRSPC_GRAY*/) |
| 0 | 449 { |
| 450 format = Orthanc::PixelFormat_Grayscale8; | |
| 451 } | |
|
124
24bd36849c56
Support more colorspaces with JPEG2k
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
115
diff
changeset
|
452 else if (image_->numcomps == 3 /*&& image_->color_space == OPJ_CLRSPC_SRGB*/) |
| 0 | 453 { |
| 454 format = Orthanc::PixelFormat_RGB24; | |
| 455 } | |
| 456 else | |
| 457 { | |
| 458 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
| 459 } | |
| 460 | |
|
199
a1c265cb2174
replacing deprecated std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
192
diff
changeset
|
461 std::unique_ptr<Orthanc::ImageAccessor> image(ImageToolbox::Allocate(format, width, height)); |
| 0 | 462 |
| 463 switch (format) | |
| 464 { | |
| 465 case Orthanc::PixelFormat_Grayscale8: | |
| 466 { | |
| 467 CopyChannel(*image, 0, 1); | |
| 468 break; | |
| 469 } | |
| 470 | |
| 471 case Orthanc::PixelFormat_RGB24: | |
| 472 { | |
| 473 CopyChannel(*image, 0, 3); | |
| 474 CopyChannel(*image, 1, 3); | |
| 475 CopyChannel(*image, 2, 3); | |
| 476 break; | |
| 477 } | |
| 478 | |
| 479 default: | |
| 480 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
| 481 } | |
| 482 | |
| 483 return image.release(); | |
| 484 } | |
| 485 }; | |
| 486 } | |
| 487 | |
| 488 | |
| 489 void Jpeg2000Reader::ReadFromMemory(const void* buffer, | |
| 490 size_t size) | |
| 491 { | |
| 492 OpenJpegDecoder decoder(DetectFormatFromMemory(buffer, size)); | |
| 493 OpenJpegInput input(decoder, buffer, size); | |
| 494 OpenJpegImage image(decoder, input); | |
| 495 | |
| 496 image_.reset(image.ProvideImage()); | |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
497 AssignWritable(image_->GetFormat(), |
| 0 | 498 image_->GetWidth(), |
| 499 image_->GetHeight(), | |
| 500 image_->GetPitch(), | |
|
217
20bc074ec19a
Viewer can display DICOM pyramids whose tile sizes vary across levels
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
214
diff
changeset
|
501 image_->GetBuffer()); |
| 0 | 502 } |
| 503 | |
| 504 | |
| 505 void Jpeg2000Reader::ReadFromMemory(const std::string& buffer) | |
| 506 { | |
| 507 if (buffer.empty()) | |
| 508 { | |
| 509 ReadFromMemory(NULL, 0); | |
| 510 } | |
| 511 else | |
| 512 { | |
| 513 ReadFromMemory(buffer.c_str(), buffer.size()); | |
| 514 } | |
| 515 } | |
| 516 | |
| 517 void Jpeg2000Reader::ReadFromFile(const std::string& filename) | |
| 518 { | |
| 519 // TODO Use opj_stream_create_file_stream() ? | |
| 520 | |
| 521 std::string content; | |
| 43 | 522 Orthanc::SystemToolbox::ReadFile(content, filename); |
| 0 | 523 } |
| 524 | |
| 525 | |
| 526 Jpeg2000Format Jpeg2000Reader::DetectFormatFromMemory(const void* buffer, | |
| 527 size_t size) | |
| 528 { | |
| 529 static const char JP2_RFC3745_HEADER[] = "\x00\x00\x00\x0c\x6a\x50\x20\x20\x0d\x0a\x87\x0a"; | |
| 530 static const char JP2_HEADER[] = "\x0d\x0a\x87\x0a"; | |
| 531 static const char J2K_HEADER[] = "\xff\x4f\xff\x51"; | |
| 532 | |
| 533 if (size < sizeof(JP2_RFC3745_HEADER) - 1) | |
| 534 { | |
| 535 return Jpeg2000Format_Unknown; | |
| 536 } | |
| 537 | |
| 538 if (memcmp(buffer, JP2_RFC3745_HEADER, sizeof(JP2_RFC3745_HEADER) - 1) == 0 || | |
| 539 memcmp(buffer, JP2_HEADER, sizeof(JP2_HEADER) - 1) == 0) | |
| 540 { | |
| 541 return Jpeg2000Format_JP2; | |
| 542 } | |
| 543 else if (memcmp(buffer, J2K_HEADER, sizeof(J2K_HEADER) - 1) == 0) | |
| 544 { | |
| 545 return Jpeg2000Format_J2K; | |
| 546 } | |
| 547 | |
| 548 return Jpeg2000Format_Unknown; | |
| 549 } | |
| 550 } |