Mercurial > hg > orthanc-wsi
annotate Resources/Orthanc/OrthancServer/ServerEnumerations.cpp @ 105:42dcf1438943
notes
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Wed, 22 Mar 2017 15:53:48 +0100 |
parents | ff0ef01c332c |
children | a3e8ac8b7256 |
rev | line source |
---|---|
1 | 1 /** |
2 * Orthanc - A Lightweight, RESTful DICOM Store | |
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
4 * Department, University Hospital of Liege, Belgium | |
98
ff0ef01c332c
shared copyright with osimis
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
82
diff
changeset
|
5 * Copyright (C) 2017 Osimis, Belgium |
1 | 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 "PrecompiledHeadersServer.h" | |
35 #include "ServerEnumerations.h" | |
36 | |
37 #include "../Core/OrthancException.h" | |
38 #include "../Core/EnumerationDictionary.h" | |
39 #include "../Core/Logging.h" | |
40 #include "../Core/Toolbox.h" | |
41 | |
42 #include <boost/thread.hpp> | |
43 | |
44 namespace Orthanc | |
45 { | |
46 typedef std::map<FileContentType, std::string> MimeTypes; | |
47 | |
48 static boost::mutex enumerationsMutex_; | |
49 static Toolbox::EnumerationDictionary<MetadataType> dictMetadataType_; | |
50 static Toolbox::EnumerationDictionary<FileContentType> dictContentType_; | |
51 static MimeTypes mimeTypes_; | |
52 | |
53 void InitializeServerEnumerations() | |
54 { | |
55 boost::mutex::scoped_lock lock(enumerationsMutex_); | |
56 | |
57 dictMetadataType_.Clear(); | |
58 dictContentType_.Clear(); | |
59 | |
60 dictMetadataType_.Add(MetadataType_Instance_IndexInSeries, "IndexInSeries"); | |
61 dictMetadataType_.Add(MetadataType_Instance_ReceptionDate, "ReceptionDate"); | |
62 dictMetadataType_.Add(MetadataType_Instance_RemoteAet, "RemoteAET"); | |
63 dictMetadataType_.Add(MetadataType_Series_ExpectedNumberOfInstances, "ExpectedNumberOfInstances"); | |
64 dictMetadataType_.Add(MetadataType_ModifiedFrom, "ModifiedFrom"); | |
65 dictMetadataType_.Add(MetadataType_AnonymizedFrom, "AnonymizedFrom"); | |
66 dictMetadataType_.Add(MetadataType_LastUpdate, "LastUpdate"); | |
67 dictMetadataType_.Add(MetadataType_Instance_Origin, "Origin"); | |
82 | 68 dictMetadataType_.Add(MetadataType_Instance_TransferSyntax, "TransferSyntax"); |
69 dictMetadataType_.Add(MetadataType_Instance_SopClassUid, "SopClassUid"); | |
1 | 70 |
71 dictContentType_.Add(FileContentType_Dicom, "dicom"); | |
72 dictContentType_.Add(FileContentType_DicomAsJson, "dicom-as-json"); | |
73 } | |
74 | |
75 void RegisterUserMetadata(int metadata, | |
76 const std::string& name) | |
77 { | |
78 boost::mutex::scoped_lock lock(enumerationsMutex_); | |
79 | |
80 MetadataType type = static_cast<MetadataType>(metadata); | |
81 | |
82 if (metadata < 0 || | |
83 !IsUserMetadata(type)) | |
84 { | |
85 LOG(ERROR) << "A user content type must have index between " | |
86 << static_cast<int>(MetadataType_StartUser) << " and " | |
87 << static_cast<int>(MetadataType_EndUser) << ", but \"" | |
88 << name << "\" has index " << metadata; | |
89 | |
90 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
91 } | |
92 | |
93 if (dictMetadataType_.Contains(type)) | |
94 { | |
95 LOG(ERROR) << "Cannot associate user content type \"" | |
96 << name << "\" with index " << metadata | |
97 << ", as this index is already used"; | |
98 | |
99 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
100 } | |
101 | |
102 dictMetadataType_.Add(type, name); | |
103 } | |
104 | |
105 std::string EnumerationToString(MetadataType type) | |
106 { | |
107 // This function MUST return a "std::string" and not "const | |
108 // char*", as the result is not a static string | |
109 boost::mutex::scoped_lock lock(enumerationsMutex_); | |
110 return dictMetadataType_.Translate(type); | |
111 } | |
112 | |
113 MetadataType StringToMetadata(const std::string& str) | |
114 { | |
115 boost::mutex::scoped_lock lock(enumerationsMutex_); | |
116 return dictMetadataType_.Translate(str); | |
117 } | |
118 | |
119 void RegisterUserContentType(int contentType, | |
120 const std::string& name, | |
121 const std::string& mime) | |
122 { | |
123 boost::mutex::scoped_lock lock(enumerationsMutex_); | |
124 | |
125 FileContentType type = static_cast<FileContentType>(contentType); | |
126 | |
127 if (contentType < 0 || | |
128 !IsUserContentType(type)) | |
129 { | |
130 LOG(ERROR) << "A user content type must have index between " | |
131 << static_cast<int>(FileContentType_StartUser) << " and " | |
132 << static_cast<int>(FileContentType_EndUser) << ", but \"" | |
133 << name << "\" has index " << contentType; | |
134 | |
135 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
136 } | |
137 | |
138 if (dictContentType_.Contains(type)) | |
139 { | |
140 LOG(ERROR) << "Cannot associate user content type \"" | |
141 << name << "\" with index " << contentType | |
142 << ", as this index is already used"; | |
143 | |
144 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
145 } | |
146 | |
147 dictContentType_.Add(type, name); | |
148 mimeTypes_[type] = mime; | |
149 } | |
150 | |
151 std::string EnumerationToString(FileContentType type) | |
152 { | |
153 // This function MUST return a "std::string" and not "const | |
154 // char*", as the result is not a static string | |
155 boost::mutex::scoped_lock lock(enumerationsMutex_); | |
156 return dictContentType_.Translate(type); | |
157 } | |
158 | |
159 std::string GetFileContentMime(FileContentType type) | |
160 { | |
161 if (type >= FileContentType_StartUser && | |
162 type <= FileContentType_EndUser) | |
163 { | |
164 boost::mutex::scoped_lock lock(enumerationsMutex_); | |
165 | |
166 MimeTypes::const_iterator it = mimeTypes_.find(type); | |
167 if (it != mimeTypes_.end()) | |
168 { | |
169 return it->second; | |
170 } | |
171 } | |
172 | |
173 switch (type) | |
174 { | |
175 case FileContentType_Dicom: | |
176 return "application/dicom"; | |
177 | |
178 case FileContentType_DicomAsJson: | |
179 return "application/json"; | |
180 | |
181 default: | |
182 return "application/octet-stream"; | |
183 } | |
184 } | |
185 | |
186 FileContentType StringToContentType(const std::string& str) | |
187 { | |
188 boost::mutex::scoped_lock lock(enumerationsMutex_); | |
189 return dictContentType_.Translate(str); | |
190 } | |
191 | |
192 std::string GetBasePath(ResourceType type, | |
193 const std::string& publicId) | |
194 { | |
195 switch (type) | |
196 { | |
197 case ResourceType_Patient: | |
198 return "/patients/" + publicId; | |
199 | |
200 case ResourceType_Study: | |
201 return "/studies/" + publicId; | |
202 | |
203 case ResourceType_Series: | |
204 return "/series/" + publicId; | |
205 | |
206 case ResourceType_Instance: | |
207 return "/instances/" + publicId; | |
208 | |
209 default: | |
210 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
211 } | |
212 } | |
213 | |
214 const char* EnumerationToString(SeriesStatus status) | |
215 { | |
216 switch (status) | |
217 { | |
218 case SeriesStatus_Complete: | |
219 return "Complete"; | |
220 | |
221 case SeriesStatus_Missing: | |
222 return "Missing"; | |
223 | |
224 case SeriesStatus_Inconsistent: | |
225 return "Inconsistent"; | |
226 | |
227 case SeriesStatus_Unknown: | |
228 return "Unknown"; | |
229 | |
230 default: | |
231 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
232 } | |
233 } | |
234 | |
235 const char* EnumerationToString(StoreStatus status) | |
236 { | |
237 switch (status) | |
238 { | |
239 case StoreStatus_Success: | |
240 return "Success"; | |
241 | |
242 case StoreStatus_AlreadyStored: | |
243 return "AlreadyStored"; | |
244 | |
245 case StoreStatus_Failure: | |
246 return "Failure"; | |
247 | |
248 case StoreStatus_FilteredOut: | |
249 return "FilteredOut"; | |
250 | |
251 default: | |
252 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
253 } | |
254 } | |
255 | |
256 | |
257 const char* EnumerationToString(ChangeType type) | |
258 { | |
259 switch (type) | |
260 { | |
261 case ChangeType_CompletedSeries: | |
262 return "CompletedSeries"; | |
263 | |
264 case ChangeType_NewInstance: | |
265 return "NewInstance"; | |
266 | |
267 case ChangeType_NewPatient: | |
268 return "NewPatient"; | |
269 | |
270 case ChangeType_NewSeries: | |
271 return "NewSeries"; | |
272 | |
273 case ChangeType_NewStudy: | |
274 return "NewStudy"; | |
275 | |
276 case ChangeType_AnonymizedStudy: | |
277 return "AnonymizedStudy"; | |
278 | |
279 case ChangeType_AnonymizedSeries: | |
280 return "AnonymizedSeries"; | |
281 | |
282 case ChangeType_ModifiedStudy: | |
283 return "ModifiedStudy"; | |
284 | |
285 case ChangeType_ModifiedSeries: | |
286 return "ModifiedSeries"; | |
287 | |
288 case ChangeType_AnonymizedPatient: | |
289 return "AnonymizedPatient"; | |
290 | |
291 case ChangeType_ModifiedPatient: | |
292 return "ModifiedPatient"; | |
293 | |
294 case ChangeType_StablePatient: | |
295 return "StablePatient"; | |
296 | |
297 case ChangeType_StableStudy: | |
298 return "StableStudy"; | |
299 | |
300 case ChangeType_StableSeries: | |
301 return "StableSeries"; | |
302 | |
303 case ChangeType_Deleted: | |
304 return "Deleted"; | |
305 | |
306 case ChangeType_NewChildInstance: | |
307 return "NewChildInstance"; | |
308 | |
309 case ChangeType_UpdatedAttachment: | |
310 return "UpdatedAttachment"; | |
311 | |
312 case ChangeType_UpdatedMetadata: | |
313 return "UpdatedMetadata"; | |
314 | |
315 default: | |
316 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
317 } | |
318 } | |
319 | |
320 | |
321 const char* EnumerationToString(ModalityManufacturer manufacturer) | |
322 { | |
323 switch (manufacturer) | |
324 { | |
325 case ModalityManufacturer_Generic: | |
326 return "Generic"; | |
327 | |
328 case ModalityManufacturer_StoreScp: | |
329 return "StoreScp"; | |
330 | |
331 case ModalityManufacturer_ClearCanvas: | |
332 return "ClearCanvas"; | |
333 | |
334 case ModalityManufacturer_MedInria: | |
335 return "MedInria"; | |
336 | |
337 case ModalityManufacturer_Dcm4Chee: | |
338 return "Dcm4Chee"; | |
339 | |
340 case ModalityManufacturer_SyngoVia: | |
341 return "SyngoVia"; | |
342 | |
343 case ModalityManufacturer_AgfaImpax: | |
344 return "AgfaImpax"; | |
345 | |
346 case ModalityManufacturer_EFilm2: | |
347 return "EFilm2"; | |
348 | |
349 case ModalityManufacturer_Vitrea: | |
350 return "Vitrea"; | |
351 | |
352 default: | |
353 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
354 } | |
355 } | |
356 | |
357 | |
358 const char* EnumerationToString(DicomRequestType type) | |
359 { | |
360 switch (type) | |
361 { | |
362 case DicomRequestType_Echo: | |
363 return "Echo"; | |
364 break; | |
365 | |
366 case DicomRequestType_Find: | |
367 return "Find"; | |
368 break; | |
369 | |
370 case DicomRequestType_Get: | |
371 return "Get"; | |
372 break; | |
373 | |
374 case DicomRequestType_Move: | |
375 return "Move"; | |
376 break; | |
377 | |
378 case DicomRequestType_Store: | |
379 return "Store"; | |
380 break; | |
381 | |
382 default: | |
383 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
384 } | |
385 } | |
386 | |
387 | |
388 | |
389 ModalityManufacturer StringToModalityManufacturer(const std::string& manufacturer) | |
390 { | |
391 if (manufacturer == "Generic") | |
392 { | |
393 return ModalityManufacturer_Generic; | |
394 } | |
395 else if (manufacturer == "ClearCanvas") | |
396 { | |
397 return ModalityManufacturer_ClearCanvas; | |
398 } | |
399 else if (manufacturer == "StoreScp") | |
400 { | |
401 return ModalityManufacturer_StoreScp; | |
402 } | |
403 else if (manufacturer == "MedInria") | |
404 { | |
405 return ModalityManufacturer_MedInria; | |
406 } | |
407 else if (manufacturer == "Dcm4Chee") | |
408 { | |
409 return ModalityManufacturer_Dcm4Chee; | |
410 } | |
411 else if (manufacturer == "SyngoVia") | |
412 { | |
413 return ModalityManufacturer_SyngoVia; | |
414 } | |
415 else if (manufacturer == "AgfaImpax") | |
416 { | |
417 return ModalityManufacturer_AgfaImpax; | |
418 } | |
419 else if (manufacturer == "Vitrea") | |
420 { | |
421 return ModalityManufacturer_Vitrea; | |
422 } | |
423 else if (manufacturer == "EFilm2") | |
424 { | |
425 return ModalityManufacturer_EFilm2; | |
426 } | |
427 else | |
428 { | |
429 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
430 } | |
431 } | |
432 | |
433 | |
434 const char* EnumerationToString(TransferSyntax syntax) | |
435 { | |
436 switch (syntax) | |
437 { | |
438 case TransferSyntax_Deflated: | |
439 return "Deflated"; | |
440 | |
441 case TransferSyntax_Jpeg: | |
442 return "JPEG"; | |
443 | |
444 case TransferSyntax_Jpeg2000: | |
445 return "JPEG2000"; | |
446 | |
447 case TransferSyntax_JpegLossless: | |
448 return "JPEG Lossless"; | |
449 | |
450 case TransferSyntax_Jpip: | |
451 return "JPIP"; | |
452 | |
453 case TransferSyntax_Mpeg2: | |
454 return "MPEG2"; | |
455 | |
456 case TransferSyntax_Rle: | |
457 return "RLE"; | |
458 | |
459 default: | |
460 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
461 } | |
462 } | |
463 | |
464 | |
465 bool IsUserMetadata(MetadataType metadata) | |
466 { | |
467 return (metadata >= MetadataType_StartUser && | |
468 metadata <= MetadataType_EndUser); | |
469 } | |
470 } |