orthanc: Core/DicomParsing/FromDcmtkBridge.cpp comparison

comparison Core/DicomParsing/FromDcmtkBridge.cpp @ 3956:6e14f2da7c7e

integration transcoding->mainline

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 20 May 2020 16:42:44 +0200
parents	74eeadf5d51d
children	884b55ce01f6

comparison

equal deleted inserted replaced

-:fe0e4ef52a72
+:6e14f2da7c7e
 #    include <dcmtk/dcmjpls/djencode.h>
 #  endif
 #endif
+#include <dcmtk/dcmdata/dcrledrg.h>
+#if ORTHANC_ENABLE_DCMTK_TRANSCODING == 1
+#  include <dcmtk/dcmdata/dcrleerg.h>
+#  include <dcmtk/dcmimage/diregist.h>  // include to support color images
+#endif
 namespace Orthanc
 {
 static bool IsBinaryTag(const DcmTag& key)
 {
 return (key.isUnknownVR() ||
 default:
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
 }
+static bool SaveToMemoryBufferInternal(std::string& buffer,
+DcmFileFormat& dicom,
+E_TransferSyntax xfer)
+{
+E_EncodingType encodingType = /*opt_sequenceType*/ EET_ExplicitLength;
+// Create a memory buffer with the proper size
+{
+const uint32_t estimatedSize = dicom.calcElementLength(xfer, encodingType);  // (*)
+buffer.resize(estimatedSize);
+}
+DcmOutputBufferStream ob(&buffer[0], buffer.size());
+// Fill the memory buffer with the meta-header and the dataset
+dicom.transferInit();
+OFCondition c = dicom.write(ob, xfer, encodingType, NULL,
+/*opt_groupLength*/ EGL_recalcGL,
+/*opt_paddingType*/ EPD_noChange,
+/*padlen*/ 0, /*subPadlen*/ 0, /*instanceLength*/ 0,
+EWM_updateMeta /* creates new SOP instance UID on lossy */);
+dicom.transferEnd();
+if (c.good())
+{
+// The DICOM file is successfully written, truncate the target
+// buffer if its size was overestimated by (*)
+ob.flush();
+size_t effectiveSize = static_cast<size_t>(ob.tell());
+if (effectiveSize < buffer.size())
+{
+buffer.resize(effectiveSize);
+}
+return true;
+}
+else
+{
+// Error
+buffer.clear();
+return false;
+}
+}
 bool FromDcmtkBridge::SaveToMemoryBuffer(std::string& buffer,
 DcmDataset& dataSet)
 {
 // Determine the transfer syntax which shall be used to write the
-// information to the file. We always switch to the Little Endian
+// information to the file. If not possible, switch to the Little
-// syntax, with explicit length.
+// Endian syntax, with explicit length.
 // http://support.dcmtk.org/docs/dcxfer_8h-source.html
 /**
 * Note that up to Orthanc 0.7.1 (inclusive), the
 * "EXS_LittleEndianExplicit" was always used to save the DICOM
 * dataset into memory. We now keep the original transfer syntax
 * (if available).
 **/
-E_TransferSyntax xfer = dataSet.getOriginalXfer();
+E_TransferSyntax xfer = dataSet.getCurrentXfer();
 if (xfer == EXS_Unknown)
 {
 // No information about the original transfer syntax: This is
 // most probably a DICOM dataset that was read from memory.
 xfer = EXS_LittleEndianExplicit;
 }
-E_EncodingType encodingType = /*opt_sequenceType*/ EET_ExplicitLength;
 // Create the meta-header information
 DcmFileFormat ff(&dataSet);
 ff.validateMetaInfo(xfer);
 ff.removeInvalidGroups();
-// Create a memory buffer with the proper size
+return SaveToMemoryBufferInternal(buffer, ff, xfer);
-{
+}
-const uint32_t estimatedSize = ff.calcElementLength(xfer, encodingType);  // (*)
-buffer.resize(estimatedSize);
-}
+bool FromDcmtkBridge::Transcode(DcmFileFormat& dicom,
+DicomTransferSyntax syntax,
-DcmOutputBufferStream ob(&buffer[0], buffer.size());
+const DcmRepresentationParameter* representation)
+{
-// Fill the memory buffer with the meta-header and the dataset
+E_TransferSyntax xfer;
-ff.transferInit();
+if (!LookupDcmtkTransferSyntax(xfer, syntax))
-OFCondition c = ff.write(ob, xfer, encodingType, NULL,
+{
-/*opt_groupLength*/ EGL_recalcGL,
+throw OrthancException(ErrorCode_InternalError);
-/*opt_paddingType*/ EPD_withoutPadding);
-ff.transferEnd();
-if (c.good())
-{
-// The DICOM file is successfully written, truncate the target
-// buffer if its size was overestimated by (*)
-ob.flush();
-size_t effectiveSize = static_cast<size_t>(ob.tell());
-if (effectiveSize < buffer.size())
-{
-buffer.resize(effectiveSize);
-}
-return true;
 }
 else
 {
-// Error
+DicomTransferSyntax sourceSyntax;
-buffer.clear();
+bool known = LookupOrthancTransferSyntax(sourceSyntax, dicom);
-return false;
+if (!dicom.chooseRepresentation(xfer, representation).good() ||
+!dicom.canWriteXfer(xfer) ||
+!dicom.validateMetaInfo(xfer, EWM_updateMeta).good())
+{
+return false;
+}
+else
+{
+dicom.removeInvalidGroups();
+if (known)
+{
+LOG(INFO) << "Transcoded an image from transfer syntax "
+<< GetTransferSyntaxUid(sourceSyntax) << " to "
+<< GetTransferSyntaxUid(syntax);
+}
+else
+{
+LOG(INFO) << "Transcoded an image from unknown transfer syntax to "
+<< GetTransferSyntaxUid(syntax);
+}
+return true;
+}
 }
 }
 ValueRepresentation FromDcmtkBridge::LookupValueRepresentation(const DicomTag& tag)
 case Json::arrayValue:
 {
 DcmTag key(tag.GetGroup(), tag.GetElement());
 if (key.getEVR() != EVR_SQ)
 {
-throw OrthancException(ErrorCode_BadParameterType);
+throw OrthancException(ErrorCode_BadParameterType, "Bad Parameter type for tag " + tag.Format());
 }
 DcmSequenceOfItems* sequence = new DcmSequenceOfItems(key);
 element.reset(sequence);
 break;
 }
 default:
-throw OrthancException(ErrorCode_BadParameterType);
+throw OrthancException(ErrorCode_BadParameterType, "Bad Parameter type for tag " + tag.Format());
 }
 return element.release();
 }
 {
 throw OrthancException(ErrorCode_BadFileFormat);
 }
 DcmPixelData& pixelData = dynamic_cast<DcmPixelData&>(*element);
+E_TransferSyntax repType;
+const DcmRepresentationParameter *repParam = NULL;
+pixelData.getCurrentRepresentationKey(repType, repParam);
 DcmPixelSequence* pixelSequence = NULL;
-if (!pixelData.getEncapsulatedRepresentation
+if (!pixelData.getEncapsulatedRepresentation(repType, repParam, pixelSequence).good())
-(dataset.getOriginalXfer(), NULL, pixelSequence).good())
 {
 return NULL;
 }
 else
 {
 }
 }
 }
-bool FromDcmtkBridge::LookupTransferSyntax(std::string& result,
-DcmFileFormat& dicom)
-{
-const char* value = NULL;
-if (dicom.getMetaInfo() != NULL &&
-dicom.getMetaInfo()->findAndGetString(DCM_TransferSyntaxUID, value).good() &&
-value != NULL)
-{
-result.assign(value);
-return true;
-}
-else
-{
-return false;
-}
-}
 #if ORTHANC_ENABLE_LUA == 1
 void FromDcmtkBridge::ExecuteToDicom(DicomMap& target,
 LuaFunctionCall& call)
 {
 Json::Value output;
 DJDecoderRegistration::registerCodecs();
 # if ORTHANC_ENABLE_DCMTK_TRANSCODING == 1
 DJEncoderRegistration::registerCodecs();
 # endif
 #endif
+LOG(INFO) << "Registering RLE codecs in DCMTK";
+DcmRLEDecoderRegistration::registerCodecs();
+#if ORTHANC_ENABLE_DCMTK_TRANSCODING == 1
+DcmRLEEncoderRegistration::registerCodecs();
+#endif
 }
 void FromDcmtkBridge::FinalizeCodecs()
 {
 // Unregister JPEG codecs
 DJDecoderRegistration::cleanup();
 # if ORTHANC_ENABLE_DCMTK_TRANSCODING == 1
 DJEncoderRegistration::cleanup();
 # endif
+#endif
+DcmRLEDecoderRegistration::cleanup();
+#if ORTHANC_ENABLE_DCMTK_TRANSCODING == 1
+DcmRLEEncoderRegistration::cleanup();
 #endif
 }
 std::vector<size_t> parentIndexes;
 bool hasCodeExtensions;
 Encoding encoding = DetectEncoding(hasCodeExtensions, dataset, defaultEncoding);
 ApplyVisitorToDataset(dataset, visitor, parentTags, parentIndexes, encoding, hasCodeExtensions);
 }
+bool FromDcmtkBridge::LookupOrthancTransferSyntax(DicomTransferSyntax& target,
+DcmFileFormat& dicom)
+{
+if (dicom.getDataset() == NULL)
+{
+throw OrthancException(ErrorCode_InternalError);
+}
+DcmDataset& dataset = *dicom.getDataset();
+E_TransferSyntax xfer = dataset.getCurrentXfer();
+if (xfer == EXS_Unknown)
+{
+dataset.updateOriginalXfer();
+xfer = dataset.getOriginalXfer();
+if (xfer == EXS_Unknown)
+{
+throw OrthancException(ErrorCode_BadFileFormat,
+"Cannot determine the transfer syntax of the DICOM instance");
+}
+}
+return FromDcmtkBridge::LookupOrthancTransferSyntax(target, xfer);
+}
 }
 #include "./FromDcmtkBridge_TransferSyntaxes.impl.h"

Mercurial > hg > orthanc

comparison Core/DicomParsing/FromDcmtkBridge.cpp @ 3956:6e14f2da7c7e