Mercurial > hg > orthanc-stone

comparison OrthancStone/Sources/Toolbox/OrthancDatasets/OrthancNativeDataset.cpp @ 2174:2410a171ebfb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
refactoring using DicomWebDataset and OrthancNativeDataset
author Sebastien Jodogne <s.jodogne@gmail.com>
date Tue, 22 Oct 2024 21:52:34 +0200
parents
children
comparison
equal deleted inserted replaced
2172:239fb2c893c1 2174:2410a171ebfb
1 /**
2 * Stone of Orthanc
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2023 Osimis S.A., Belgium
6 * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
7 *
8 * This program is free software: you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation, either version 3 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
21 **/
22
23
24 #include "OrthancNativeDataset.h"
25
26 #include <OrthancException.h>
27
28
29 static const char* const NAME = "Name";
30 static const char* const TYPE = "Type";
31 static const char* const VALUE = "Value";
32
33
34 namespace OrthancStone
35 {
36 const Json::Value* OrthancNativeDataset::LookupValue(std::string& type,
37 const Orthanc::DicomPath& path) const
38 {
39 if (path.IsPrefixUniversal(0))
40 {
41 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
42 }
43
44 const Orthanc::DicomValue* rootSequence = dicom_->TestAndGetValue(path.GetPrefixTag(0));
45 if (rootSequence == NULL ||
46 !rootSequence->IsSequence())
47 {
48 return NULL;
49 }
50
51 Json::ArrayIndex index = path.GetPrefixIndex(0);
52
53 if (rootSequence->GetSequenceContent().type() != Json::arrayValue)
54 {
55 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat);
56 }
57
58 if (index >= rootSequence->GetSequenceContent().size())
59 {
60 return NULL;
61 }
62
63 const Json::Value* current = &(rootSequence->GetSequenceContent() [index]);
64
65 for (size_t i = 1; i < path.GetPrefixLength(); i++)
66 {
67 if (path.IsPrefixUniversal(i))
68 {
69 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
70 }
71
72 index = path.GetPrefixIndex(i);
73 std::string tag = path.GetPrefixTag(i).Format();
74
75 if (current->type() != Json::objectValue)
76 {
77 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat);
78 }
79
80 if (!current->isMember(tag))
81 {
82 return NULL;
83 }
84
85 if ((*current) [tag].type() != Json::objectValue ||
86 !(*current) [tag].isMember(NAME) ||
87 !(*current) [tag].isMember(TYPE) ||
88 !(*current) [tag].isMember(VALUE) ||
89 (*current) [tag][NAME].type() != Json::stringValue ||
90 (*current) [tag][TYPE].type() != Json::stringValue)
91 {
92 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat);
93 }
94
95 if ((*current) [tag][TYPE].asString() != "Sequence" ||
96 (*current) [tag][VALUE].type() != Json::arrayValue ||
97 index >= (*current) [tag][VALUE].size())
98 {
99 return NULL;
100 }
101
102 current = &(*current) [tag][VALUE][index];
103 }
104
105 std::string tag = path.GetFinalTag().Format();
106
107 if (current->type() != Json::objectValue)
108 {
109 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat);
110 }
111
112 if (!current->isMember(tag))
113 {
114 return NULL;
115 }
116
117 if ((*current) [tag].type() != Json::objectValue ||
118 !(*current) [tag].isMember(NAME) ||
119 !(*current) [tag].isMember(TYPE) ||
120 !(*current) [tag].isMember(VALUE) ||
121 (*current) [tag][NAME].type() != Json::stringValue ||
122 (*current) [tag][TYPE].type() != Json::stringValue)
123 {
124 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat);
125 }
126 else
127 {
128 type = (*current) [tag][TYPE].asString();
129 return &((*current) [tag][VALUE]);
130 }
131 }
132
133
134 OrthancNativeDataset::OrthancNativeDataset(const Json::Value& dicom) :
135 dicom_(new Orthanc::DicomMap)
136 {
137 dicom_->FromDicomAsJson(dicom, false, true /* parse sequences */);
138 }
139
140
141 bool OrthancNativeDataset::GetStringValue(std::string& result,
142 const Orthanc::DicomPath& path) const
143 {
144 if (path.GetPrefixLength() == 0)
145 {
146 return dicom_->LookupStringValue(result, path.GetFinalTag(), false);
147 }
148 else
149 {
150 std::string type;
151 const Json::Value* value = LookupValue(type, path);
152
153 if (value == NULL)
154 {
155 return false;
156 }
157 else if (type == "String" &&
158 value->type() == Json::stringValue)
159 {
160 result = value->asString();
161 return true;
162 }
163 else
164 {
165 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
166 }
167 }
168 }
169
170
171 bool OrthancNativeDataset::GetSequenceSize(size_t& size,
172 const Orthanc::DicomPath& path) const
173 {
174 if (path.GetPrefixLength() == 0)
175 {
176 const Orthanc::DicomValue* value = dicom_->TestAndGetValue(path.GetFinalTag());
177 if (value == NULL ||
178 !value->IsSequence())
179 {
180 return false;
181 }
182 else if (value->GetSequenceContent().type() != Json::arrayValue)
183 {
184 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat);
185 }
186 else
187 {
188 size = value->GetSequenceContent().size();
189 return true;
190 }
191 }
192 else
193 {
194 std::string type;
195 const Json::Value* value = LookupValue(type, path);
196
197 if (value == NULL ||
198 type != "Sequence")
199 {
200 return false;
201 }
202 else if (value->type() != Json::arrayValue)
203 {
204 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat);
205 }
206 else
207 {
208 size = value->size();
209 return true;
210 }
211 }
212 }
213 }