Mercurial > hg > orthanc
annotate Core/DicomParsing/DcmtkTranscoder.cpp @ 3901:603a7b86fa5f transcoding
route "/instances/.../modify": New option "Transcode"
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 07 May 2020 14:52:53 +0200 |
parents | 8f7ad4989fec |
children | 7459fcb1bdf7 |
rev | line source |
---|---|
3893 | 1 /** |
2 * Orthanc - A Lightweight, RESTful DICOM Store | |
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
4 * Department, University Hospital of Liege, Belgium | |
5 * Copyright (C) 2017-2020 Osimis S.A., Belgium | |
6 * | |
7 * This program is free software: you can redistribute it and/or | |
8 * modify it under the terms of the GNU General Public License as | |
9 * published by the Free Software Foundation, either version 3 of the | |
10 * License, or (at your option) any later version. | |
11 * | |
12 * In addition, as a special exception, the copyright holders of this | |
13 * program give permission to link the code of its release with the | |
14 * OpenSSL project's "OpenSSL" library (or with modified versions of it | |
15 * that use the same license as the "OpenSSL" library), and distribute | |
16 * the linked executables. You must obey the GNU General Public License | |
17 * in all respects for all of the code used other than "OpenSSL". If you | |
18 * modify file(s) with this exception, you may extend this exception to | |
19 * your version of the file(s), but you are not obligated to do so. If | |
20 * you do not wish to do so, delete this exception statement from your | |
21 * version. If you delete this exception statement from all source files | |
22 * in the program, then also delete it here. | |
23 * | |
24 * This program is distributed in the hope that it will be useful, but | |
25 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
27 * General Public License for more details. | |
28 * | |
29 * You should have received a copy of the GNU General Public License | |
30 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
31 **/ | |
32 | |
33 | |
34 #include "../PrecompiledHeaders.h" | |
35 #include "DcmtkTranscoder.h" | |
36 | |
37 | |
38 #if !defined(ORTHANC_ENABLE_DCMTK_JPEG) | |
39 # error Macro ORTHANC_ENABLE_DCMTK_JPEG must be defined | |
40 #endif | |
41 | |
42 #if !defined(ORTHANC_ENABLE_DCMTK_JPEG_LOSSLESS) | |
43 # error Macro ORTHANC_ENABLE_DCMTK_JPEG_LOSSLESS must be defined | |
44 #endif | |
45 | |
46 | |
47 #include "FromDcmtkBridge.h" | |
48 #include "../OrthancException.h" | |
49 | |
50 #include <dcmtk/dcmdata/dcdeftag.h> | |
51 #include <dcmtk/dcmjpeg/djrploss.h> // for DJ_RPLossy | |
52 #include <dcmtk/dcmjpeg/djrplol.h> // for DJ_RPLossless | |
53 #include <dcmtk/dcmjpls/djrparam.h> // for DJLSRepresentationParameter | |
54 | |
55 | |
56 namespace Orthanc | |
57 { | |
58 static uint16_t GetBitsStored(DcmDataset& dataset) | |
59 { | |
60 uint16_t bitsStored; | |
61 if (dataset.findAndGetUint16(DCM_BitsStored, bitsStored).good()) | |
62 { | |
63 return bitsStored; | |
64 } | |
65 else | |
66 { | |
67 throw OrthancException(ErrorCode_BadFileFormat, | |
68 "Missing \"Bits Stored\" tag in DICOM instance"); | |
69 } | |
70 } | |
71 | |
72 | |
73 static std::string GetSopInstanceUid(DcmDataset& dataset) | |
74 { | |
75 const char* v = NULL; | |
76 | |
77 if (dataset.findAndGetString(DCM_SOPInstanceUID, v).good() && | |
78 v != NULL) | |
79 { | |
80 return std::string(v); | |
81 } | |
82 else | |
83 { | |
84 throw OrthancException(ErrorCode_BadFileFormat, "File without SOP instance UID"); | |
85 } | |
86 } | |
87 | |
88 | |
89 static void CheckSopInstanceUid(DcmFileFormat& dicom, | |
90 const std::string& sopInstanceUid, | |
91 bool mustEqual) | |
92 { | |
93 if (dicom.getDataset() == NULL) | |
94 { | |
95 throw OrthancException(ErrorCode_InternalError); | |
96 } | |
97 | |
98 bool ok; | |
99 | |
100 if (mustEqual) | |
101 { | |
102 ok = (GetSopInstanceUid(*dicom.getDataset()) == sopInstanceUid); | |
103 } | |
104 else | |
105 { | |
106 ok = (GetSopInstanceUid(*dicom.getDataset()) != sopInstanceUid); | |
107 } | |
108 | |
109 if (!ok) | |
110 { | |
111 throw OrthancException(ErrorCode_InternalError, | |
112 mustEqual ? "The SOP instance UID has changed unexpectedly during transcoding" : | |
113 "The SOP instance UID has not changed as expected during transcoding"); | |
114 } | |
115 } | |
116 | |
117 | |
118 void DcmtkTranscoder::SetLossyQuality(unsigned int quality) | |
119 { | |
120 if (quality <= 0 || | |
121 quality > 100) | |
122 { | |
123 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
124 } | |
125 else | |
126 { | |
127 lossyQuality_ = quality; | |
128 } | |
129 } | |
130 | |
131 | |
3894
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
132 DcmFileFormat* DcmtkTranscoder::TranscodeToParsed(bool& hasSopInstanceUidChanged /* out */, |
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
133 const void* buffer, |
3893 | 134 size_t size, |
135 const std::set<DicomTransferSyntax>& allowedSyntaxes, | |
136 bool allowNewSopInstanceUid) | |
137 { | |
138 std::unique_ptr<DcmFileFormat> dicom(FromDcmtkBridge::LoadFromMemoryBuffer(buffer, size)); | |
139 | |
140 if (dicom.get() == NULL) | |
141 { | |
142 throw OrthancException(ErrorCode_InternalError); | |
143 } | |
144 | |
3894
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
145 if (InplaceTranscode(hasSopInstanceUidChanged, *dicom, allowedSyntaxes, allowNewSopInstanceUid)) |
3893 | 146 { |
147 return dicom.release(); | |
148 } | |
149 else | |
150 { | |
151 return NULL; | |
152 } | |
153 } | |
154 | |
155 | |
3894
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
156 bool DcmtkTranscoder::InplaceTranscode(bool& hasSopInstanceUidChanged /* out */, |
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
157 DcmFileFormat& dicom, |
3893 | 158 const std::set<DicomTransferSyntax>& allowedSyntaxes, |
159 bool allowNewSopInstanceUid) | |
160 { | |
161 if (dicom.getDataset() == NULL) | |
162 { | |
163 throw OrthancException(ErrorCode_InternalError); | |
164 } | |
165 | |
3894
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
166 hasSopInstanceUidChanged = false; |
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
167 |
3893 | 168 DicomTransferSyntax syntax; |
169 if (!FromDcmtkBridge::LookupOrthancTransferSyntax(syntax, dicom)) | |
170 { | |
171 throw OrthancException(ErrorCode_BadFileFormat, | |
172 "Cannot determine the transfer syntax"); | |
173 } | |
174 | |
175 const uint16_t bitsStored = GetBitsStored(*dicom.getDataset()); | |
176 std::string sourceSopInstanceUid = GetSopInstanceUid(*dicom.getDataset()); | |
3894
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
177 |
3893 | 178 if (allowedSyntaxes.find(syntax) != allowedSyntaxes.end()) |
179 { | |
180 // No transcoding is needed | |
181 return true; | |
182 } | |
183 | |
184 if (allowedSyntaxes.find(DicomTransferSyntax_LittleEndianImplicit) != allowedSyntaxes.end() && | |
185 FromDcmtkBridge::Transcode(dicom, DicomTransferSyntax_LittleEndianImplicit, NULL)) | |
186 { | |
187 CheckSopInstanceUid(dicom, sourceSopInstanceUid, true); | |
188 return true; | |
189 } | |
190 | |
191 if (allowedSyntaxes.find(DicomTransferSyntax_LittleEndianExplicit) != allowedSyntaxes.end() && | |
192 FromDcmtkBridge::Transcode(dicom, DicomTransferSyntax_LittleEndianExplicit, NULL)) | |
193 { | |
194 CheckSopInstanceUid(dicom, sourceSopInstanceUid, true); | |
195 return true; | |
196 } | |
197 | |
198 if (allowedSyntaxes.find(DicomTransferSyntax_BigEndianExplicit) != allowedSyntaxes.end() && | |
199 FromDcmtkBridge::Transcode(dicom, DicomTransferSyntax_BigEndianExplicit, NULL)) | |
200 { | |
201 CheckSopInstanceUid(dicom, sourceSopInstanceUid, true); | |
202 return true; | |
203 } | |
204 | |
205 if (allowedSyntaxes.find(DicomTransferSyntax_DeflatedLittleEndianExplicit) != allowedSyntaxes.end() && | |
206 FromDcmtkBridge::Transcode(dicom, DicomTransferSyntax_DeflatedLittleEndianExplicit, NULL)) | |
207 { | |
208 CheckSopInstanceUid(dicom, sourceSopInstanceUid, true); | |
209 return true; | |
210 } | |
211 | |
212 #if ORTHANC_ENABLE_DCMTK_JPEG == 1 | |
213 if (allowedSyntaxes.find(DicomTransferSyntax_JPEGProcess1) != allowedSyntaxes.end() && | |
214 allowNewSopInstanceUid && | |
215 bitsStored == 8) | |
216 { | |
217 // Check out "dcmjpeg/apps/dcmcjpeg.cc" | |
218 DJ_RPLossy parameters(lossyQuality_); | |
219 | |
220 if (FromDcmtkBridge::Transcode(dicom, DicomTransferSyntax_JPEGProcess1, ¶meters)) | |
221 { | |
222 CheckSopInstanceUid(dicom, sourceSopInstanceUid, false); | |
3894
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
223 hasSopInstanceUidChanged = true; |
3893 | 224 return true; |
225 } | |
226 } | |
227 #endif | |
228 | |
229 #if ORTHANC_ENABLE_DCMTK_JPEG == 1 | |
230 if (allowedSyntaxes.find(DicomTransferSyntax_JPEGProcess2_4) != allowedSyntaxes.end() && | |
231 allowNewSopInstanceUid && | |
232 bitsStored <= 12) | |
233 { | |
234 // Check out "dcmjpeg/apps/dcmcjpeg.cc" | |
235 DJ_RPLossy parameters(lossyQuality_); | |
236 if (FromDcmtkBridge::Transcode(dicom, DicomTransferSyntax_JPEGProcess2_4, ¶meters)) | |
237 { | |
238 CheckSopInstanceUid(dicom, sourceSopInstanceUid, false); | |
3894
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
239 hasSopInstanceUidChanged = true; |
3893 | 240 return true; |
241 } | |
242 } | |
243 #endif | |
244 | |
245 #if ORTHANC_ENABLE_DCMTK_JPEG == 1 | |
246 if (allowedSyntaxes.find(DicomTransferSyntax_JPEGProcess14SV1) != allowedSyntaxes.end()) | |
247 { | |
248 // Check out "dcmjpeg/apps/dcmcjpeg.cc" | |
249 DJ_RPLossless parameters(6 /* opt_selection_value */, | |
250 0 /* opt_point_transform */); | |
251 if (FromDcmtkBridge::Transcode(dicom, DicomTransferSyntax_JPEGProcess14SV1, ¶meters)) | |
252 { | |
253 CheckSopInstanceUid(dicom, sourceSopInstanceUid, true); | |
254 return true; | |
255 } | |
256 } | |
257 #endif | |
258 | |
259 #if ORTHANC_ENABLE_DCMTK_JPEG_LOSSLESS == 1 | |
260 if (allowedSyntaxes.find(DicomTransferSyntax_JPEGLSLossless) != allowedSyntaxes.end()) | |
261 { | |
262 // Check out "dcmjpls/apps/dcmcjpls.cc" | |
263 DJLSRepresentationParameter parameters(2 /* opt_nearlossless_deviation */, | |
264 OFTrue /* opt_useLosslessProcess */); | |
265 | |
266 /** | |
267 * WARNING: This call results in a segmentation fault if using | |
268 * the DCMTK package 3.6.2 from Ubuntu 18.04. | |
269 **/ | |
270 if (FromDcmtkBridge::Transcode(dicom, DicomTransferSyntax_JPEGLSLossless, ¶meters)) | |
271 { | |
272 CheckSopInstanceUid(dicom, sourceSopInstanceUid, true); | |
273 return true; | |
274 } | |
275 } | |
276 #endif | |
277 | |
278 #if ORTHANC_ENABLE_DCMTK_JPEG_LOSSLESS == 1 | |
279 if (allowNewSopInstanceUid && | |
280 allowedSyntaxes.find(DicomTransferSyntax_JPEGLSLossy) != allowedSyntaxes.end()) | |
281 { | |
282 // Check out "dcmjpls/apps/dcmcjpls.cc" | |
283 DJLSRepresentationParameter parameters(2 /* opt_nearlossless_deviation */, | |
284 OFFalse /* opt_useLosslessProcess */); | |
285 | |
286 /** | |
287 * WARNING: This call results in a segmentation fault if using | |
288 * the DCMTK package 3.6.2 from Ubuntu 18.04. | |
289 **/ | |
290 if (FromDcmtkBridge::Transcode(dicom, DicomTransferSyntax_JPEGLSLossy, ¶meters)) | |
291 { | |
292 CheckSopInstanceUid(dicom, sourceSopInstanceUid, false); | |
3894
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
293 hasSopInstanceUidChanged = true; |
3893 | 294 return true; |
295 } | |
296 } | |
297 #endif | |
298 | |
299 return false; | |
300 } | |
301 | |
302 | |
303 bool DcmtkTranscoder::TranscodeToBuffer(std::string& target, | |
3894
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
304 bool& hasSopInstanceUidChanged /* out */, |
3893 | 305 const void* buffer, |
306 size_t size, | |
307 const std::set<DicomTransferSyntax>& allowedSyntaxes, | |
308 bool allowNewSopInstanceUid) | |
309 { | |
310 std::unique_ptr<DcmFileFormat> transcoded( | |
3894
8f7ad4989fec
transcoding to uncompressed transfer syntaxes over DICOM protocol is implemented
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3893
diff
changeset
|
311 TranscodeToParsed(hasSopInstanceUidChanged, buffer, size, allowedSyntaxes, allowNewSopInstanceUid)); |
3893 | 312 |
313 if (transcoded.get() == NULL) | |
314 { | |
315 return false; | |
316 } | |
317 else | |
318 { | |
319 if (transcoded->getDataset() == NULL) | |
320 { | |
321 throw OrthancException(ErrorCode_InternalError); | |
322 } | |
323 | |
324 FromDcmtkBridge::SaveToMemoryBuffer(target, *transcoded->getDataset()); | |
325 return true; | |
326 } | |
327 } | |
328 } |