orthanc: Core/DicomParsing/ParsedDicomFile.cpp comparison

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

-:0dd54ee073db
+:ae20fccdd867
 #endif
 #include "ParsedDicomFile.h"
 #include "FromDcmtkBridge.h"
+#include "Internals/DicomFrameIndex.h"
 #include "ToDcmtkBridge.h"
-#include "Internals/DicomFrameIndex.h"
+#include "../Images/PamReader.h"
 #include "../Logging.h"
 #include "../OrthancException.h"
 #include "../Toolbox.h"
 #if ORTHANC_SANDBOXED == 0
 std::auto_ptr<DicomFrameIndex>  frameIndex_;
 };
 #if ORTHANC_ENABLE_CIVETWEB == 1 || ORTHANC_ENABLE_MONGOOSE == 1
-static const char* CONTENT_TYPE_OCTET_STREAM = "application/octet-stream";
 static void ParseTagAndGroup(DcmTagKey& key,
 const std::string& tag)
 {
 DicomTag t = FromDcmtkBridge::ParseTag(tag);
 key = DcmTagKey(t.GetGroup(), t.GetElement());
 DcmPixelItem* pixelItem = NULL;
 if (pixelSequence->getItem(pixelItem, block).good() && pixelItem)
 {
 if (pixelItem->getLength() == 0)
 {
-output.AnswerBuffer(NULL, 0, CONTENT_TYPE_OCTET_STREAM);
+output.AnswerBuffer(NULL, 0, MIME_BINARY);
 return true;
 }
 Uint8* buffer = NULL;
 if (pixelItem->getUint8Array(buffer).good() && buffer)
 {
-output.AnswerBuffer(buffer, pixelItem->getLength(), CONTENT_TYPE_OCTET_STREAM);
+output.AnswerBuffer(buffer, pixelItem->getLength(), MIME_BINARY);
 return true;
 }
 }
 }
 }
 std::string binary;
 const std::string* decoded = &utf8Value;
 if (decodeDataUriScheme &&
-boost::starts_with(utf8Value, "data:application/octet-stream;base64,"))
+boost::starts_with(utf8Value, URI_SCHEME_PREFIX_BINARY))
 {
 std::string mime;
 if (!Toolbox::DecodeDataUriScheme(mime, binary, utf8Value))
 {
 throw OrthancException(ErrorCode_BadFileFormat);
 void ParsedDicomFile::Answer(RestApiOutput& output)
 {
 std::string serialized;
 if (FromDcmtkBridge::SaveToMemoryBuffer(serialized, *pimpl_->file_->getDataset()))
 {
-output.AnswerBuffer(serialized, CONTENT_TYPE_OCTET_STREAM);
+output.AnswerBuffer(serialized, MIME_BINARY);
 }
 }
 #endif
 return false;
 }
 Toolbox::ToLowerCase(mime);
-if (mime == "image/png")
+if (mime == MIME_PNG)
 {
 #if ORTHANC_ENABLE_PNG == 1
 EmbedImage(mime, content);
 #else
 LOG(ERROR) << "Orthanc was compiled without support of PNG";
 throw OrthancException(ErrorCode_NotImplemented);
 #endif
 }
-else if (mime == "image/jpeg")
+else if (mime == MIME_JPEG)
 {
 #if ORTHANC_ENABLE_JPEG == 1
 EmbedImage(mime, content);
 #else
 LOG(ERROR) << "Orthanc was compiled without support of JPEG";
 throw OrthancException(ErrorCode_NotImplemented);
 #endif
 }
-else if (mime == "application/pdf")
+else if (mime == MIME_PAM)
+{
+EmbedImage(mime, content);
+}
+else if (mime == MIME_PDF)
 {
 EmbedPdf(content);
 }
 else
 {
 throw OrthancException(ErrorCode_BadFileFormat);
 }
 }
-#if (ORTHANC_ENABLE_JPEG == 1 &&                \
-ORTHANC_ENABLE_PNG == 1)
 void ParsedDicomFile::EmbedImage(const std::string& mime,
 const std::string& content)
 {
-if (mime == "image/png")
+#if ORTHANC_ENABLE_JPEG == 1
+if (mime == MIME_JPEG)
+{
+JpegReader reader;
+reader.ReadFromMemory(content);
+EmbedImage(reader);
+return;
+}
+#endif
+#if ORTHANC_ENABLE_PNG == 1
+if (mime == MIME_PNG)
 {
 PngReader reader;
 reader.ReadFromMemory(content);
 EmbedImage(reader);
-}
+return;
-else if (mime == "image/jpeg")
+}
-{
+#endif
-JpegReader reader;
+if (mime == MIME_PAM)
+{
+PamReader reader;
 reader.ReadFromMemory(content);
 EmbedImage(reader);
 }
 else
 {
 throw OrthancException(ErrorCode_NotImplemented);
 }
 }
-#endif
 void ParsedDicomFile::EmbedImage(const ImageAccessor& accessor)
 {
 if (accessor.GetFormat() != PixelFormat_Grayscale8 &&
 InvalidateCache();
 ReplacePlainString(DICOM_TAG_SOP_CLASS_UID, UID_EncapsulatedPDFStorage);
 ReplacePlainString(FromDcmtkBridge::Convert(DCM_Modality), "OT");
 ReplacePlainString(FromDcmtkBridge::Convert(DCM_ConversionType), "WSD");
-ReplacePlainString(FromDcmtkBridge::Convert(DCM_MIMETypeOfEncapsulatedDocument), "application/pdf");
+ReplacePlainString(FromDcmtkBridge::Convert(DCM_MIMETypeOfEncapsulatedDocument), MIME_PDF);
 //ReplacePlainString(FromDcmtkBridge::Convert(DCM_SeriesNumber), "1");
 std::auto_ptr<DcmPolymorphOBOW> element(new DcmPolymorphOBOW(DCM_EncapsulatedDocument));
 size_t s = pdf.size();
 std::string sop, mime;
 if (!GetTagValue(sop, DICOM_TAG_SOP_CLASS_UID) ||
 !GetTagValue(mime, FromDcmtkBridge::Convert(DCM_MIMETypeOfEncapsulatedDocument)) ||
 sop != UID_EncapsulatedPDFStorage ||
-mime != "application/pdf")
+mime != MIME_PDF)
 {
 return false;
 }
 if (!GetTagValue(pdf, DICOM_TAG_ENCAPSULATED_DOCUMENT))
 E_TransferSyntax transferSyntax = pimpl_->file_->getDataset()->getOriginalXfer();
 switch (transferSyntax)
 {
 case EXS_JPEGProcess1:
-mime = "image/jpeg";
+mime = MIME_JPEG;
 break;
 case EXS_JPEG2000LosslessOnly:
 case EXS_JPEG2000:
-mime = "image/jp2";
+mime = MIME_JPEG2000;
 break;
 default:
-mime = "application/octet-stream";
+mime = MIME_BINARY;
 break;
 }
 }

Mercurial > hg > orthanc

comparison Core/DicomParsing/ParsedDicomFile.cpp @ 2905:ae20fccdd867