# HG changeset patch # User Sebastien Jodogne # Date 1729626754 -7200 # Node ID 2410a171ebfb356444bdcbd448270596af59f66d # Parent 239fb2c893c183da0e15dcb8a32d4d4270c57e75 refactoring using DicomWebDataset and OrthancNativeDataset diff -r 239fb2c893c1 -r 2410a171ebfb OrthancStone/Resources/CMake/OrthancStoneConfiguration.cmake --- a/OrthancStone/Resources/CMake/OrthancStoneConfiguration.cmake Tue Oct 22 15:41:38 2024 +0200 +++ b/OrthancStone/Resources/CMake/OrthancStoneConfiguration.cmake Tue Oct 22 21:52:34 2024 +0200 @@ -226,8 +226,10 @@ list(APPEND ORTHANC_STONE_SOURCES ${ORTHANC_STONE_ROOT}/Toolbox/OrthancDatasets/DicomDatasetReader.cpp + ${ORTHANC_STONE_ROOT}/Toolbox/OrthancDatasets/DicomWebDataset.cpp ${ORTHANC_STONE_ROOT}/Toolbox/OrthancDatasets/FullOrthancDataset.cpp ${ORTHANC_STONE_ROOT}/Toolbox/OrthancDatasets/IOrthancConnection.cpp + ${ORTHANC_STONE_ROOT}/Toolbox/OrthancDatasets/OrthancNativeDataset.cpp ${ORTHANC_STONE_ROOT}/Fonts/FontRenderer.cpp ${ORTHANC_STONE_ROOT}/Fonts/Glyph.cpp diff -r 239fb2c893c1 -r 2410a171ebfb OrthancStone/Sources/Toolbox/DicomInstanceParameters.cpp --- a/OrthancStone/Sources/Toolbox/DicomInstanceParameters.cpp Tue Oct 22 15:41:38 2024 +0200 +++ b/OrthancStone/Sources/Toolbox/DicomInstanceParameters.cpp Tue Oct 22 21:52:34 2024 +0200 @@ -27,6 +27,9 @@ #include "../Scene2D/FloatTextureSceneLayer.h" #include "GeometryToolbox.h" #include "ImageToolbox.h" +#include "OrthancDatasets/DicomDatasetReader.h" +#include "OrthancDatasets/DicomWebDataset.h" +#include "OrthancDatasets/OrthancNativeDataset.h" #include #include @@ -231,68 +234,103 @@ { instanceNumber_ = 0; } + } + void DicomInstanceParameters::InjectSequenceTags(const IDicomDataset& dataset) + { + /** + * Use DICOM tag "SequenceOfUltrasoundRegions" (0018,6011) in + * order to derive the pixel spacing on ultrasound (US) images + **/ + + static const Orthanc::DicomTag DICOM_TAG_SEQUENCE_OF_ULTRASOUND_REGIONS(0x0018, 0x6011); + static const Orthanc::DicomTag DICOM_TAG_PHYSICAL_UNITS_X_DIRECTION(0x0018, 0x6024); + static const Orthanc::DicomTag DICOM_TAG_PHYSICAL_UNITS_Y_DIRECTION(0x0018, 0x6026); + static const Orthanc::DicomTag DICOM_TAG_PHYSICAL_DELTA_X(0x0018, 0x602c); + static const Orthanc::DicomTag DICOM_TAG_PHYSICAL_DELTA_Y(0x0018, 0x602e); + + DicomDatasetReader reader(dataset); + + size_t size; + + if (!data_.hasPixelSpacing_ && + dataset.GetSequenceSize(size, Orthanc::DicomPath(DICOM_TAG_SEQUENCE_OF_ULTRASOUND_REGIONS)) && + size == 1) + { + int directionX, directionY; + double deltaX, deltaY; + + if (reader.GetIntegerValue(directionX, Orthanc::DicomPath(DICOM_TAG_SEQUENCE_OF_ULTRASOUND_REGIONS, + 0, DICOM_TAG_PHYSICAL_UNITS_X_DIRECTION)) && + reader.GetIntegerValue(directionY, Orthanc::DicomPath(DICOM_TAG_SEQUENCE_OF_ULTRASOUND_REGIONS, + 0, DICOM_TAG_PHYSICAL_UNITS_Y_DIRECTION)) && + reader.GetDoubleValue(deltaX, Orthanc::DicomPath(DICOM_TAG_SEQUENCE_OF_ULTRASOUND_REGIONS, + 0, DICOM_TAG_PHYSICAL_DELTA_X)) && + reader.GetDoubleValue(deltaY, Orthanc::DicomPath(DICOM_TAG_SEQUENCE_OF_ULTRASOUND_REGIONS, + 0, DICOM_TAG_PHYSICAL_DELTA_Y)) && + directionX == 0x0003 && // Centimeters + directionY == 0x0003) // Centimeters + { + // Scene coordinates are expressed in millimeters => multiplication by 10 + SetPixelSpacing(10.0 * deltaX, 10.0 * deltaY); + } + } + + + /** + * New in Stone Web viewer 2.2: Deal with Philips multiframe + * (cf. mail from Tomas Kenda on 2021-08-17). This cannot be done + * in LoadSeriesDetailsFromInstance, as the "Per Frame Functional + * Groups Sequence" is not available at that point. + **/ + static const Orthanc::DicomTag DICOM_TAG_PER_FRAME_FUNCTIONAL_GROUPS_SEQUENCE(0x5200, 0x9230); static const Orthanc::DicomTag DICOM_TAG_FRAME_VOI_LUT_SEQUENCE_ATTRIBUTE(0x0028, 0x9132); - const Orthanc::DicomValue* frames = dicom.TestAndGetValue(DICOM_TAG_PER_FRAME_FUNCTIONAL_GROUPS_SEQUENCE); - if (frames != NULL && - hasNumberOfFrames_ && - frames->IsSequence()) + if (dataset.GetSequenceSize(size, Orthanc::DicomPath(DICOM_TAG_PER_FRAME_FUNCTIONAL_GROUPS_SEQUENCE))) { - /** - * New in Stone Web viewer 2.2: Deal with Philips multiframe - * (cf. mail from Tomas Kenda on 2021-08-17). This cannot be done - * in LoadSeriesDetailsFromInstance, as the "Per Frame Functional Groups Sequence" - * is not available at that point. - **/ - - const Json::Value& sequence = frames->GetSequenceContent(); - - perFrameWindowing_.resize(numberOfFrames_); + data_.perFrameWindowing_.resize(data_.numberOfFrames_); // This corresponds to "ParsedDicomFile::GetDefaultWindowing()" - for (Json::ArrayIndex i = 0; i < sequence.size(); i++) + for (size_t i = 0; i < size; i++) { - if (i < numberOfFrames_ && - sequence[i].isMember(DICOM_TAG_FRAME_VOI_LUT_SEQUENCE_ATTRIBUTE.Format())) - { - const Json::Value& v = sequence[i][DICOM_TAG_FRAME_VOI_LUT_SEQUENCE_ATTRIBUTE.Format()]; - - static const char* KEY_VALUE = "Value"; + size_t tmp; + double center, width; - if (v.isMember(KEY_VALUE) && - v[KEY_VALUE].type() == Json::arrayValue && - v[KEY_VALUE].size() >= 1 && - v[KEY_VALUE][0].isMember(Orthanc::DICOM_TAG_WINDOW_CENTER.Format()) && - v[KEY_VALUE][0].isMember(Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()) && - v[KEY_VALUE][0][Orthanc::DICOM_TAG_WINDOW_CENTER.Format()].isMember(KEY_VALUE) && - v[KEY_VALUE][0][Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()].isMember(KEY_VALUE)) - { - const Json::Value& scenter = v[KEY_VALUE][0][Orthanc::DICOM_TAG_WINDOW_CENTER.Format()][KEY_VALUE]; - const Json::Value& swidth = v[KEY_VALUE][0][Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()][KEY_VALUE]; - - double center, width; - if (scenter.isString() && - swidth.isString() && - Orthanc::SerializationToolbox::ParseDouble(center, scenter.asString()) && - Orthanc::SerializationToolbox::ParseDouble(width, swidth.asString())) - { - perFrameWindowing_[i] = Windowing(center, width); - } - else if (scenter.isNumeric() && - swidth.isNumeric()) - { - perFrameWindowing_[i] = Windowing(scenter.asDouble(), swidth.asDouble()); - } - } + if (dataset.GetSequenceSize(tmp, Orthanc::DicomPath(DICOM_TAG_PER_FRAME_FUNCTIONAL_GROUPS_SEQUENCE, i, + DICOM_TAG_FRAME_VOI_LUT_SEQUENCE_ATTRIBUTE)) && + tmp == 1 && + reader.GetDoubleValue(center, Orthanc::DicomPath(DICOM_TAG_PER_FRAME_FUNCTIONAL_GROUPS_SEQUENCE, i, + DICOM_TAG_FRAME_VOI_LUT_SEQUENCE_ATTRIBUTE, 0, + Orthanc::DICOM_TAG_WINDOW_CENTER)) && + reader.GetDoubleValue(width, Orthanc::DicomPath(DICOM_TAG_PER_FRAME_FUNCTIONAL_GROUPS_SEQUENCE, i, + DICOM_TAG_FRAME_VOI_LUT_SEQUENCE_ATTRIBUTE, 0, + Orthanc::DICOM_TAG_WINDOW_WIDTH))) + { + data_.perFrameWindowing_[i] = Windowing(center, width); } } } } + DicomInstanceParameters::DicomInstanceParameters(const DicomInstanceParameters& other) : + data_(other.data_), + tags_(other.tags_->Clone()) + { + } + + + DicomInstanceParameters::DicomInstanceParameters(const Orthanc::DicomMap& dicom) : + data_(dicom), + tags_(dicom.Clone()) + { + OrthancNativeDataset dataset(dicom); + InjectSequenceTags(dataset); + } + + double DicomInstanceParameters::GetSliceThickness() const { if (data_.hasSliceThickness_) @@ -814,38 +852,8 @@ void DicomInstanceParameters::EnrichUsingDicomWeb(const Json::Value& dicomweb) { - /** - * Use DICOM tag "SequenceOfUltrasoundRegions" (0018,6011) in - * order to derive the pixel spacing on ultrasound (US) images - **/ - - if (!data_.hasPixelSpacing_) - { - const Json::Value* region = LookupDicomWebSingleValue(dicomweb, "00186011", "SQ"); - if (region != NULL) - { - const Json::Value* physicalUnitsXDirection = LookupDicomWebSingleValue(*region, "00186024", "US"); - const Json::Value* physicalUnitsYDirection = LookupDicomWebSingleValue(*region, "00186026", "US"); - const Json::Value* physicalDeltaX = LookupDicomWebSingleValue(*region, "0018602C", "FD"); - const Json::Value* physicalDeltaY = LookupDicomWebSingleValue(*region, "0018602E", "FD"); - - if (physicalUnitsXDirection != NULL && - physicalUnitsYDirection != NULL && - physicalDeltaX != NULL && - physicalDeltaY != NULL && - physicalUnitsXDirection->type() == Json::intValue && - physicalUnitsYDirection->type() == Json::intValue && - physicalUnitsXDirection->asInt() == 0x0003 && // Centimeters - physicalUnitsYDirection->asInt() == 0x0003 && // Centimeters - physicalDeltaX->isNumeric() && - physicalDeltaY->isNumeric()) - { - // Scene coordinates are expressed in millimeters => multiplication by 10 - SetPixelSpacing(10.0 * physicalDeltaX->asDouble(), - 10.0 * physicalDeltaY->asDouble()); - } - } - } + DicomWebDataset dataset(dicomweb); + InjectSequenceTags(dataset); } diff -r 239fb2c893c1 -r 2410a171ebfb OrthancStone/Sources/Toolbox/DicomInstanceParameters.h --- a/OrthancStone/Sources/Toolbox/DicomInstanceParameters.h Tue Oct 22 15:41:38 2024 +0200 +++ b/OrthancStone/Sources/Toolbox/DicomInstanceParameters.h Tue Oct 22 21:52:34 2024 +0200 @@ -77,18 +77,12 @@ std::unique_ptr tags_; std::unique_ptr imageInformation_; // Lazy evaluation + void InjectSequenceTags(const IDicomDataset& dataset); + public: - explicit DicomInstanceParameters(const DicomInstanceParameters& other) : - data_(other.data_), - tags_(other.tags_->Clone()) - { - } + explicit DicomInstanceParameters(const DicomInstanceParameters& other); - explicit DicomInstanceParameters(const Orthanc::DicomMap& dicom) : - data_(dicom), - tags_(dicom.Clone()) - { - } + explicit DicomInstanceParameters(const Orthanc::DicomMap& dicom); DicomInstanceParameters* Clone() const { diff -r 239fb2c893c1 -r 2410a171ebfb OrthancStone/Sources/Toolbox/OrthancDatasets/DicomWebDataset.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/OrthancStone/Sources/Toolbox/OrthancDatasets/DicomWebDataset.cpp Tue Oct 22 21:52:34 2024 +0200 @@ -0,0 +1,231 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2023 Osimis S.A., Belgium + * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program. If not, see + * . + **/ + + +#include "DicomWebDataset.h" + +#include + +#include + + +static const char* const VALUE = "Value"; +static const char* const VR = "vr"; +static const char* const SQ = "SQ"; +static const char* const ALPHABETIC = "Alphabetic"; + + +namespace OrthancStone +{ + static const Json::Value* GetValue(std::string& vr, + const Json::Value& node, + const Orthanc::DicomTag& tag) + { + char id[16]; + sprintf(id, "%04X%04X", tag.GetGroup(), tag.GetElement()); + + if (node.type() != Json::objectValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + + if (!node.isMember(id)) + { + return NULL; + } + + if (node[id].type() == Json::objectValue && + node[id].isMember(VALUE) && + node[id].isMember(VR) && + node[id][VR].type() == Json::stringValue) + { + vr = node[id][VR].asString(); + return &node[id][VALUE]; + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + } + + + static const Json::Value* GetSequenceArray(const Json::Value& node, + const Orthanc::DicomTag& tag) + { + std::string vr; + const Json::Value* value = GetValue(vr, node, tag); + + if (value != NULL && + vr == SQ && + value->type() == Json::arrayValue) + { + return value; + } + else + { + return NULL; + } + } + + + const Json::Value* DicomWebDataset::LookupValue(std::string& vr, + const Orthanc::DicomPath& path) const + { + const Json::Value* current = &dicomweb_; + + for (size_t i = 0; i < path.GetPrefixLength(); i++) + { + if (path.IsPrefixUniversal(i)) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + } + + Json::ArrayIndex index = path.GetPrefixIndex(i); + + const Json::Value* next = GetSequenceArray(*current, path.GetPrefixTag(i)); + if (next != NULL && + index < next->size()) + { + current = &((*next) [index]); + } + else + { + return NULL; + } + } + + return GetValue(vr, *current, path.GetFinalTag()); + } + + + DicomWebDataset::DicomWebDataset(const Json::Value& dicomweb) : + dicomweb_(dicomweb) + { + if (dicomweb.type() != Json::objectValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + } + + + bool DicomWebDataset::GetStringValue(std::string& result, + const Orthanc::DicomPath& path) const + { + std::string vr; + const Json::Value* value = LookupValue(vr, path); + + if (value == NULL) + { + return false; + } + else if (value->type() == Json::arrayValue && + value->size() == 1u && + (*value) [0].type() == Json::stringValue && ( + // This is the list of all the string value representations: + // https://dicom.nema.org/medical/dicom/current/output/chtml/part05/sect_6.2.html + vr == "AE" || + vr == "AS" || + vr == "CS" || + vr == "DA" || + vr == "DS" || + vr == "DT" || + vr == "IS" || + vr == "LO" || + vr == "LT" || + vr == "SH" || + vr == "ST" || + vr == "TM" || + vr == "UC" || + vr == "UI" || + vr == "UR" || + vr == "UT")) + { + result = (*value) [0].asString(); + return true; + } + else if (value->type() == Json::arrayValue && + value->size() == 1u && + vr == "PN" && + (*value) [0].type() == Json::objectValue && + (*value) [0].isMember(ALPHABETIC) && + (*value) [0][ALPHABETIC].type() == Json::stringValue) + { + result = (*value) [0][ALPHABETIC].asString(); + return true; + } + else if (value->type() == Json::arrayValue && + value->size() == 1u && + (vr == "FD" || vr == "FL") && + (*value) [0].isDouble()) + { + result = boost::lexical_cast((*value) [0].asDouble()); + return true; + } + else if (value->type() == Json::arrayValue && + value->size() == 1u && + (vr == "UL" || + vr == "US") && + (*value) [0].isUInt64()) + { + result = boost::lexical_cast((*value) [0].asUInt64()); + return true; + } + else if (value->type() == Json::arrayValue && + value->size() == 1u && + (vr == "SL" || + vr == "SS") && + (*value) [0].isInt64()) + { + result = boost::lexical_cast((*value) [0].asInt64()); + return true; + } + else if (value->type() == Json::arrayValue && + vr == "SQ") + { + return false; + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + } + } + + + bool DicomWebDataset::GetSequenceSize(size_t& size, + const Orthanc::DicomPath& path) const + { + std::string vr; + const Json::Value* value = LookupValue(vr, path); + + if (value != NULL && + vr == SQ && + value->type() == Json::arrayValue) + { + size = value->size(); + return true; + } + else + { + return false; + } + } +} diff -r 239fb2c893c1 -r 2410a171ebfb OrthancStone/Sources/Toolbox/OrthancDatasets/DicomWebDataset.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/OrthancStone/Sources/Toolbox/OrthancDatasets/DicomWebDataset.h Tue Oct 22 21:52:34 2024 +0200 @@ -0,0 +1,49 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2023 Osimis S.A., Belgium + * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program. If not, see + * . + **/ + + +#pragma once + +#include "IDicomDataset.h" + +#include + + +namespace OrthancStone +{ + class DicomWebDataset : public IDicomDataset + { + private: + Json::Value dicomweb_; + + const Json::Value* LookupValue(std::string& vr, + const Orthanc::DicomPath& path) const; + + public: + DicomWebDataset(const Json::Value& dicomweb); + + virtual bool GetStringValue(std::string& result, + const Orthanc::DicomPath& path) const ORTHANC_OVERRIDE; + virtual bool GetSequenceSize(size_t& size, + const Orthanc::DicomPath& path) const ORTHANC_OVERRIDE; + }; +} diff -r 239fb2c893c1 -r 2410a171ebfb OrthancStone/Sources/Toolbox/OrthancDatasets/OrthancNativeDataset.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/OrthancStone/Sources/Toolbox/OrthancDatasets/OrthancNativeDataset.cpp Tue Oct 22 21:52:34 2024 +0200 @@ -0,0 +1,213 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2023 Osimis S.A., Belgium + * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program. If not, see + * . + **/ + + +#include "OrthancNativeDataset.h" + +#include + + +static const char* const NAME = "Name"; +static const char* const TYPE = "Type"; +static const char* const VALUE = "Value"; + + +namespace OrthancStone +{ + const Json::Value* OrthancNativeDataset::LookupValue(std::string& type, + const Orthanc::DicomPath& path) const + { + if (path.IsPrefixUniversal(0)) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + } + + const Orthanc::DicomValue* rootSequence = dicom_->TestAndGetValue(path.GetPrefixTag(0)); + if (rootSequence == NULL || + !rootSequence->IsSequence()) + { + return NULL; + } + + Json::ArrayIndex index = path.GetPrefixIndex(0); + + if (rootSequence->GetSequenceContent().type() != Json::arrayValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + + if (index >= rootSequence->GetSequenceContent().size()) + { + return NULL; + } + + const Json::Value* current = &(rootSequence->GetSequenceContent() [index]); + + for (size_t i = 1; i < path.GetPrefixLength(); i++) + { + if (path.IsPrefixUniversal(i)) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + } + + index = path.GetPrefixIndex(i); + std::string tag = path.GetPrefixTag(i).Format(); + + if (current->type() != Json::objectValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + + if (!current->isMember(tag)) + { + return NULL; + } + + if ((*current) [tag].type() != Json::objectValue || + !(*current) [tag].isMember(NAME) || + !(*current) [tag].isMember(TYPE) || + !(*current) [tag].isMember(VALUE) || + (*current) [tag][NAME].type() != Json::stringValue || + (*current) [tag][TYPE].type() != Json::stringValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + + if ((*current) [tag][TYPE].asString() != "Sequence" || + (*current) [tag][VALUE].type() != Json::arrayValue || + index >= (*current) [tag][VALUE].size()) + { + return NULL; + } + + current = &(*current) [tag][VALUE][index]; + } + + std::string tag = path.GetFinalTag().Format(); + + if (current->type() != Json::objectValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + + if (!current->isMember(tag)) + { + return NULL; + } + + if ((*current) [tag].type() != Json::objectValue || + !(*current) [tag].isMember(NAME) || + !(*current) [tag].isMember(TYPE) || + !(*current) [tag].isMember(VALUE) || + (*current) [tag][NAME].type() != Json::stringValue || + (*current) [tag][TYPE].type() != Json::stringValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + else + { + type = (*current) [tag][TYPE].asString(); + return &((*current) [tag][VALUE]); + } + } + + + OrthancNativeDataset::OrthancNativeDataset(const Json::Value& dicom) : + dicom_(new Orthanc::DicomMap) + { + dicom_->FromDicomAsJson(dicom, false, true /* parse sequences */); + } + + + bool OrthancNativeDataset::GetStringValue(std::string& result, + const Orthanc::DicomPath& path) const + { + if (path.GetPrefixLength() == 0) + { + return dicom_->LookupStringValue(result, path.GetFinalTag(), false); + } + else + { + std::string type; + const Json::Value* value = LookupValue(type, path); + + if (value == NULL) + { + return false; + } + else if (type == "String" && + value->type() == Json::stringValue) + { + result = value->asString(); + return true; + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + } + } + } + + + bool OrthancNativeDataset::GetSequenceSize(size_t& size, + const Orthanc::DicomPath& path) const + { + if (path.GetPrefixLength() == 0) + { + const Orthanc::DicomValue* value = dicom_->TestAndGetValue(path.GetFinalTag()); + if (value == NULL || + !value->IsSequence()) + { + return false; + } + else if (value->GetSequenceContent().type() != Json::arrayValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + else + { + size = value->GetSequenceContent().size(); + return true; + } + } + else + { + std::string type; + const Json::Value* value = LookupValue(type, path); + + if (value == NULL || + type != "Sequence") + { + return false; + } + else if (value->type() != Json::arrayValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + else + { + size = value->size(); + return true; + } + } + } +} diff -r 239fb2c893c1 -r 2410a171ebfb OrthancStone/Sources/Toolbox/OrthancDatasets/OrthancNativeDataset.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/OrthancStone/Sources/Toolbox/OrthancDatasets/OrthancNativeDataset.h Tue Oct 22 21:52:34 2024 +0200 @@ -0,0 +1,55 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2023 Osimis S.A., Belgium + * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program. If not, see + * . + **/ + + +#pragma once + +#include "IDicomDataset.h" + +#include + + +namespace OrthancStone +{ + class OrthancNativeDataset : public IDicomDataset + { + private: + std::unique_ptr dicom_; + + const Json::Value* LookupValue(std::string& type, + const Orthanc::DicomPath& path) const; + + public: + OrthancNativeDataset(const Orthanc::DicomMap& dicom) : + dicom_(dicom.Clone()) + { + } + + OrthancNativeDataset(const Json::Value& dicom); + + virtual bool GetStringValue(std::string& result, + const Orthanc::DicomPath& path) const ORTHANC_OVERRIDE; + + virtual bool GetSequenceSize(size_t& size, + const Orthanc::DicomPath& path) const ORTHANC_OVERRIDE; + }; +}