Mercurial > hg > orthanc

comparison OrthancFramework/Sources/DicomFormat/DicomStreamReader.cpp @ 4222:7461f98c23a0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
remove debug printf from DicomStreamReader
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 30 Sep 2020 15:53:17 +0200
parents e4c0218b6b23
children c5ca798b158a
comparison
equal deleted inserted replaced
4221:e4c0218b6b23 4222:7461f98c23a0
138 vr == ValueRepresentation_UnsignedLong /* UL */ || 138 vr == ValueRepresentation_UnsignedLong /* UL */ ||
139 vr == ValueRepresentation_UnsignedShort /* US */); 139 vr == ValueRepresentation_UnsignedShort /* US */);
140 } 140 }
141 141
142 142
143 static void PrintBlock(const std::string& block)
144 {
145 for (size_t i = 0; i < block.size(); i++)
146 {
147 printf("%02x ", static_cast<uint8_t>(block[i]));
148 if (i % 16 == 15)
149 printf("\n");
150 }
151 printf("\n");
152 }
153
154
155
156 bool DicomStreamReader::IsLittleEndian() const 143 bool DicomStreamReader::IsLittleEndian() const
157 { 144 {
158 return (transferSyntax_ != DicomTransferSyntax_BigEndianExplicit); 145 return (transferSyntax_ != DicomTransferSyntax_BigEndianExplicit);
159 } 146 }
160 147
161 148
162 void DicomStreamReader::HandlePreamble(IVisitor& visitor, 149 void DicomStreamReader::HandlePreamble(IVisitor& visitor,
163 const std::string& block) 150 const std::string& block)
164 { 151 {
165 //printf("PREAMBLE:\n");
166 //PrintBlock(block);
167
168 assert(block.size() == 144u); 152 assert(block.size() == 144u);
169 assert(reader_.GetProcessedBytes() == 144u); 153 assert(reader_.GetProcessedBytes() == 144u);
170 154
171 /** 155 /**
172 * The "DICOM file meta information" is always encoded using 156 * The "DICOM file meta information" is always encoded using
193 177
194 178
195 void DicomStreamReader::HandleMetaHeader(IVisitor& visitor, 179 void DicomStreamReader::HandleMetaHeader(IVisitor& visitor,
196 const std::string& block) 180 const std::string& block)
197 { 181 {
198 //printf("META-HEADER:\n");
199 //PrintBlock(block);
200
201 size_t pos = 0; 182 size_t pos = 0;
202 const char* p = block.c_str(); 183 const char* p = block.c_str();
203 184
204 bool hasTransferSyntax = false; 185 bool hasTransferSyntax = false;
205 186
296 277
297 if (tag == DICOM_TAG_SEQUENCE_ITEM || 278 if (tag == DICOM_TAG_SEQUENCE_ITEM ||
298 tag == DICOM_TAG_SEQUENCE_DELIMITATION_ITEM || 279 tag == DICOM_TAG_SEQUENCE_DELIMITATION_ITEM ||
299 tag == DICOM_TAG_SEQUENCE_DELIMITATION_SEQUENCE) 280 tag == DICOM_TAG_SEQUENCE_DELIMITATION_SEQUENCE)
300 { 281 {
301 //printf("SEQUENCE TAG:\n");
302 //PrintBlock(block);
303
304 // The special sequence items are encoded like "Implicit VR" 282 // The special sequence items are encoded like "Implicit VR"
305 uint32_t length = ReadUnsignedInteger32(block.c_str() + 4, littleEndian); 283 uint32_t length = ReadUnsignedInteger32(block.c_str() + 4, littleEndian);
306 284
307 if (tag == DICOM_TAG_SEQUENCE_ITEM) 285 if (tag == DICOM_TAG_SEQUENCE_ITEM)
308 { 286 {
309 for (unsigned int i = 0; i <= sequenceDepth_; i++)
310 printf(" ");
311 if (length == 0xffffffffu) 287 if (length == 0xffffffffu)
312 { 288 {
313 // Undefined length: Need to loop over the tags of the nested dataset 289 // Undefined length: Need to loop over the tags of the nested dataset
314 printf("...next dataset in sequence...\n");
315 reader_.Schedule(8); 290 reader_.Schedule(8);
316 state_ = State_DatasetTag; 291 state_ = State_DatasetTag;
317 } 292 }
318 else 293 else
319 { 294 {
320 // Explicit length: Can skip the full sequence at once 295 // Explicit length: Can skip the full sequence at once
321 printf("...next dataset in sequence... %u bytes\n", length);
322 reader_.Schedule(length); 296 reader_.Schedule(length);
323 state_ = State_DatasetValue; 297 state_ = State_DatasetValue;
324 } 298 }
325 } 299 }
326 else if (tag == DICOM_TAG_SEQUENCE_DELIMITATION_ITEM || 300 else if (tag == DICOM_TAG_SEQUENCE_DELIMITATION_ITEM ||
332 throw OrthancException(ErrorCode_BadFileFormat); 306 throw OrthancException(ErrorCode_BadFileFormat);
333 } 307 }
334 308
335 if (tag == DICOM_TAG_SEQUENCE_DELIMITATION_SEQUENCE) 309 if (tag == DICOM_TAG_SEQUENCE_DELIMITATION_SEQUENCE)
336 { 310 {
337 for (unsigned int i = 0; i < sequenceDepth_; i++)
338 printf(" ");
339 printf("...leaving sequence...\n");
340
341 sequenceDepth_ --; 311 sequenceDepth_ --;
342 }
343 else
344 {
345 if (sequenceDepth_ == 0)
346 {
347 throw OrthancException(ErrorCode_BadFileFormat);
348 }
349 } 312 }
350 313
351 reader_.Schedule(8); 314 reader_.Schedule(8);
352 state_ = State_DatasetTag; 315 state_ = State_DatasetTag;
353 } 316 }
356 throw OrthancException(ErrorCode_InternalError); 319 throw OrthancException(ErrorCode_InternalError);
357 } 320 }
358 } 321 }
359 else 322 else
360 { 323 {
361 //printf("DATASET TAG:\n");
362 //PrintBlock(block);
363
364 previousTag_ = tag;
365
366 ValueRepresentation vr = ValueRepresentation_Unknown; 324 ValueRepresentation vr = ValueRepresentation_Unknown;
367 325
368 if (transferSyntax_ == DicomTransferSyntax_LittleEndianImplicit) 326 if (transferSyntax_ == DicomTransferSyntax_LittleEndianImplicit)
369 { 327 {
370 if (sequenceDepth_ == 0) 328 if (sequenceDepth_ == 0)
381 // This in an explicit transfer syntax 339 // This in an explicit transfer syntax
382 340
383 vr = StringToValueRepresentation( 341 vr = StringToValueRepresentation(
384 std::string(block.c_str() + 4, 2), false /* ignore unknown VR */); 342 std::string(block.c_str() + 4, 2), false /* ignore unknown VR */);
385 343
386 if (vr != ValueRepresentation_Sequence &&
387 sequenceDepth_ > 0)
388 {
389 for (unsigned int i = 0; i <= sequenceDepth_; i++)
390 printf(" ");
391 printf("%s\n", tag.Format().c_str());
392 }
393
394 if (vr == ValueRepresentation_Sequence) 344 if (vr == ValueRepresentation_Sequence)
395 { 345 {
396 for (unsigned int i = 0; i <= sequenceDepth_; i++)
397 printf(" ");
398 printf("...entering sequence... %s\n", tag.Format().c_str());
399 sequenceDepth_ ++; 346 sequenceDepth_ ++;
400 reader_.Schedule(4); 347 reader_.Schedule(4);
401 state_ = State_SequenceExplicitLength; 348 state_ = State_SequenceExplicitLength;
402 } 349 }
403 else if (IsShortExplicitTag(vr)) 350 else if (IsShortExplicitTag(vr))
437 * This is the case of pixel data with compressed transfer 384 * This is the case of pixel data with compressed transfer
438 * syntaxes. Schedule the reading of the first tag of the 385 * syntaxes. Schedule the reading of the first tag of the
439 * nested dataset. 386 * nested dataset.
440 * http://dicom.nema.org/medical/dicom/current/output/chtml/part05/sect_7.5.html 387 * http://dicom.nema.org/medical/dicom/current/output/chtml/part05/sect_7.5.html
441 **/ 388 **/
442
443 for (unsigned int i = 0; i <= sequenceDepth_; i++)
444 printf(" ");
445 printf("...entering sequence... %s\n", previousTag_.Format().c_str());
446
447 state_ = State_DatasetTag; 389 state_ = State_DatasetTag;
448 reader_.Schedule(8); 390 reader_.Schedule(8);
449 sequenceDepth_ ++; 391 sequenceDepth_ ++;
450 } 392 }
451 else 393 else
456 } 398 }
457 399
458 400
459 void DicomStreamReader::HandleDatasetExplicitLength(const std::string& block) 401 void DicomStreamReader::HandleDatasetExplicitLength(const std::string& block)
460 { 402 {
461 //printf("DATASET TAG LENGTH:\n");
462 //PrintBlock(block);
463
464 assert(block.size() == 4); 403 assert(block.size() == 4);
465 404
466 uint32_t length = ReadUnsignedInteger32(block.c_str(), IsLittleEndian()); 405 uint32_t length = ReadUnsignedInteger32(block.c_str(), IsLittleEndian());
467 HandleDatasetExplicitLength(length); 406 HandleDatasetExplicitLength(length);
468 } 407 }
469 408
470 409
471 void DicomStreamReader::HandleSequenceExplicitLength(const std::string& block) 410 void DicomStreamReader::HandleSequenceExplicitLength(const std::string& block)
472 { 411 {
473 //printf("DATASET TAG LENGTH:\n");
474 //PrintBlock(block);
475
476 assert(block.size() == 4); 412 assert(block.size() == 4);
477 413
478 uint32_t length = ReadUnsignedInteger32(block.c_str(), IsLittleEndian()); 414 uint32_t length = ReadUnsignedInteger32(block.c_str(), IsLittleEndian());
479 if (length == 0xffffffffu) 415 if (length == 0xffffffffu)
480 { 416 {
481 state_ = State_DatasetTag; 417 state_ = State_DatasetTag;
482 reader_.Schedule(8); 418 reader_.Schedule(8);
483 } 419 }
484 else 420 else
485 { 421 {
486 for (unsigned int i = 0; i <= sequenceDepth_; i++)
487 printf(" ");
488 printf("...skipping sequence thanks to explicit length... %d\n", length);
489
490 reader_.Schedule(length); 422 reader_.Schedule(length);
491 state_ = State_SequenceExplicitValue; 423 state_ = State_SequenceExplicitValue;
492 } 424 }
493 } 425 }
494 426
538 470
539 DicomStreamReader::DicomStreamReader(std::istream& stream) : 471 DicomStreamReader::DicomStreamReader(std::istream& stream) :
540 reader_(stream), 472 reader_(stream),
541 state_(State_Preamble), 473 state_(State_Preamble),
542 transferSyntax_(DicomTransferSyntax_LittleEndianImplicit), // Dummy 474 transferSyntax_(DicomTransferSyntax_LittleEndianImplicit), // Dummy
543 previousTag_(0x0000, 0x0000), // Dummy
544 danglingTag_(0x0000, 0x0000), // Dummy 475 danglingTag_(0x0000, 0x0000), // Dummy
545 danglingVR_(ValueRepresentation_Unknown), // Dummy 476 danglingVR_(ValueRepresentation_Unknown), // Dummy
546 sequenceDepth_(0) 477 sequenceDepth_(0)
547 { 478 {
548 reader_.Schedule(128 /* empty header */ + 479 reader_.Schedule(128 /* empty header */ +