Mercurial > hg > orthanc
comparison Core/DicomParsing/ParsedDicomFile.cpp @ 2905:ae20fccdd867
refactoring mime types
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Tue, 30 Oct 2018 11:55:23 +0100 |
parents | f3c1eda54e47 |
children | 9d277f8ad698 |
comparison
equal
deleted
inserted
replaced
2904:0dd54ee073db | 2905:ae20fccdd867 |
---|---|
80 #endif | 80 #endif |
81 | 81 |
82 #include "ParsedDicomFile.h" | 82 #include "ParsedDicomFile.h" |
83 | 83 |
84 #include "FromDcmtkBridge.h" | 84 #include "FromDcmtkBridge.h" |
85 #include "Internals/DicomFrameIndex.h" | |
85 #include "ToDcmtkBridge.h" | 86 #include "ToDcmtkBridge.h" |
86 #include "Internals/DicomFrameIndex.h" | 87 |
88 #include "../Images/PamReader.h" | |
87 #include "../Logging.h" | 89 #include "../Logging.h" |
88 #include "../OrthancException.h" | 90 #include "../OrthancException.h" |
89 #include "../Toolbox.h" | 91 #include "../Toolbox.h" |
90 | 92 |
91 #if ORTHANC_SANDBOXED == 0 | 93 #if ORTHANC_SANDBOXED == 0 |
158 std::auto_ptr<DicomFrameIndex> frameIndex_; | 160 std::auto_ptr<DicomFrameIndex> frameIndex_; |
159 }; | 161 }; |
160 | 162 |
161 | 163 |
162 #if ORTHANC_ENABLE_CIVETWEB == 1 || ORTHANC_ENABLE_MONGOOSE == 1 | 164 #if ORTHANC_ENABLE_CIVETWEB == 1 || ORTHANC_ENABLE_MONGOOSE == 1 |
163 static const char* CONTENT_TYPE_OCTET_STREAM = "application/octet-stream"; | |
164 | |
165 static void ParseTagAndGroup(DcmTagKey& key, | 165 static void ParseTagAndGroup(DcmTagKey& key, |
166 const std::string& tag) | 166 const std::string& tag) |
167 { | 167 { |
168 DicomTag t = FromDcmtkBridge::ParseTag(tag); | 168 DicomTag t = FromDcmtkBridge::ParseTag(tag); |
169 key = DcmTagKey(t.GetGroup(), t.GetElement()); | 169 key = DcmTagKey(t.GetGroup(), t.GetElement()); |
360 DcmPixelItem* pixelItem = NULL; | 360 DcmPixelItem* pixelItem = NULL; |
361 if (pixelSequence->getItem(pixelItem, block).good() && pixelItem) | 361 if (pixelSequence->getItem(pixelItem, block).good() && pixelItem) |
362 { | 362 { |
363 if (pixelItem->getLength() == 0) | 363 if (pixelItem->getLength() == 0) |
364 { | 364 { |
365 output.AnswerBuffer(NULL, 0, CONTENT_TYPE_OCTET_STREAM); | 365 output.AnswerBuffer(NULL, 0, MIME_BINARY); |
366 return true; | 366 return true; |
367 } | 367 } |
368 | 368 |
369 Uint8* buffer = NULL; | 369 Uint8* buffer = NULL; |
370 if (pixelItem->getUint8Array(buffer).good() && buffer) | 370 if (pixelItem->getUint8Array(buffer).good() && buffer) |
371 { | 371 { |
372 output.AnswerBuffer(buffer, pixelItem->getLength(), CONTENT_TYPE_OCTET_STREAM); | 372 output.AnswerBuffer(buffer, pixelItem->getLength(), MIME_BINARY); |
373 return true; | 373 return true; |
374 } | 374 } |
375 } | 375 } |
376 } | 376 } |
377 } | 377 } |
690 | 690 |
691 std::string binary; | 691 std::string binary; |
692 const std::string* decoded = &utf8Value; | 692 const std::string* decoded = &utf8Value; |
693 | 693 |
694 if (decodeDataUriScheme && | 694 if (decodeDataUriScheme && |
695 boost::starts_with(utf8Value, "data:application/octet-stream;base64,")) | 695 boost::starts_with(utf8Value, URI_SCHEME_PREFIX_BINARY)) |
696 { | 696 { |
697 std::string mime; | 697 std::string mime; |
698 if (!Toolbox::DecodeDataUriScheme(mime, binary, utf8Value)) | 698 if (!Toolbox::DecodeDataUriScheme(mime, binary, utf8Value)) |
699 { | 699 { |
700 throw OrthancException(ErrorCode_BadFileFormat); | 700 throw OrthancException(ErrorCode_BadFileFormat); |
823 void ParsedDicomFile::Answer(RestApiOutput& output) | 823 void ParsedDicomFile::Answer(RestApiOutput& output) |
824 { | 824 { |
825 std::string serialized; | 825 std::string serialized; |
826 if (FromDcmtkBridge::SaveToMemoryBuffer(serialized, *pimpl_->file_->getDataset())) | 826 if (FromDcmtkBridge::SaveToMemoryBuffer(serialized, *pimpl_->file_->getDataset())) |
827 { | 827 { |
828 output.AnswerBuffer(serialized, CONTENT_TYPE_OCTET_STREAM); | 828 output.AnswerBuffer(serialized, MIME_BINARY); |
829 } | 829 } |
830 } | 830 } |
831 #endif | 831 #endif |
832 | 832 |
833 | 833 |
1070 return false; | 1070 return false; |
1071 } | 1071 } |
1072 | 1072 |
1073 Toolbox::ToLowerCase(mime); | 1073 Toolbox::ToLowerCase(mime); |
1074 | 1074 |
1075 if (mime == "image/png") | 1075 if (mime == MIME_PNG) |
1076 { | 1076 { |
1077 #if ORTHANC_ENABLE_PNG == 1 | 1077 #if ORTHANC_ENABLE_PNG == 1 |
1078 EmbedImage(mime, content); | 1078 EmbedImage(mime, content); |
1079 #else | 1079 #else |
1080 LOG(ERROR) << "Orthanc was compiled without support of PNG"; | 1080 LOG(ERROR) << "Orthanc was compiled without support of PNG"; |
1081 throw OrthancException(ErrorCode_NotImplemented); | 1081 throw OrthancException(ErrorCode_NotImplemented); |
1082 #endif | 1082 #endif |
1083 } | 1083 } |
1084 else if (mime == "image/jpeg") | 1084 else if (mime == MIME_JPEG) |
1085 { | 1085 { |
1086 #if ORTHANC_ENABLE_JPEG == 1 | 1086 #if ORTHANC_ENABLE_JPEG == 1 |
1087 EmbedImage(mime, content); | 1087 EmbedImage(mime, content); |
1088 #else | 1088 #else |
1089 LOG(ERROR) << "Orthanc was compiled without support of JPEG"; | 1089 LOG(ERROR) << "Orthanc was compiled without support of JPEG"; |
1090 throw OrthancException(ErrorCode_NotImplemented); | 1090 throw OrthancException(ErrorCode_NotImplemented); |
1091 #endif | 1091 #endif |
1092 } | 1092 } |
1093 else if (mime == "application/pdf") | 1093 else if (mime == MIME_PAM) |
1094 { | |
1095 EmbedImage(mime, content); | |
1096 } | |
1097 else if (mime == MIME_PDF) | |
1094 { | 1098 { |
1095 EmbedPdf(content); | 1099 EmbedPdf(content); |
1096 } | 1100 } |
1097 else | 1101 else |
1098 { | 1102 { |
1111 throw OrthancException(ErrorCode_BadFileFormat); | 1115 throw OrthancException(ErrorCode_BadFileFormat); |
1112 } | 1116 } |
1113 } | 1117 } |
1114 | 1118 |
1115 | 1119 |
1116 #if (ORTHANC_ENABLE_JPEG == 1 && \ | |
1117 ORTHANC_ENABLE_PNG == 1) | |
1118 void ParsedDicomFile::EmbedImage(const std::string& mime, | 1120 void ParsedDicomFile::EmbedImage(const std::string& mime, |
1119 const std::string& content) | 1121 const std::string& content) |
1120 { | 1122 { |
1121 if (mime == "image/png") | 1123 #if ORTHANC_ENABLE_JPEG == 1 |
1124 if (mime == MIME_JPEG) | |
1125 { | |
1126 JpegReader reader; | |
1127 reader.ReadFromMemory(content); | |
1128 EmbedImage(reader); | |
1129 return; | |
1130 } | |
1131 #endif | |
1132 | |
1133 #if ORTHANC_ENABLE_PNG == 1 | |
1134 if (mime == MIME_PNG) | |
1122 { | 1135 { |
1123 PngReader reader; | 1136 PngReader reader; |
1124 reader.ReadFromMemory(content); | 1137 reader.ReadFromMemory(content); |
1125 EmbedImage(reader); | 1138 EmbedImage(reader); |
1126 } | 1139 return; |
1127 else if (mime == "image/jpeg") | 1140 } |
1128 { | 1141 #endif |
1129 JpegReader reader; | 1142 |
1143 if (mime == MIME_PAM) | |
1144 { | |
1145 PamReader reader; | |
1130 reader.ReadFromMemory(content); | 1146 reader.ReadFromMemory(content); |
1131 EmbedImage(reader); | 1147 EmbedImage(reader); |
1132 } | 1148 } |
1133 else | 1149 else |
1134 { | 1150 { |
1135 throw OrthancException(ErrorCode_NotImplemented); | 1151 throw OrthancException(ErrorCode_NotImplemented); |
1136 } | 1152 } |
1137 } | 1153 } |
1138 #endif | |
1139 | 1154 |
1140 | 1155 |
1141 void ParsedDicomFile::EmbedImage(const ImageAccessor& accessor) | 1156 void ParsedDicomFile::EmbedImage(const ImageAccessor& accessor) |
1142 { | 1157 { |
1143 if (accessor.GetFormat() != PixelFormat_Grayscale8 && | 1158 if (accessor.GetFormat() != PixelFormat_Grayscale8 && |
1344 InvalidateCache(); | 1359 InvalidateCache(); |
1345 | 1360 |
1346 ReplacePlainString(DICOM_TAG_SOP_CLASS_UID, UID_EncapsulatedPDFStorage); | 1361 ReplacePlainString(DICOM_TAG_SOP_CLASS_UID, UID_EncapsulatedPDFStorage); |
1347 ReplacePlainString(FromDcmtkBridge::Convert(DCM_Modality), "OT"); | 1362 ReplacePlainString(FromDcmtkBridge::Convert(DCM_Modality), "OT"); |
1348 ReplacePlainString(FromDcmtkBridge::Convert(DCM_ConversionType), "WSD"); | 1363 ReplacePlainString(FromDcmtkBridge::Convert(DCM_ConversionType), "WSD"); |
1349 ReplacePlainString(FromDcmtkBridge::Convert(DCM_MIMETypeOfEncapsulatedDocument), "application/pdf"); | 1364 ReplacePlainString(FromDcmtkBridge::Convert(DCM_MIMETypeOfEncapsulatedDocument), MIME_PDF); |
1350 //ReplacePlainString(FromDcmtkBridge::Convert(DCM_SeriesNumber), "1"); | 1365 //ReplacePlainString(FromDcmtkBridge::Convert(DCM_SeriesNumber), "1"); |
1351 | 1366 |
1352 std::auto_ptr<DcmPolymorphOBOW> element(new DcmPolymorphOBOW(DCM_EncapsulatedDocument)); | 1367 std::auto_ptr<DcmPolymorphOBOW> element(new DcmPolymorphOBOW(DCM_EncapsulatedDocument)); |
1353 | 1368 |
1354 size_t s = pdf.size(); | 1369 size_t s = pdf.size(); |
1386 std::string sop, mime; | 1401 std::string sop, mime; |
1387 | 1402 |
1388 if (!GetTagValue(sop, DICOM_TAG_SOP_CLASS_UID) || | 1403 if (!GetTagValue(sop, DICOM_TAG_SOP_CLASS_UID) || |
1389 !GetTagValue(mime, FromDcmtkBridge::Convert(DCM_MIMETypeOfEncapsulatedDocument)) || | 1404 !GetTagValue(mime, FromDcmtkBridge::Convert(DCM_MIMETypeOfEncapsulatedDocument)) || |
1390 sop != UID_EncapsulatedPDFStorage || | 1405 sop != UID_EncapsulatedPDFStorage || |
1391 mime != "application/pdf") | 1406 mime != MIME_PDF) |
1392 { | 1407 { |
1393 return false; | 1408 return false; |
1394 } | 1409 } |
1395 | 1410 |
1396 if (!GetTagValue(pdf, DICOM_TAG_ENCAPSULATED_DOCUMENT)) | 1411 if (!GetTagValue(pdf, DICOM_TAG_ENCAPSULATED_DOCUMENT)) |
1468 | 1483 |
1469 E_TransferSyntax transferSyntax = pimpl_->file_->getDataset()->getOriginalXfer(); | 1484 E_TransferSyntax transferSyntax = pimpl_->file_->getDataset()->getOriginalXfer(); |
1470 switch (transferSyntax) | 1485 switch (transferSyntax) |
1471 { | 1486 { |
1472 case EXS_JPEGProcess1: | 1487 case EXS_JPEGProcess1: |
1473 mime = "image/jpeg"; | 1488 mime = MIME_JPEG; |
1474 break; | 1489 break; |
1475 | 1490 |
1476 case EXS_JPEG2000LosslessOnly: | 1491 case EXS_JPEG2000LosslessOnly: |
1477 case EXS_JPEG2000: | 1492 case EXS_JPEG2000: |
1478 mime = "image/jp2"; | 1493 mime = MIME_JPEG2000; |
1479 break; | 1494 break; |
1480 | 1495 |
1481 default: | 1496 default: |
1482 mime = "application/octet-stream"; | 1497 mime = MIME_BINARY; |
1483 break; | 1498 break; |
1484 } | 1499 } |
1485 } | 1500 } |
1486 | 1501 |
1487 | 1502 |