Mercurial > hg > orthanc
annotate PalantirServer/FromDcmtkBridge.cpp @ 41:c1097a676eca
better naming for preview images
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Fri, 31 Aug 2012 11:45:48 +0200 |
| parents | f6d12037f886 |
| children | ea48f38afe5f |
| rev | line source |
|---|---|
| 0 | 1 /** |
| 2 * Palantir - A Lightweight, RESTful DICOM Store | |
| 3 * Copyright (C) 2012 Medical Physics Department, CHU of Liege, | |
| 4 * Belgium | |
| 5 * | |
| 6 * This program is free software: you can redistribute it and/or | |
| 7 * modify it under the terms of the GNU General Public License as | |
| 8 * published by the Free Software Foundation, either version 3 of the | |
| 9 * License, or (at your option) any later version. | |
| 10 * | |
| 11 * This program is distributed in the hope that it will be useful, but | |
| 12 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 14 * General Public License for more details. | |
| 15 * | |
| 16 * You should have received a copy of the GNU General Public License | |
| 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 18 **/ | |
| 19 | |
| 20 | |
| 21 #include "FromDcmtkBridge.h" | |
| 22 | |
| 23 #include "ToDcmtkBridge.h" | |
| 24 #include "DicomIntegerPixelAccessor.h" | |
| 25 #include "../Core/PalantirException.h" | |
| 26 #include "../Core/PngWriter.h" | |
| 27 #include "../Core/DicomFormat/DicomString.h" | |
| 28 #include "../Core/DicomFormat/DicomNullValue.h" | |
| 29 | |
| 30 #include <boost/locale.hpp> | |
| 31 #include <boost/lexical_cast.hpp> | |
| 32 | |
| 33 #include <dcmtk/dcmdata/dcdicent.h> | |
| 34 #include <dcmtk/dcmdata/dcdict.h> | |
| 35 #include <dcmtk/dcmdata/dcelem.h> | |
| 36 #include <dcmtk/dcmdata/dcfilefo.h> | |
| 37 #include <dcmtk/dcmdata/dcistrmb.h> | |
| 38 #include <dcmtk/dcmdata/dcsequen.h> | |
| 39 #include <dcmtk/dcmdata/dcvrfd.h> | |
| 40 #include <dcmtk/dcmdata/dcvrfl.h> | |
| 41 #include <dcmtk/dcmdata/dcvrsl.h> | |
| 42 #include <dcmtk/dcmdata/dcvrss.h> | |
| 43 #include <dcmtk/dcmdata/dcvrul.h> | |
| 44 #include <dcmtk/dcmdata/dcvrus.h> | |
| 45 | |
| 2 | 46 #include <boost/math/special_functions/round.hpp> |
| 0 | 47 |
| 48 namespace Palantir | |
| 49 { | |
| 50 void FromDcmtkBridge::Convert(DicomMap& target, DcmDataset& dataset) | |
| 51 { | |
| 52 target.Clear(); | |
| 53 for (unsigned long i = 0; i < dataset.card(); i++) | |
| 54 { | |
| 55 DcmElement* element = dataset.getElement(i); | |
| 56 if (element && element->isLeaf()) | |
| 57 { | |
| 58 target.SetValue(element->getTag().getGTag(), | |
| 59 element->getTag().getETag(), | |
| 60 ConvertLeafElement(*element)); | |
| 61 } | |
| 62 } | |
| 63 } | |
| 64 | |
| 65 | |
| 66 DicomTag FromDcmtkBridge::GetTag(const DcmElement& element) | |
| 67 { | |
| 68 return DicomTag(element.getGTag(), element.getETag()); | |
| 69 } | |
| 70 | |
| 71 | |
| 72 DicomValue* FromDcmtkBridge::ConvertLeafElement(DcmElement& element) | |
| 73 { | |
| 74 if (!element.isLeaf()) | |
| 75 { | |
| 76 throw PalantirException("Only applicable to leaf elements"); | |
| 77 } | |
| 78 | |
| 79 if (element.isaString()) | |
| 80 { | |
| 81 char *c; | |
| 82 if (element.getString(c).good() && | |
| 83 c != NULL) | |
| 84 { | |
| 85 std::string s(c); | |
| 86 std::string utf8; | |
| 87 try | |
| 88 { | |
| 89 utf8 = boost::locale::conv::to_utf<char>(s, "ISO-8859-1"); // TODO Parameter? | |
| 90 } | |
| 2 | 91 catch (std::runtime_error&) |
| 0 | 92 { |
| 93 // Bad input string or bad encoding | |
| 94 utf8 = s; | |
| 95 } | |
| 96 | |
| 97 return new DicomString(utf8); | |
| 98 } | |
| 99 else | |
| 100 { | |
| 101 return new DicomNullValue; | |
| 102 } | |
| 103 } | |
| 104 | |
| 105 try | |
| 106 { | |
| 107 // http://support.dcmtk.org/docs/dcvr_8h-source.html | |
| 108 switch (element.getVR()) | |
| 109 { | |
| 110 | |
| 111 /** | |
| 112 * TODO. | |
| 113 **/ | |
| 114 | |
| 115 case EVR_DS: // decimal string | |
| 116 case EVR_IS: // integer string | |
| 117 case EVR_OB: // other byte | |
| 118 case EVR_OF: // other float | |
| 119 case EVR_OW: // other word | |
| 120 case EVR_AS: // age string | |
| 121 case EVR_AT: // attribute tag | |
| 122 case EVR_DA: // date string | |
| 123 case EVR_DT: // date time string | |
| 124 case EVR_TM: // time string | |
| 125 case EVR_UN: // unknown value representation | |
| 126 return new DicomNullValue(); | |
| 127 | |
| 128 | |
| 129 /** | |
| 130 * String types, should never happen at this point because of | |
| 131 * "element.isaString()". | |
| 132 **/ | |
| 133 | |
| 134 case EVR_AE: // application entity title | |
| 135 case EVR_CS: // code string | |
| 136 case EVR_SH: // short string | |
| 137 case EVR_LO: // long string | |
| 138 case EVR_ST: // short text | |
| 139 case EVR_LT: // long text | |
| 140 case EVR_UT: // unlimited text | |
| 141 case EVR_PN: // person name | |
| 142 case EVR_UI: // unique identifier | |
| 143 return new DicomNullValue(); | |
| 144 | |
| 145 | |
| 146 /** | |
| 147 * Numerical types | |
| 148 **/ | |
| 149 | |
| 150 case EVR_SL: // signed long | |
| 151 { | |
| 152 Sint32 f; | |
| 153 if (dynamic_cast<DcmSignedLong&>(element).getSint32(f).good()) | |
| 154 { | |
| 155 return new DicomString(boost::lexical_cast<std::string>(f)); | |
| 156 } | |
| 157 else | |
| 158 { | |
| 159 return new DicomNullValue(); | |
| 160 } | |
| 161 } | |
| 162 | |
| 163 case EVR_SS: // signed short | |
| 164 { | |
| 165 Sint16 f; | |
| 166 if (dynamic_cast<DcmSignedShort&>(element).getSint16(f).good()) | |
| 167 { | |
| 168 return new DicomString(boost::lexical_cast<std::string>(f)); | |
| 169 } | |
| 170 else | |
| 171 { | |
| 172 return new DicomNullValue(); | |
| 173 } | |
| 174 } | |
| 175 | |
| 176 case EVR_UL: // unsigned long | |
| 177 { | |
| 178 Uint32 f; | |
| 179 if (dynamic_cast<DcmUnsignedLong&>(element).getUint32(f).good()) | |
| 180 { | |
| 181 return new DicomString(boost::lexical_cast<std::string>(f)); | |
| 182 } | |
| 183 else | |
| 184 { | |
| 185 return new DicomNullValue(); | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 case EVR_US: // unsigned short | |
| 190 { | |
| 191 Uint16 f; | |
| 192 if (dynamic_cast<DcmUnsignedShort&>(element).getUint16(f).good()) | |
| 193 { | |
| 194 return new DicomString(boost::lexical_cast<std::string>(f)); | |
| 195 } | |
| 196 else | |
| 197 { | |
| 198 return new DicomNullValue(); | |
| 199 } | |
| 200 } | |
| 201 | |
| 202 case EVR_FL: // float single-precision | |
| 203 { | |
| 204 Float32 f; | |
| 205 if (dynamic_cast<DcmFloatingPointSingle&>(element).getFloat32(f).good()) | |
| 206 { | |
| 207 return new DicomString(boost::lexical_cast<std::string>(f)); | |
| 208 } | |
| 209 else | |
| 210 { | |
| 211 return new DicomNullValue(); | |
| 212 } | |
| 213 } | |
| 214 | |
| 215 case EVR_FD: // float double-precision | |
| 216 { | |
| 217 Float64 f; | |
| 218 if (dynamic_cast<DcmFloatingPointDouble&>(element).getFloat64(f).good()) | |
| 219 { | |
| 220 return new DicomString(boost::lexical_cast<std::string>(f)); | |
| 221 } | |
| 222 else | |
| 223 { | |
| 224 return new DicomNullValue(); | |
| 225 } | |
| 226 } | |
| 227 | |
| 228 | |
| 229 /** | |
| 230 * Sequence types, should never occur at this point because of | |
| 231 * "element.isLeaf()". | |
| 232 **/ | |
| 233 | |
| 234 case EVR_SQ: // sequence of items | |
| 235 return new DicomNullValue; | |
| 236 | |
| 237 | |
| 238 /** | |
| 239 * Internal to DCMTK. | |
| 240 **/ | |
| 241 | |
| 242 case EVR_ox: // OB or OW depending on context | |
| 243 case EVR_xs: // SS or US depending on context | |
| 244 case EVR_lt: // US, SS or OW depending on context, used for LUT Data (thus the name) | |
| 245 case EVR_na: // na="not applicable", for data which has no VR | |
| 246 case EVR_up: // up="unsigned pointer", used internally for DICOMDIR suppor | |
| 247 case EVR_item: // used internally for items | |
| 248 case EVR_metainfo: // used internally for meta info datasets | |
| 249 case EVR_dataset: // used internally for datasets | |
| 250 case EVR_fileFormat: // used internally for DICOM files | |
| 251 case EVR_dicomDir: // used internally for DICOMDIR objects | |
| 252 case EVR_dirRecord: // used internally for DICOMDIR records | |
| 253 case EVR_pixelSQ: // used internally for pixel sequences in a compressed image | |
| 254 case EVR_pixelItem: // used internally for pixel items in a compressed image | |
| 255 case EVR_UNKNOWN: // used internally for elements with unknown VR (encoded with 4-byte length field in explicit VR) | |
| 256 case EVR_PixelData: // used internally for uncompressed pixeld data | |
| 257 case EVR_OverlayData: // used internally for overlay data | |
| 258 case EVR_UNKNOWN2B: // used internally for elements with unknown VR with 2-byte length field in explicit VR | |
| 259 return new DicomNullValue; | |
| 260 | |
| 261 | |
| 262 /** | |
| 263 * Default case. | |
| 264 **/ | |
| 265 | |
| 266 default: | |
| 267 return new DicomNullValue; | |
| 268 } | |
| 269 } | |
| 270 catch (boost::bad_lexical_cast) | |
| 271 { | |
| 272 return new DicomNullValue; | |
| 273 } | |
| 274 } | |
| 275 | |
| 276 | |
| 277 static void StoreElement(Json::Value& target, | |
| 278 DcmElement& element, | |
| 279 unsigned int maxStringLength); | |
| 280 | |
| 281 static void StoreItem(Json::Value& target, | |
| 282 DcmItem& item, | |
| 283 unsigned int maxStringLength) | |
| 284 { | |
| 285 target = Json::Value(Json::objectValue); | |
| 286 | |
| 287 for (unsigned long i = 0; i < item.card(); i++) | |
| 288 { | |
| 289 DcmElement* element = item.getElement(i); | |
| 290 StoreElement(target, *element, maxStringLength); | |
| 291 } | |
| 292 } | |
| 293 | |
| 294 | |
| 295 static void StoreElement(Json::Value& target, | |
| 296 DcmElement& element, | |
| 297 unsigned int maxStringLength) | |
| 298 { | |
| 299 assert(target.type() == Json::objectValue); | |
| 300 | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
301 DicomTag tag(FromDcmtkBridge::GetTag(element)); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
302 const std::string tagName = FromDcmtkBridge::GetName(tag); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
303 const std::string formattedTag = tag.Format(); |
| 0 | 304 |
| 305 if (element.isLeaf()) | |
| 306 { | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
307 Json::Value value(Json::objectValue); |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
308 value["Name"] = tagName; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
309 |
| 0 | 310 std::auto_ptr<DicomValue> v(FromDcmtkBridge::ConvertLeafElement(element)); |
| 311 if (v->IsNull()) | |
| 312 { | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
313 value["Type"] = "Null"; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
314 value["Value"] = Json::nullValue; |
| 0 | 315 } |
| 316 else | |
| 317 { | |
| 318 std::string s = v->AsString(); | |
| 319 if (maxStringLength == 0 || | |
| 320 s.size() <= maxStringLength) | |
| 321 { | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
322 value["Type"] = "String"; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
323 value["Value"] = s; |
| 0 | 324 } |
| 325 else | |
| 326 { | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
327 value["Type"] = "TooLong"; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
328 value["Value"] = Json::nullValue; |
| 0 | 329 } |
| 330 } | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
331 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
332 target[formattedTag] = value; |
| 0 | 333 } |
| 334 else | |
| 335 { | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
336 Json::Value children(Json::arrayValue); |
| 0 | 337 |
| 338 // "All subclasses of DcmElement except for DcmSequenceOfItems | |
| 339 // are leaf nodes, while DcmSequenceOfItems, DcmItem, DcmDataset | |
| 340 // etc. are not." The following cast is thus OK. | |
| 341 DcmSequenceOfItems& sequence = dynamic_cast<DcmSequenceOfItems&>(element); | |
| 342 | |
| 343 for (unsigned long i = 0; i < sequence.card(); i++) | |
| 344 { | |
| 345 DcmItem* child = sequence.getItem(i); | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
346 Json::Value& v = children.append(Json::objectValue); |
| 0 | 347 StoreItem(v, *child, maxStringLength); |
| 348 } | |
|
35
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
349 |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
350 target[formattedTag]["Name"] = tagName; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
351 target[formattedTag]["Type"] = "Sequence"; |
|
f6d12037f886
full json vs. simplified json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2
diff
changeset
|
352 target[formattedTag]["Value"] = children; |
| 0 | 353 } |
| 354 } | |
| 355 | |
| 356 | |
| 357 void FromDcmtkBridge::ToJson(Json::Value& root, | |
| 358 DcmDataset& dataset, | |
| 359 unsigned int maxStringLength) | |
| 360 { | |
| 361 StoreItem(root, dataset, maxStringLength); | |
| 362 } | |
| 363 | |
| 364 | |
| 365 | |
| 366 void FromDcmtkBridge::ToJson(Json::Value& target, | |
| 367 const std::string& path, | |
| 368 unsigned int maxStringLength) | |
| 369 { | |
| 370 DcmFileFormat dicom; | |
| 371 if (!dicom.loadFile(path.c_str()).good()) | |
| 372 { | |
| 373 throw PalantirException(ErrorCode_BadFileFormat); | |
| 374 } | |
| 375 else | |
| 376 { | |
| 377 FromDcmtkBridge::ToJson(target, *dicom.getDataset(), maxStringLength); | |
| 378 } | |
| 379 } | |
| 380 | |
| 381 | |
|
41
c1097a676eca
better naming for preview images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
35
diff
changeset
|
382 void FromDcmtkBridge::ExtractPreviewImage(std::string& result, |
|
c1097a676eca
better naming for preview images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
35
diff
changeset
|
383 DcmDataset& dataset) |
| 0 | 384 { |
| 385 // See also: http://support.dcmtk.org/wiki/dcmtk/howto/accessing-compressed-data | |
| 386 | |
| 387 PngWriter w; | |
| 388 std::auto_ptr<DicomIntegerPixelAccessor> accessor; | |
| 389 | |
| 390 DicomMap m; | |
| 391 FromDcmtkBridge::Convert(m, dataset); | |
| 392 | |
| 393 DcmElement* e; | |
| 394 if (dataset.findAndGetElement(ToDcmtkBridge::Convert(DicomTag::PIXEL_DATA), e).good() && | |
| 395 e != NULL) | |
| 396 { | |
| 397 Uint8* pixData = NULL; | |
| 398 if (e->getUint8Array(pixData) == EC_Normal) | |
| 399 { | |
| 400 accessor.reset(new DicomIntegerPixelAccessor(m, pixData, e->getLength())); | |
| 401 } | |
| 402 } | |
| 403 | |
| 404 if (accessor.get() == NULL || | |
| 405 accessor->GetWidth() == 0 || | |
| 406 accessor->GetHeight() == 0) | |
| 407 { | |
| 408 w.WriteToMemory(result, 0, 0, 0, PixelFormat_Grayscale8, NULL); | |
| 409 } | |
| 410 else | |
| 411 { | |
| 412 int32_t min, max; | |
| 413 accessor->GetExtremeValues(min, max); | |
| 414 | |
| 415 std::vector<uint8_t> image(accessor->GetWidth() * accessor->GetHeight(), 0); | |
| 416 if (min != max) | |
| 417 { | |
| 418 uint8_t* result = &image[0]; | |
| 419 for (unsigned int y = 0; y < accessor->GetHeight(); y++) | |
| 420 { | |
| 421 for (unsigned int x = 0; x < accessor->GetWidth(); x++, result++) | |
| 422 { | |
| 423 int32_t v = accessor->GetValue(x, y); | |
| 2 | 424 *result = static_cast<uint8_t>(boost::math::lround(static_cast<float>(v - min) / static_cast<float>(max - min) * 255.0f)); |
| 0 | 425 } |
| 426 } | |
| 427 } | |
| 428 | |
| 429 w.WriteToMemory(result, accessor->GetWidth(), accessor->GetHeight(), | |
| 430 accessor->GetWidth(), PixelFormat_Grayscale8, &image[0]); | |
| 431 } | |
| 432 } | |
| 433 | |
| 434 | |
|
41
c1097a676eca
better naming for preview images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
35
diff
changeset
|
435 void FromDcmtkBridge::ExtractPreviewImage(std::string& result, |
|
c1097a676eca
better naming for preview images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
35
diff
changeset
|
436 const std::string& dicomContent) |
| 0 | 437 { |
| 438 DcmInputBufferStream is; | |
| 439 if (dicomContent.size() > 0) | |
| 440 { | |
| 441 is.setBuffer(&dicomContent[0], dicomContent.size()); | |
| 442 } | |
| 443 is.setEos(); | |
| 444 | |
| 445 DcmFileFormat dicom; | |
| 446 if (dicom.read(is).good()) | |
| 447 { | |
|
41
c1097a676eca
better naming for preview images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
35
diff
changeset
|
448 ExtractPreviewImage(result, *dicom.getDataset()); |
| 0 | 449 } |
| 450 else | |
| 451 { | |
| 452 throw PalantirException(ErrorCode_BadFileFormat); | |
| 453 } | |
| 454 } | |
| 455 | |
| 456 | |
| 457 | |
| 458 std::string FromDcmtkBridge::GetName(const DicomTag& t) | |
| 459 { | |
| 460 DcmTagKey tag(t.GetGroup(), t.GetElement()); | |
| 461 const DcmDataDictionary& dict = dcmDataDict.rdlock(); | |
| 462 const DcmDictEntry* entry = dict.findEntry(tag, NULL); | |
| 463 | |
| 464 std::string s("Unknown"); | |
| 465 if (entry != NULL) | |
| 466 { | |
| 467 s = std::string(entry->getTagName()); | |
| 468 } | |
| 469 | |
| 470 dcmDataDict.unlock(); | |
| 471 return s; | |
| 472 } | |
| 473 | |
| 474 | |
| 475 DicomTag FromDcmtkBridge::FindTag(const char* name) | |
| 476 { | |
| 477 const DcmDataDictionary& dict = dcmDataDict.rdlock(); | |
| 478 const DcmDictEntry* entry = dict.findEntry(name); | |
| 479 | |
| 480 if (entry == NULL) | |
| 481 { | |
| 482 dcmDataDict.unlock(); | |
| 483 throw PalantirException("Unknown DICOM tag"); | |
| 484 } | |
| 485 else | |
| 486 { | |
| 487 DcmTagKey key = entry->getKey(); | |
| 488 DicomTag tag(key.getGroup(), key.getElement()); | |
| 489 dcmDataDict.unlock(); | |
| 490 return tag; | |
| 491 } | |
| 492 } | |
| 493 | |
| 494 | |
| 495 void FromDcmtkBridge::Print(FILE* fp, const DicomMap& m) | |
| 496 { | |
| 497 for (DicomMap::Map::const_iterator | |
| 498 it = m.map_.begin(); it != m.map_.end(); it++) | |
| 499 { | |
| 500 DicomTag t = it->first; | |
| 501 std::string s = it->second->AsString(); | |
| 502 printf("0x%04x 0x%04x (%s) [%s]\n", t.GetGroup(), t.GetElement(), GetName(t).c_str(), s.c_str()); | |
| 503 } | |
| 504 } | |
| 505 | |
| 506 | |
| 507 void FromDcmtkBridge::ToJson(Json::Value& result, | |
| 508 const DicomMap& values) | |
| 509 { | |
| 510 if (result.type() != Json::objectValue) | |
| 511 { | |
| 512 throw PalantirException(ErrorCode_BadParameterType); | |
| 513 } | |
| 514 | |
| 515 result.clear(); | |
| 516 | |
| 517 for (DicomMap::Map::const_iterator | |
| 518 it = values.map_.begin(); it != values.map_.end(); it++) | |
| 519 { | |
| 520 result[GetName(it->first)] = it->second->AsString(); | |
| 521 } | |
| 522 } | |
| 523 } |