Mercurial > hg > orthanc

comparison OrthancServer/DicomDirWriter.cpp @ 1885:5be57564ffc4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
refactoring dicomdir generation
author Sebastien Jodogne <s.jodogne@gmail.com>
date Fri, 11 Dec 2015 15:43:33 +0100
parents 6a2d507ef064
children d7f63122c7f3
comparison
equal deleted inserted replaced
1883:71356f41ec2f 1885:5be57564ffc4
132 typedef std::pair<ResourceType, std::string> IndexKey; 132 typedef std::pair<ResourceType, std::string> IndexKey;
133 typedef std::map<IndexKey, DcmDirectoryRecord* > Index; 133 typedef std::map<IndexKey, DcmDirectoryRecord* > Index;
134 Index index_; 134 Index index_;
135 135
136 136
137 /*******************************************************************************
138 * Functions adapted from "dcmdata/libsrc/dcddirif.cc" from DCMTK 3.6.0
139 *******************************************************************************/
140
141 // print an error message to the console (stderr) that something went wrong with an attribute
142 static void printAttributeErrorMessage(const DcmTagKey &key,
143 const OFCondition &error,
144 const char *operation)
145 {
146 if (error.bad())
147 {
148 OFString str;
149 if (operation != NULL)
150 {
151 str = "cannot ";
152 str += operation;
153 str += " ";
154 }
155 LOG(ERROR) << error.text() << ": " << str << DcmTag(key).getTagName() << " " << key;
156 }
157 }
158
159 // copy element from dataset to directory record
160 static void copyElement(DcmItem& dataset,
161 const DcmTagKey &key,
162 DcmDirectoryRecord& record,
163 const OFBool optional,
164 const OFBool copyEmpty)
165 {
166 /* check whether tag exists in source dataset (if optional) */
167 if (!optional || (copyEmpty && dataset.tagExists(key)) || dataset.tagExistsWithValue(key))
168 {
169 DcmElement *delem = NULL;
170 /* get copy of element from source dataset */
171 OFCondition status = dataset.findAndGetElement(key, delem, OFFalse /*searchIntoSub*/, OFTrue /*createCopy*/);
172 if (status.good())
173 {
174 /* ... and insert it into the destination dataset (record) */
175 status = record.insert(delem, OFTrue /*replaceOld*/);
176 if (status.good())
177 {
178 DcmTag tag(key);
179 /* check for correct VR in the dataset */
180 if (delem->getVR() != tag.getEVR())
181 {
182 /* create warning message */
183 LOG(WARNING) << "DICOMDIR: possibly wrong VR: "
184 << tag.getTagName() << " " << key << " with "
185 << DcmVR(delem->getVR()).getVRName() << " found, expected "
186 << tag.getVRName() << " instead";
187 }
188 } else
189 delete delem;
190 } else if (status == EC_TagNotFound)
191 status = record.insertEmptyElement(key);
192 printAttributeErrorMessage(key, status, "insert");
193 }
194 }
195
196 // copy optional string value from dataset to directory record
197 static void copyStringWithDefault(DcmItem& dataset,
198 const DcmTagKey &key,
199 DcmDirectoryRecord& record,
200 const char *defaultValue,
201 const OFBool printWarning)
202 {
203 OFCondition status;
204 if (dataset.tagExistsWithValue(key))
205 {
206 OFString stringValue;
207 /* retrieve string value from source dataset and put it into the destination dataset */
208 status = dataset.findAndGetOFStringArray(key, stringValue);
209 if (status.good())
210 status = record.putAndInsertString(key, stringValue.c_str());
211 } else {
212 if (printWarning && (defaultValue != NULL))
213 {
214 /* create warning message */
215 LOG(WARNING) << "DICOMDIR: " << DcmTag(key).getTagName() << " "
216 << key << " missing, using alternative: " << defaultValue;
217 }
218 /* put default value */
219 status = record.putAndInsertString(key, defaultValue);
220 }
221 }
222
223 // create alternative study date if absent in dataset
224 static OFString &alternativeStudyDate(DcmItem& dataset,
225 OFString &result)
226 {
227 /* use another date if present */
228 if (dataset.findAndGetOFStringArray(DCM_SeriesDate, result).bad() || result.empty())
229 {
230 if (dataset.findAndGetOFStringArray(DCM_AcquisitionDate, result).bad() || result.empty())
231 {
232 if (dataset.findAndGetOFStringArray(DCM_ContentDate, result).bad() || result.empty())
233 {
234 /* use current date, "19000101" in case of error */
235 DcmDate::getCurrentDate(result);
236 }
237 }
238 }
239 return result;
240 }
241
242
243 // create alternative study time if absent in dataset
244 static OFString &alternativeStudyTime(DcmItem& dataset,
245 OFString &result)
246 {
247 /* use another time if present */
248 if (dataset.findAndGetOFStringArray(DCM_SeriesTime, result).bad() || result.empty())
249 {
250 if (dataset.findAndGetOFStringArray(DCM_AcquisitionTime, result).bad() || result.empty())
251 {
252 if (dataset.findAndGetOFStringArray(DCM_ContentTime, result).bad() || result.empty())
253 {
254 /* use current time, "0000" in case of error */
255 DcmTime::getCurrentTime(result);
256 }
257 }
258 }
259 return result;
260 }
261
262
263 static void copyElementType1(DcmItem& dataset,
264 const DcmTagKey &key,
265 DcmDirectoryRecord& record)
266 {
267 copyElement(dataset, key, record, OFFalse /*optional*/, OFFalse /*copyEmpty*/);
268 }
269
270 static void copyElementType1C(DcmItem& dataset,
271 const DcmTagKey &key,
272 DcmDirectoryRecord& record)
273 {
274 copyElement(dataset, key, record, OFTrue /*optional*/, OFFalse /*copyEmpty*/);
275 }
276
277 static void copyElementType2(DcmItem& dataset,
278 const DcmTagKey &key,
279 DcmDirectoryRecord& record)
280 {
281 copyElement(dataset, key, record, OFFalse /*optional*/, OFTrue /*copyEmpty*/);
282 }
283
284 /*******************************************************************************
285 * End of functions adapted from "dcmdata/libsrc/dcddirif.cc" from DCMTK 3.6.0
286 *******************************************************************************/
287
288
289 DcmDicomDir& GetDicomDir() 137 DcmDicomDir& GetDicomDir()
290 { 138 {
291 if (dir_.get() == NULL) 139 if (dir_.get() == NULL)
292 { 140 {
293 dir_.reset(new DcmDicomDir(file_.GetPath().c_str(), 141 dir_.reset(new DcmDicomDir(file_.GetPath().c_str(),
294 fileSetId_.c_str())); 142 fileSetId_.c_str()));
143 //SetTagValue(dir_->getRootRecord(), DCM_SpecificCharacterSet, GetDicomSpecificCharacterSet(Encoding_Utf8));
295 } 144 }
296 145
297 return *dir_; 146 return *dir_;
298 } 147 }
299 148
300 149
301 DcmDirectoryRecord& GetRoot() 150 DcmDirectoryRecord& GetRoot()
302 { 151 {
303 return GetDicomDir().getRootRecord(); 152 return GetDicomDir().getRootRecord();
153 }
154
155
156 static bool GetUtf8TagValue(std::string& result,
157 DcmItem& source,
158 Encoding encoding,
159 const DcmTagKey& key)
160 {
161 DcmElement* element = NULL;
162 char* s = NULL;
163
164 if (source.findAndGetElement(key, element).good())
165 {
166 if (element->isLeaf() &&
167 element->getString(s).good() &&
168 s != NULL)
169 {
170 result = Toolbox::ConvertToUtf8(s, encoding);
171 return true;
172 }
173 }
174
175 result.clear();
176 return false;
177 }
178
179
180 static void SetTagValue(DcmDirectoryRecord& target,
181 const DcmTagKey& key,
182 const std::string& valueUtf8)
183 {
184 std::string s = Toolbox::ConvertFromUtf8(valueUtf8, Encoding_Ascii);
185
186 if (!target.putAndInsertString(key, s.c_str()).good())
187 {
188 throw OrthancException(ErrorCode_InternalError);
189 }
190 }
191
192
193
194 static bool CopyString(DcmDirectoryRecord& target,
195 DcmDataset& source,
196 Encoding encoding,
197 const DcmTagKey& key,
198 bool optional,
199 bool copyEmpty)
200 {
201 if (optional &&
202 !source.tagExistsWithValue(key) &&
203 !(copyEmpty && source.tagExists(key)))
204 {
205 return false;
206 }
207
208 std::string value;
209 bool found = GetUtf8TagValue(value, source, encoding, key);
210
211 SetTagValue(target, key, value);
212 return found;
213 }
214
215
216 static void CopyStringType1(DcmDirectoryRecord& target,
217 DcmDataset& source,
218 Encoding encoding,
219 const DcmTagKey& key)
220 {
221 CopyString(target, source, encoding, key, false, false);
222 }
223
224 static void CopyStringType1C(DcmDirectoryRecord& target,
225 DcmDataset& source,
226 Encoding encoding,
227 const DcmTagKey& key)
228 {
229 CopyString(target, source, encoding, key, true, false);
230 }
231
232 static void CopyStringType2(DcmDirectoryRecord& target,
233 DcmDataset& source,
234 Encoding encoding,
235 const DcmTagKey& key)
236 {
237 CopyString(target, source, encoding, key, false, true);
304 } 238 }
305 239
306 240
307 public: 241 public:
308 PImpl() : fileSetId_("ORTHANC_MEDIA") 242 PImpl() : fileSetId_("ORTHANC_MEDIA")
309 { 243 {
310 } 244 }
311 245
312 void FillPatient(DcmDirectoryRecord& record, 246 void FillPatient(DcmDirectoryRecord& record,
313 DcmItem& dicom) 247 DcmDataset& dicom,
248 Encoding encoding)
314 { 249 {
315 // cf. "DicomDirInterface::buildPatientRecord()" 250 // cf. "DicomDirInterface::buildPatientRecord()"
316 251
317 copyElementType1C(dicom, DCM_PatientID, record); 252 CopyStringType1C(record, dicom, encoding, DCM_PatientID);
318 copyElementType2(dicom, DCM_PatientName, record); 253 CopyStringType2(record, dicom, encoding, DCM_PatientName);
319 } 254 }
320 255
321 void FillStudy(DcmDirectoryRecord& record, 256 void FillStudy(DcmDirectoryRecord& record,
322 DcmItem& dicom) 257 DcmDataset& dicom,
258 Encoding encoding)
323 { 259 {
324 // cf. "DicomDirInterface::buildStudyRecord()" 260 // cf. "DicomDirInterface::buildStudyRecord()"
325 261
326 OFString tmpString; 262 std::string nowDate, nowTime;
263 Toolbox::GetNowDicom(nowDate, nowTime);
264
265 std::string studyDate;
266 if (!GetUtf8TagValue(studyDate, dicom, encoding, DCM_StudyDate) &&
267 !GetUtf8TagValue(studyDate, dicom, encoding, DCM_SeriesDate) &&
268 !GetUtf8TagValue(studyDate, dicom, encoding, DCM_AcquisitionDate) &&
269 !GetUtf8TagValue(studyDate, dicom, encoding, DCM_ContentDate))
270 {
271 studyDate = nowDate;
272 }
273
274 std::string studyTime;
275 if (!GetUtf8TagValue(studyTime, dicom, encoding, DCM_StudyTime) &&
276 !GetUtf8TagValue(studyTime, dicom, encoding, DCM_SeriesTime) &&
277 !GetUtf8TagValue(studyTime, dicom, encoding, DCM_AcquisitionTime) &&
278 !GetUtf8TagValue(studyTime, dicom, encoding, DCM_ContentTime))
279 {
280 studyTime = nowTime;
281 }
282
327 /* copy attribute values from dataset to study record */ 283 /* copy attribute values from dataset to study record */
328 copyStringWithDefault(dicom, DCM_StudyDate, record, 284 SetTagValue(record, DCM_StudyDate, studyDate);
329 alternativeStudyDate(dicom, tmpString).c_str(), OFTrue /*printWarning*/); 285 SetTagValue(record, DCM_StudyTime, studyTime);
330 copyStringWithDefault(dicom, DCM_StudyTime, record, 286 CopyStringType2(record, dicom, encoding, DCM_StudyDescription);
331 alternativeStudyTime(dicom, tmpString).c_str(), OFTrue /*printWarning*/); 287 CopyStringType1(record, dicom, encoding, DCM_StudyInstanceUID);
332 copyElementType2(dicom, DCM_StudyDescription, record);
333 copyElementType1(dicom, DCM_StudyInstanceUID, record);
334 /* use type 1C instead of 1 in order to avoid unwanted overwriting */ 288 /* use type 1C instead of 1 in order to avoid unwanted overwriting */
335 copyElementType1C(dicom, DCM_StudyID, record); 289 CopyStringType1C(record, dicom, encoding, DCM_StudyID);
336 copyElementType2(dicom, DCM_AccessionNumber, record); 290 CopyStringType2(record, dicom, encoding, DCM_AccessionNumber);
337 } 291 }
338 292
339 void FillSeries(DcmDirectoryRecord& record, 293 void FillSeries(DcmDirectoryRecord& record,
340 DcmItem& dicom) 294 DcmDataset& dicom,
295 Encoding encoding)
341 { 296 {
342 // cf. "DicomDirInterface::buildSeriesRecord()" 297 // cf. "DicomDirInterface::buildSeriesRecord()"
343 298
344 /* copy attribute values from dataset to series record */ 299 /* copy attribute values from dataset to series record */
345 copyElementType1(dicom, DCM_Modality, record); 300 CopyStringType1(record, dicom, encoding, DCM_Modality);
346 copyElementType1(dicom, DCM_SeriesInstanceUID, record); 301 CopyStringType1(record, dicom, encoding, DCM_SeriesInstanceUID);
347 /* use type 1C instead of 1 in order to avoid unwanted overwriting */ 302 /* use type 1C instead of 1 in order to avoid unwanted overwriting */
348 copyElementType1C(dicom, DCM_SeriesNumber, record); 303 CopyStringType1C(record, dicom, encoding, DCM_SeriesNumber);
349 } 304 }
350 305
351 void FillInstance(DcmDirectoryRecord& record, 306 void FillInstance(DcmDirectoryRecord& record,
352 DcmItem& dicom, 307 DcmDataset& dicom,
308 Encoding encoding,
353 DcmMetaInfo& metaInfo, 309 DcmMetaInfo& metaInfo,
354 const char* path) 310 const char* path)
355 { 311 {
356 // cf. "DicomDirInterface::buildImageRecord()" 312 // cf. "DicomDirInterface::buildImageRecord()"
357 313
358 /* copy attribute values from dataset to image record */ 314 /* copy attribute values from dataset to image record */
359 copyElementType1(dicom, DCM_InstanceNumber, record); 315 CopyStringType1(record, dicom, encoding, DCM_InstanceNumber);
360 //copyElementType1C(dicom, DCM_ImageType, record); 316 //CopyElementType1C(record, dicom, encoding, DCM_ImageType);
361 copyElementType1C(dicom, DCM_ReferencedImageSequence, record); 317
362 318 // REMOVED since 0.9.7: copyElementType1C(dicom, DCM_ReferencedImageSequence, record);
363 OFString tmp; 319
364 320 std::string sopClassUid, sopInstanceUid, transferSyntaxUid;
365 DcmElement* item = record.remove(DCM_ReferencedImageSequence); 321 if (!GetUtf8TagValue(sopClassUid, dicom, encoding, DCM_SOPClassUID) ||
366 if (item != NULL) 322 !GetUtf8TagValue(sopInstanceUid, dicom, encoding, DCM_SOPInstanceUID) ||
367 { 323 !GetUtf8TagValue(transferSyntaxUid, metaInfo, encoding, DCM_TransferSyntaxUID))
368 delete item;
369 }
370
371 if (record.putAndInsertString(DCM_ReferencedFileID, path).bad() ||
372 dicom.findAndGetOFStringArray(DCM_SOPClassUID, tmp).bad() ||
373 record.putAndInsertString(DCM_ReferencedSOPClassUIDInFile, tmp.c_str()).bad() ||
374 dicom.findAndGetOFStringArray(DCM_SOPInstanceUID, tmp).bad() ||
375 record.putAndInsertString(DCM_ReferencedSOPInstanceUIDInFile, tmp.c_str()).bad() ||
376 metaInfo.findAndGetOFStringArray(DCM_TransferSyntaxUID, tmp).bad() ||
377 record.putAndInsertString(DCM_ReferencedTransferSyntaxUIDInFile, tmp.c_str()).bad())
378 { 324 {
379 throw OrthancException(ErrorCode_BadFileFormat); 325 throw OrthancException(ErrorCode_BadFileFormat);
380 } 326 }
327
328 SetTagValue(record, DCM_ReferencedFileID, path);
329 SetTagValue(record, DCM_ReferencedSOPClassUIDInFile, sopClassUid);
330 SetTagValue(record, DCM_ReferencedSOPInstanceUIDInFile, sopInstanceUid);
331 SetTagValue(record, DCM_ReferencedTransferSyntaxUIDInFile, transferSyntaxUid);
381 } 332 }
382 333
383 334
384 335
385 bool CreateResource(DcmDirectoryRecord*& target, 336 bool CreateResource(DcmDirectoryRecord*& target,
386 ResourceType level, 337 ResourceType level,
387 DcmFileFormat& dicom, 338 ParsedDicomFile& dicom,
388 const char* filename, 339 const char* filename,
389 const char* path) 340 const char* path)
390 { 341 {
391 DcmDataset& dataset = *dicom.getDataset(); 342 DcmDataset& dataset = *dicom.GetDcmtkObject().getDataset();
392 343 Encoding encoding = dicom.GetEncoding();
393 OFCondition result; 344
394 OFString id; 345 bool found;
346 std::string id;
395 E_DirRecType type; 347 E_DirRecType type;
396 348
397 switch (level) 349 switch (level)
398 { 350 {
399 case ResourceType_Patient: 351 case ResourceType_Patient:
400 result = dataset.findAndGetOFString(DCM_PatientID, id); 352 found = GetUtf8TagValue(id, dataset, encoding, DCM_PatientID);
401 type = ERT_Patient; 353 type = ERT_Patient;
402 break; 354 break;
403 355
404 case ResourceType_Study: 356 case ResourceType_Study:
405 result = dataset.findAndGetOFString(DCM_StudyInstanceUID, id); 357 found = GetUtf8TagValue(id, dataset, encoding, DCM_StudyInstanceUID);
406 type = ERT_Study; 358 type = ERT_Study;
407 break; 359 break;
408 360
409 case ResourceType_Series: 361 case ResourceType_Series:
410 result = dataset.findAndGetOFString(DCM_SeriesInstanceUID, id); 362 found = GetUtf8TagValue(id, dataset, encoding, DCM_SeriesInstanceUID);
411 type = ERT_Series; 363 type = ERT_Series;
412 break; 364 break;
413 365
414 case ResourceType_Instance: 366 case ResourceType_Instance:
415 result = dataset.findAndGetOFString(DCM_SOPInstanceUID, id); 367 found = GetUtf8TagValue(id, dataset, encoding, DCM_SOPInstanceUID);
416 type = ERT_Image; 368 type = ERT_Image;
417 break; 369 break;
418 370
419 default: 371 default:
420 throw OrthancException(ErrorCode_InternalError); 372 throw OrthancException(ErrorCode_InternalError);
421 } 373 }
422 374
423 if (!result.good()) 375 if (!found)
424 { 376 {
425 throw OrthancException(ErrorCode_InternalError); 377 throw OrthancException(ErrorCode_BadFileFormat);
426 } 378 }
427 379
428 IndexKey key = std::make_pair(level, std::string(id.c_str())); 380 IndexKey key = std::make_pair(level, std::string(id.c_str()));
429 Index::iterator it = index_.find(key); 381 Index::iterator it = index_.find(key);
430 382
437 std::auto_ptr<DcmDirectoryRecord> record(new DcmDirectoryRecord(type, NULL, filename)); 389 std::auto_ptr<DcmDirectoryRecord> record(new DcmDirectoryRecord(type, NULL, filename));
438 390
439 switch (level) 391 switch (level)
440 { 392 {
441 case ResourceType_Patient: 393 case ResourceType_Patient:
442 FillPatient(*record, dataset); 394 FillPatient(*record, dataset, encoding);
443 break; 395 break;
444 396
445 case ResourceType_Study: 397 case ResourceType_Study:
446 FillStudy(*record, dataset); 398 FillStudy(*record, dataset, encoding);
447 break; 399 break;
448 400
449 case ResourceType_Series: 401 case ResourceType_Series:
450 FillSeries(*record, dataset); 402 FillSeries(*record, dataset, encoding);
451 break; 403 break;
452 404
453 case ResourceType_Instance: 405 case ResourceType_Instance:
454 FillInstance(*record, dataset, *dicom.getMetaInfo(), path); 406 FillInstance(*record, dataset, encoding, *dicom.GetDcmtkObject().getMetaInfo(), path);
455 break; 407 break;
456 408
457 default: 409 default:
458 throw OrthancException(ErrorCode_InternalError); 410 throw OrthancException(ErrorCode_InternalError);
459 } 411 }
460 412
461 if (record->isAffectedBySpecificCharacterSet()) 413 CopyStringType1C(*record, dataset, encoding, DCM_SpecificCharacterSet);
462 {
463 copyElementType1C(dataset, DCM_SpecificCharacterSet, *record);
464 }
465 414
466 target = record.get(); 415 target = record.get();
467 GetRoot().insertSub(record.release()); 416 GetRoot().insertSub(record.release());
468 index_[key] = target; 417 index_[key] = target;
469 418
525 } 474 }
526 475
527 path = directory + '\\' + filename; 476 path = directory + '\\' + filename;
528 } 477 }
529 478
530 DcmFileFormat& fileFormat = dicom.GetDcmtkObject();
531
532 DcmDirectoryRecord* instance; 479 DcmDirectoryRecord* instance;
533 bool isNewInstance = pimpl_->CreateResource(instance, ResourceType_Instance, fileFormat, filename.c_str(), path.c_str()); 480 bool isNewInstance = pimpl_->CreateResource(instance, ResourceType_Instance, dicom, filename.c_str(), path.c_str());
534 if (isNewInstance) 481 if (isNewInstance)
535 { 482 {
536 DcmDirectoryRecord* series; 483 DcmDirectoryRecord* series;
537 bool isNewSeries = pimpl_->CreateResource(series, ResourceType_Series, fileFormat, filename.c_str(), NULL); 484 bool isNewSeries = pimpl_->CreateResource(series, ResourceType_Series, dicom, filename.c_str(), NULL);
538 series->insertSub(instance); 485 series->insertSub(instance);
539 486
540 if (isNewSeries) 487 if (isNewSeries)
541 { 488 {
542 DcmDirectoryRecord* study; 489 DcmDirectoryRecord* study;
543 bool isNewStudy = pimpl_->CreateResource(study, ResourceType_Study, fileFormat, filename.c_str(), NULL); 490 bool isNewStudy = pimpl_->CreateResource(study, ResourceType_Study, dicom, filename.c_str(), NULL);
544 study->insertSub(series); 491 study->insertSub(series);
545 492
546 if (isNewStudy) 493 if (isNewStudy)
547 { 494 {
548 DcmDirectoryRecord* patient; 495 DcmDirectoryRecord* patient;
549 pimpl_->CreateResource(patient, ResourceType_Patient, fileFormat, filename.c_str(), NULL); 496 pimpl_->CreateResource(patient, ResourceType_Patient, dicom, filename.c_str(), NULL);
550 patient->insertSub(study); 497 patient->insertSub(study);
551 } 498 }
552 } 499 }
553 } 500 }
554 } 501 }