# HG changeset patch # User Sebastien Jodogne # Date 1449674971 -3600 # Node ID cb86c0518d748d1fde380fd2ea4a0d60d16366a1 # Parent 4667d423579127b109467f63eccbd8d8ed0d830d transcoding is working diff -r 4667d4235791 -r cb86c0518d74 Plugin/Dicom.cpp --- a/Plugin/Dicom.cpp Wed Dec 09 11:57:44 2015 +0100 +++ b/Plugin/Dicom.cpp Wed Dec 09 16:29:31 2015 +0100 @@ -57,120 +57,6 @@ - void ParsedDicomFile::Setup(const std::string& dicom) - { - // Prepare a memory stream over the DICOM instance - std::stringstream stream(dicom); - - // Parse the DICOM instance using GDCM - reader_.SetStream(stream); - if (!reader_.Read()) - { - /* "GDCM cannot read this DICOM instance of length " + - boost::lexical_cast(dicom.size()) */ - throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); - } - } - - - ParsedDicomFile::ParsedDicomFile(const OrthancPlugins::MultipartItem& item) - { - std::string dicom(item.data_, item.data_ + item.size_); - Setup(dicom); - } - - - static bool GetTag(std::string& result, - const gdcm::DataSet& dataset, - const gdcm::Tag& tag, - bool stripSpaces) - { - if (dataset.FindDataElement(tag)) - { - const gdcm::ByteValue* value = dataset.GetDataElement(tag).GetByteValue(); - if (value) - { - result = std::string(value->GetPointer(), value->GetLength()); - - if (stripSpaces) - { - result = Orthanc::Toolbox::StripSpaces(result); - } - - return true; - } - } - - return false; - } - - - static std::string GetTagWithDefault(const gdcm::DataSet& dataset, - const gdcm::Tag& tag, - const std::string& defaultValue, - bool stripSpaces) - { - std::string result; - if (!GetTag(result, dataset, tag, false)) - { - result = defaultValue; - } - - if (stripSpaces) - { - result = Orthanc::Toolbox::StripSpaces(result); - } - - return result; - } - - - bool ParsedDicomFile::GetTag(std::string& result, - const gdcm::Tag& tag, - bool stripSpaces) const - { - return OrthancPlugins::GetTag(result, GetDataSet(), tag, stripSpaces); - } - - - std::string ParsedDicomFile::GetTagWithDefault(const gdcm::Tag& tag, - const std::string& defaultValue, - bool stripSpaces) const - { - return OrthancPlugins::GetTagWithDefault(GetDataSet(), tag, defaultValue, stripSpaces); - } - - - static std::string FormatTag(const gdcm::Tag& tag) - { - char tmp[16]; - sprintf(tmp, "%04X%04X", tag.GetGroup(), tag.GetElement()); - return std::string(tmp); - } - - - static const char* GetKeyword(const gdcm::Dict& dictionary, - const gdcm::Tag& tag) - { - const gdcm::DictEntry &entry = dictionary.GetDictEntry(tag); - const char* keyword = entry.GetKeyword(); - - if (strlen(keyword) != 0) - { - return keyword; - } - - if (tag == DICOM_TAG_RETRIEVE_URL) - { - return "RetrieveURL"; - } - - //throw Orthanc::OrthancException("Unknown keyword for tag: " + FormatTag(tag)); - return NULL; - } - - - static const char* GetVRName(bool& isSequence, const gdcm::Dict& dictionary, const gdcm::DataElement& element) @@ -209,6 +95,206 @@ } + + static bool ConvertDicomStringToUtf8(std::string& result, + const gdcm::Dict& dictionary, + const gdcm::File* file, + const gdcm::DataElement& element, + const Orthanc::Encoding sourceEncoding) + { + const gdcm::ByteValue* data = element.GetByteValue(); + if (!data) + { + return false; + } + + if (file != NULL) + { + bool isSequence; + std::string vr = GetVRName(isSequence, dictionary, element); + if (!isSequence && ( + vr == "FL" || + vr == "FD" || + vr == "SL" || + vr == "SS" || + vr == "UL" || + vr == "US" + )) + { + gdcm::StringFilter f; + f.SetFile(*file); + result = f.ToString(element.GetTag()); + return true; + } + } + + if (sourceEncoding == Orthanc::Encoding_Utf8) + { + result.assign(data->GetPointer(), data->GetLength()); + } + else + { + std::string tmp(data->GetPointer(), data->GetLength()); + result = Orthanc::Toolbox::ConvertToUtf8(tmp, sourceEncoding); + } + + result = Orthanc::Toolbox::StripSpaces(result); + return true; + } + + + + void ParsedDicomFile::Setup(const std::string& dicom) + { + // Prepare a memory stream over the DICOM instance + std::stringstream stream(dicom); + + // Parse the DICOM instance using GDCM + reader_.SetStream(stream); + if (!reader_.Read()) + { + /* "GDCM cannot read this DICOM instance of length " + + boost::lexical_cast(dicom.size()) */ + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + } + + + ParsedDicomFile::ParsedDicomFile(const OrthancPlugins::MultipartItem& item) + { + std::string dicom(item.data_, item.data_ + item.size_); + Setup(dicom); + } + + + static bool GetRawTag(std::string& result, + const gdcm::DataSet& dataset, + const gdcm::Tag& tag, + bool stripSpaces) + { + if (dataset.FindDataElement(tag)) + { + const gdcm::ByteValue* value = dataset.GetDataElement(tag).GetByteValue(); + if (value) + { + result.assign(value->GetPointer(), value->GetLength()); + + if (stripSpaces) + { + result = Orthanc::Toolbox::StripSpaces(result); + } + + return true; + } + } + + return false; + } + + + bool ParsedDicomFile::GetRawTag(std::string& result, + const gdcm::Tag& tag, + bool stripSpaces) const + { + return OrthancPlugins::GetRawTag(result, GetDataSet(), tag, stripSpaces); + } + + + std::string ParsedDicomFile::GetRawTagWithDefault(const gdcm::Tag& tag, + const std::string& defaultValue, + bool stripSpaces) const + { + std::string result; + if (!GetRawTag(result, tag, stripSpaces)) + { + return defaultValue; + } + else + { + return result; + } + } + + + bool ParsedDicomFile::GetStringTag(std::string& result, + const gdcm::Dict& dictionary, + const gdcm::Tag& tag, + bool stripSpaces) const + { + if (!GetDataSet().FindDataElement(tag)) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InexistentTag); + } + + const gdcm::DataElement& element = GetDataSet().GetDataElement(tag); + + if (!ConvertDicomStringToUtf8(result, dictionary, &GetFile(), element, GetEncoding())) + { + return false; + } + + if (stripSpaces) + { + result = Orthanc::Toolbox::StripSpaces(result); + } + + return true; + } + + + bool ParsedDicomFile::GetIntegerTag(int& result, + const gdcm::Dict& dictionary, + const gdcm::Tag& tag) const + { + std::string tmp; + if (!GetStringTag(tmp, dictionary, tag, true)) + { + return false; + } + + try + { + result = boost::lexical_cast(tmp); + return true; + } + catch (boost::bad_lexical_cast&) + { + return false; + } + } + + + + static std::string FormatTag(const gdcm::Tag& tag) + { + char tmp[16]; + sprintf(tmp, "%04X%04X", tag.GetGroup(), tag.GetElement()); + return std::string(tmp); + } + + + static const char* GetKeyword(const gdcm::Dict& dictionary, + const gdcm::Tag& tag) + { + const gdcm::DictEntry &entry = dictionary.GetDictEntry(tag); + const char* keyword = entry.GetKeyword(); + + if (strlen(keyword) != 0) + { + return keyword; + } + + if (tag == DICOM_TAG_RETRIEVE_URL) + { + return "RetrieveURL"; + } + + //throw Orthanc::OrthancException("Unknown keyword for tag: " + FormatTag(tag)); + return NULL; + } + + + static bool IsBulkData(const std::string& vr) { /** @@ -239,9 +325,9 @@ { std::string study, series, instance; - if (!GetTag(study, dicom, DICOM_TAG_STUDY_INSTANCE_UID, true) || - !GetTag(series, dicom, DICOM_TAG_SERIES_INSTANCE_UID, true) || - !GetTag(instance, dicom, DICOM_TAG_SOP_INSTANCE_UID, true)) + if (!GetRawTag(study, dicom, DICOM_TAG_STUDY_INSTANCE_UID, true) || + !GetRawTag(series, dicom, DICOM_TAG_SERIES_INSTANCE_UID, true) || + !GetRawTag(instance, dicom, DICOM_TAG_SOP_INSTANCE_UID, true)) { return ""; } @@ -285,51 +371,11 @@ } - static bool ConvertDicomStringToUf8(std::string& result, - const gdcm::Dict& dictionary, - const gdcm::File* file, - const gdcm::DataElement& element, - const Orthanc::Encoding sourceEncoding) + Orthanc::Encoding ParsedDicomFile::GetEncoding() const { - const gdcm::ByteValue* data = element.GetByteValue(); - if (!data) - { - return false; - } - - if (file != NULL) - { - bool isSequence; - std::string vr = GetVRName(isSequence, dictionary, element); - if (!isSequence && ( - vr == "FL" || - vr == "FD" || - vr == "SL" || - vr == "SS" || - vr == "UL" || - vr == "US" - )) - { - gdcm::StringFilter f; - f.SetFile(*file); - result = f.ToString(element.GetTag()); - return true; - } - } - - if (sourceEncoding == Orthanc::Encoding_Utf8) - { - result.assign(data->GetPointer(), data->GetLength()); - } - else - { - std::string tmp(data->GetPointer(), data->GetLength()); - result = Orthanc::Toolbox::ConvertToUtf8(tmp, sourceEncoding); - } - - result = Orthanc::Toolbox::StripSpaces(result); - return true; + return DetectEncoding(GetDataSet()); } + static void DicomToXmlInternal(pugi::xml_node& target, @@ -406,7 +452,7 @@ value.append_attribute("number").set_value("1"); std::string tmp; - if (ConvertDicomStringToUf8(tmp, dictionary, file, *it, sourceEncoding)) + if (ConvertDicomStringToUtf8(tmp, dictionary, file, *it, sourceEncoding)) { value.append_child(pugi::node_pcdata).set_value(tmp.c_str()); } @@ -504,7 +550,7 @@ node["Value"] = Json::arrayValue; std::string value; - if (ConvertDicomStringToUf8(value, dictionary, file, *it, sourceEncoding)) + if (ConvertDicomStringToUtf8(value, dictionary, file, *it, sourceEncoding)) { node["Value"].append(value.c_str()); } diff -r 4667d4235791 -r cb86c0518d74 Plugin/Dicom.h --- a/Plugin/Dicom.h Wed Dec 09 11:57:44 2015 +0100 +++ b/Plugin/Dicom.h Wed Dec 09 16:29:31 2015 +0100 @@ -22,6 +22,8 @@ #include "Configuration.h" +#include "../Orthanc/Core/Enumerations.h" + #include #include #include @@ -45,6 +47,9 @@ static const gdcm::Tag DICOM_TAG_ACCESSION_NUMBER(0x0008, 0x0050); static const gdcm::Tag DICOM_TAG_SPECIFIC_CHARACTER_SET(0x0008, 0x0005); static const gdcm::Tag DICOM_TAG_PIXEL_DATA(0x7fe0, 0x0010); + static const gdcm::Tag DICOM_TAG_COLUMNS(0x0028, 0x0011); + static const gdcm::Tag DICOM_TAG_ROWS(0x0028, 0x0010); + static const gdcm::Tag DICOM_TAG_BITS_ALLOCATED(0x0028, 0x0100); class ParsedDicomFile { @@ -71,13 +76,24 @@ return reader_.GetFile().GetDataSet(); } - bool GetTag(std::string& result, - const gdcm::Tag& tag, - bool stripSpaces) const; + bool GetRawTag(std::string& result, + const gdcm::Tag& tag, + bool stripSpaces) const; + + std::string GetRawTagWithDefault(const gdcm::Tag& tag, + const std::string& defaultValue, + bool stripSpaces) const; - std::string GetTagWithDefault(const gdcm::Tag& tag, - const std::string& defaultValue, - bool stripSpaces) const; + bool GetStringTag(std::string& result, + const gdcm::Dict& dictionary, + const gdcm::Tag& tag, + bool stripSpaces) const; + + bool GetIntegerTag(int& result, + const gdcm::Dict& dictionary, + const gdcm::Tag& tag) const; + + Orthanc::Encoding GetEncoding() const; }; diff -r 4667d4235791 -r cb86c0518d74 Plugin/QidoRs.cpp --- a/Plugin/QidoRs.cpp Wed Dec 09 11:57:44 2015 +0100 +++ b/Plugin/QidoRs.cpp Wed Dec 09 16:29:31 2015 +0100 @@ -376,16 +376,16 @@ // Set the retrieve URL for WADO-RS std::string url = (wadoBase + "studies/" + - dicom.GetTagWithDefault(OrthancPlugins::DICOM_TAG_STUDY_INSTANCE_UID, "", true)); + dicom.GetRawTagWithDefault(OrthancPlugins::DICOM_TAG_STUDY_INSTANCE_UID, "", true)); if (level == QueryLevel_Series || level == QueryLevel_Instance) { - url += "/series/" + dicom.GetTagWithDefault(OrthancPlugins::DICOM_TAG_SERIES_INSTANCE_UID, "", true); + url += "/series/" + dicom.GetRawTagWithDefault(OrthancPlugins::DICOM_TAG_SERIES_INSTANCE_UID, "", true); } if (level == QueryLevel_Instance) { - url += "/instances/" + dicom.GetTagWithDefault(OrthancPlugins::DICOM_TAG_SOP_INSTANCE_UID, "", true); + url += "/instances/" + dicom.GetRawTagWithDefault(OrthancPlugins::DICOM_TAG_SOP_INSTANCE_UID, "", true); } gdcm::DataElement element(OrthancPlugins::DICOM_TAG_RETRIEVE_URL); diff -r 4667d4235791 -r cb86c0518d74 Plugin/StowRs.cpp --- a/Plugin/StowRs.cpp Wed Dec 09 11:57:44 2015 +0100 +++ b/Plugin/StowRs.cpp Wed Dec 09 16:29:31 2015 +0100 @@ -169,9 +169,9 @@ OrthancPlugins::ParsedDicomFile dicom(items[i]); - std::string studyInstanceUid = dicom.GetTagWithDefault(OrthancPlugins::DICOM_TAG_STUDY_INSTANCE_UID, "", true); - std::string sopClassUid = dicom.GetTagWithDefault(OrthancPlugins::DICOM_TAG_SOP_CLASS_UID, "", true); - std::string sopInstanceUid = dicom.GetTagWithDefault(OrthancPlugins::DICOM_TAG_SOP_INSTANCE_UID, "", true); + std::string studyInstanceUid = dicom.GetRawTagWithDefault(OrthancPlugins::DICOM_TAG_STUDY_INSTANCE_UID, "", true); + std::string sopClassUid = dicom.GetRawTagWithDefault(OrthancPlugins::DICOM_TAG_SOP_CLASS_UID, "", true); + std::string sopInstanceUid = dicom.GetRawTagWithDefault(OrthancPlugins::DICOM_TAG_SOP_INSTANCE_UID, "", true); gdcm::Item item; item.SetVLToUndefined(); @@ -207,7 +207,7 @@ { std::string url = (wadoBase + "studies/" + studyInstanceUid + - "/series/" + dicom.GetTagWithDefault(OrthancPlugins::DICOM_TAG_SERIES_INSTANCE_UID, "", true) + + "/series/" + dicom.GetRawTagWithDefault(OrthancPlugins::DICOM_TAG_SERIES_INSTANCE_UID, "", true) + "/instances/" + sopInstanceUid); SetTag(status, OrthancPlugins::DICOM_TAG_RETRIEVE_URL, gdcm::VR::UT, url); diff -r 4667d4235791 -r cb86c0518d74 Plugin/WadoRs.cpp --- a/Plugin/WadoRs.cpp Wed Dec 09 11:57:44 2015 +0100 +++ b/Plugin/WadoRs.cpp Wed Dec 09 16:29:31 2015 +0100 @@ -797,36 +797,160 @@ for (size_t i = 0; i < tokens.size(); i++) { - frames.push_back(boost::lexical_cast(tokens[i])); + int frame = boost::lexical_cast(tokens[i]); + if (frame <= 0) + { + std::string s = "Invalid frame number (must be > 0): " + tokens[i]; + OrthancPluginLogError(context_, s.c_str()); + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + frames.push_back(static_cast(frame - 1)); } } +static const char* GetMimeType(const gdcm::TransferSyntax& syntax) +{ + switch (syntax) + { + case gdcm::TransferSyntax::ImplicitVRLittleEndian: + return "application/octet-stream"; + + case gdcm::TransferSyntax::JPEGBaselineProcess1: + return "image/dicom+jpeg; transfer-syntax=1.2.840.10008.1.2.4.50"; + + case gdcm::TransferSyntax::JPEGExtendedProcess2_4: + return "image/dicom+jpeg; transfer-syntax=1.2.840.10008.1.2.4.51"; + + case gdcm::TransferSyntax::JPEGLosslessProcess14: + return "image/dicom+jpeg; transfer-syntax=1.2.840.10008.1.2.4.57"; + + case gdcm::TransferSyntax::JPEGLosslessProcess14_1: + return "image/dicom+jpeg; transferSyntax=1.2.840.10008.1.2.4.70"; + + case gdcm::TransferSyntax::RLELossless: + return "image/dicom+rle; transferSyntax=1.2.840.10008.1.2.5"; + + case gdcm::TransferSyntax::JPEGLSLossless: + return "image/dicom+jpeg-ls; transferSyntax=1.2.840.10008.1.2.4.80"; + + case gdcm::TransferSyntax::JPEGLSNearLossless: + return "image/dicom+jpeg-ls; transfer-syntax=1.2.840.10008.1.2.4.81"; + + case gdcm::TransferSyntax::JPEG2000Lossless: + return "image/dicom+jp2; transferSyntax=1.2.840.10008.1.2.4.90"; + + case gdcm::TransferSyntax::JPEG2000: + return "image/dicom+jp2; transfer-syntax=1.2.840.10008.1.2.4.91"; + + case gdcm::TransferSyntax::JPEG2000Part2Lossless: + return "image/dicom+jpx; transferSyntax=1.2.840.10008.1.2.4.92"; + + case gdcm::TransferSyntax::JPEG2000Part2: + return "image/dicom+jpx; transfer-syntax=1.2.840.10008.1.2.4.93"; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } +} + + static bool AnswerFrames(OrthancPluginRestOutput* output, - const gdcm::DataSet& dicom, + const OrthancPlugins::ParsedDicomFile& dicom, + const gdcm::TransferSyntax& syntax, const std::list& frames) { - if (!dicom.FindDataElement(OrthancPlugins::DICOM_TAG_PIXEL_DATA)) + if (!dicom.GetDataSet().FindDataElement(OrthancPlugins::DICOM_TAG_PIXEL_DATA)) { return OrthancPluginErrorCode_IncompatibleImageFormat; } - const gdcm::DataElement& pixelData = dicom.GetDataElement(OrthancPlugins::DICOM_TAG_PIXEL_DATA); + const gdcm::DataElement& pixelData = dicom.GetDataSet().GetDataElement(OrthancPlugins::DICOM_TAG_PIXEL_DATA); const gdcm::SequenceOfFragments* fragments = pixelData.GetSequenceOfFragments(); + if (OrthancPluginStartMultipartAnswer(context_, output, "related", GetMimeType(syntax)) != OrthancPluginErrorCode_Success) + { + return false; + } + if (fragments == NULL) { - printf("Single-frame image\n"); - printf("%d\n", pixelData.GetByteValue()->GetLength()); + // Single-fragment image + + if (pixelData.GetByteValue() == NULL) + { + OrthancPluginLogError(context_, "Image was not properly decoded"); + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + int width, height, bits; + + if (!dicom.GetIntegerTag(height, *dictionary_, OrthancPlugins::DICOM_TAG_ROWS) || + !dicom.GetIntegerTag(width, *dictionary_, OrthancPlugins::DICOM_TAG_COLUMNS) || + !dicom.GetIntegerTag(bits, *dictionary_, OrthancPlugins::DICOM_TAG_BITS_ALLOCATED)) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + + size_t frameSize = height * width * bits / 8; + + if (pixelData.GetByteValue()->GetLength() % frameSize != 0) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + size_t framesCount = pixelData.GetByteValue()->GetLength() / frameSize; + const char* buffer = pixelData.GetByteValue()->GetPointer(); + assert(sizeof(char) == 1); + + for (std::list::const_iterator + frame = frames.begin(); frame != frames.end(); ++frame) + { + if (*frame >= framesCount) + { + std::string s = ("Trying to access frame number " + boost::lexical_cast(*frame + 1) + + " of an image with " + boost::lexical_cast(framesCount) + " frames"); + OrthancPluginLogError(context_, s.c_str()); + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + else + { + const char* p = buffer + (*frame) * frameSize; + + // TODO SET Content-Location + if (OrthancPluginSendMultipartItem(context_, output, p, frameSize) != OrthancPluginErrorCode_Success) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol); + } + } + } } else { - printf("Multi-frame image (%d fragments)\n", fragments->GetNumberOfFragments()); + // Multi-fragment image, we assume that each fragment corresponds to one frame - for (gdcm::SequenceOfFragments::SizeType i = 0; i < fragments->GetNumberOfFragments(); i++) + for (std::list::const_iterator + frame = frames.begin(); frame != frames.end(); ++frame) { - printf("%d: %d\n", i, fragments->GetFragment(i).GetByteValue()->GetLength()); + if (*frame >= fragments->GetNumberOfFragments()) + { + std::string s = ("Trying to access frame number " + boost::lexical_cast(*frame + 1) + + " of an image with " + boost::lexical_cast(fragments->GetNumberOfFragments()) + " frames"); + OrthancPluginLogError(context_, s.c_str()); + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + else + { + // TODO SET Content-Location + if (OrthancPluginSendMultipartItem(context_, output, + fragments->GetFragment(*frame).GetByteValue()->GetPointer(), + fragments->GetFragment(*frame).GetByteValue()->GetLength()) != OrthancPluginErrorCode_Success) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol); + } + } } } @@ -840,8 +964,8 @@ { // storescu -xs localhost 4242 ~/Subversion/orthanc-tests/Database/Multiframe.dcm - // curl http://localhost:8042/dicom-web/studies/1.3.51.0.1.1.192.168.29.133.1681753.1681732/series/1.3.12.2.1107.5.2.33.37097.2012041612474981424569674.0.0.0/instances/1.3.12.2.1107.5.2.33.37097.2012041612485517294169680/frames/0 - // curl http://localhost:8042/dicom-web/studies/1.3.46.670589.7.5.8.80001255161.20000323.151537.1/series/1.3.46.670589.7.5.7.80001255161.20000323.151537.1/instances/1.3.46.670589.7.5.1.981501.20000323.16172540.1.1.13/frames/0 + // curl http://localhost:8042/dicom-web/studies/1.3.51.0.1.1.192.168.29.133.1681753.1681732/series/1.3.12.2.1107.5.2.33.37097.2012041612474981424569674.0.0.0/instances/1.3.12.2.1107.5.2.33.37097.2012041612485517294169680/frames/1 + // curl http://localhost:8042/dicom-web/studies/1.3.46.670589.7.5.8.80001255161.20000323.151537.1/series/1.3.46.670589.7.5.7.80001255161.20000323.151537.1/instances/1.3.46.670589.7.5.1.981501.20000323.16172540.1.1.13/frames/1 // http://gdcm.sourceforge.net/html/CompressLossyJPEG_8cs-example.html @@ -859,9 +983,10 @@ { { std::string s = "DICOMweb RetrieveFrames on " + uri + ", frames: "; - for (std::list::const_iterator it = frames.begin(); it != frames.end(); ++it) + for (std::list::const_iterator + frame = frames.begin(); frame != frames.end(); ++frame) { - s += boost::lexical_cast(*it) + " "; + s += boost::lexical_cast(*frame + 1) + " "; } OrthancPluginLogInfo(context_, s.c_str()); } @@ -892,7 +1017,7 @@ source.reset(new OrthancPlugins::ParsedDicomFile(content)); } - AnswerFrames(output, source->GetFile().GetDataSet(), frames); + AnswerFrames(output, *source, targetSyntax, frames); } else { @@ -905,25 +1030,24 @@ } gdcm::ImageChangeTransferSyntax change; - change.SetTransferSyntax(gdcm::TransferSyntax::JPEG2000Lossless); - - gdcm::JPEG2000Codec codec; - if (!codec.CanCode(change.GetTransferSyntax())) - { - return OrthancPluginErrorCode_Plugin; - } - - //codec.SetLossless(true); - change.SetUserCodec(&codec); + change.SetTransferSyntax(targetSyntax); std::stringstream stream(content); gdcm::ImageReader reader; reader.SetStream(stream); - printf("Read: %d\n", reader.Read()); + if (!reader.Read()) + { + OrthancPluginLogError(context_, "Cannot decode the image"); + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } change.SetInput(reader.GetImage()); - printf("Change: %d\n", change.Change()); + if (!change.Change()) + { + OrthancPluginLogError(context_, "Cannot change the transfer syntax of the image"); + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } gdcm::ImageWriter writer; writer.SetImage(change.GetOutput()); @@ -931,13 +1055,13 @@ std::stringstream ss; writer.SetStream(ss); - printf("Write: %d\n", writer.Write()); + if (!writer.Write()) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotEnoughMemory); + } - gdcm::Reader reader2; - reader2.SetStream(ss); - printf("Read: %d\n", reader2.Read()); - - AnswerFrames(output, reader2.GetFile().GetDataSet(), frames); + OrthancPlugins::ParsedDicomFile transcoded(ss.str()); + AnswerFrames(output, transcoded, targetSyntax, frames); } }