OFFIS DCMTK  Version 3.6.0
diinpxt.h
1 /*
2  *
3  * Copyright (C) 1996-2010, OFFIS e.V.
4  * All rights reserved. See COPYRIGHT file for details.
5  *
6  * This software and supporting documentation were developed by
7  *
8  * OFFIS e.V.
9  * R&D Division Health
10  * Escherweg 2
11  * D-26121 Oldenburg, Germany
12  *
13  *
14  * Module: dcmimgle
15  *
16  * Author: Joerg Riesmeier
17  *
18  * Purpose: DicomInputPixelTemplate (Header)
19  *
20  * Last Update: $Author: joergr $
21  * Update Date: $Date: 2010-10-14 13:16:26 $
22  * CVS/RCS Revision: $Revision: 1.42 $
23  * Status: $State: Exp $
24  *
25  * CVS/RCS Log at end of file
26  *
27  */
28 
29 
30 #ifndef DIINPXT_H
31 #define DIINPXT_H
32 
33 #include "dcmtk/config/osconfig.h"
34 #include "dcmtk/dcmdata/dcpixel.h"
35 
36 #include "dcmtk/ofstd/ofbmanip.h"
37 #include "dcmtk/ofstd/ofcast.h"
38 
39 #include "dcmtk/dcmimgle/diinpx.h"
40 #include "dcmtk/dcmimgle/didocu.h"
41 #include "dcmtk/dcmimgle/dipxrept.h"
42 
43 
44 /*--------------------*
45  * helper functions *
46  *--------------------*/
47 
48 static inline Uint8 expandSign(const Uint8 Value,
49  const Uint8,
50  const Uint8)
51 {
52  return Value;
53 }
54 
55 
56 static inline Uint16 expandSign(const Uint16 Value,
57  const Uint16,
58  const Uint16)
59 {
60  return Value;
61 }
62 
63 
64 static inline Uint32 expandSign(const Uint32 Value,
65  const Uint32,
66  const Uint32)
67 {
68  return Value;
69 }
70 
71 
72 static inline Sint8 expandSign(const Sint8 Value,
73  const Sint8 SignBit,
74  const Sint8 SignMask)
75 {
76  return (Value & SignBit) ? (Value | SignMask) : Value;
77 }
78 
79 
80 static inline Sint16 expandSign(const Sint16 Value,
81  const Sint16 SignBit,
82  const Sint16 SignMask)
83 {
84  return (Value & SignBit) ? (Value | SignMask) : Value;
85 }
86 
87 
88 static inline Sint32 expandSign(const Sint32 Value,
89  const Sint32 SignBit,
90  const Sint32 SignMask)
91 {
92  return (Value & SignBit) ? (Value | SignMask) : Value;
93 }
94 
95 
96 static Uint32 getPixelData(DcmPixelData *PixelData,
97  Uint8 *&pixel)
98 {
99  PixelData->getUint8Array(pixel);
100  return PixelData->getLength();
101 }
102 
103 
104 static Uint32 getPixelData(DcmPixelData *PixelData,
105  Uint16 *&pixel)
106 {
107  PixelData->getUint16Array(pixel);
108  return PixelData->getLength();
109 }
110 
111 
112 /*---------------------*
113  * class declaration *
114  *---------------------*/
115 
118 template<class T1, class T2>
120  : public DiInputPixel,
122 {
123 
124  public:
125 
139  const Uint16 alloc,
140  const Uint16 stored,
141  const Uint16 high,
142  const unsigned long first,
143  const unsigned long number,
144  const unsigned long fsize,
145  DcmFileCache *fileCache,
146  Uint32 &fragment)
147  : DiInputPixel(stored, first, number, fsize),
148  Data(NULL)
149  {
150  MinValue[0] = 0;
151  MinValue[1] = 0;
152  MaxValue[0] = 0;
153  MaxValue[1] = 0;
154  if (this->isSigned())
155  {
156  AbsMinimum = -OFstatic_cast(double, DicomImageClass::maxval(Bits - 1, 0));
157  AbsMaximum = OFstatic_cast(double, DicomImageClass::maxval(Bits - 1));
158  } else {
159  AbsMinimum = 0;
160  AbsMaximum = OFstatic_cast(double, DicomImageClass::maxval(Bits));
161  }
162  if ((document != NULL) && (document->getPixelData() != NULL))
163  convert(document, alloc, stored, high, fileCache, fragment);
164  if ((PixelCount == 0) || (PixelStart + PixelCount > Count)) // check for corrupt pixel length
165  {
167  DCMIMGLE_DEBUG("setting number of pixels to be processed (PixelCount) to: " << PixelCount);
168  }
169  }
170 
174  {
175  delete[] Data;
176  }
177 
183  {
184  if (Data != NULL)
185  {
186  DCMIMGLE_DEBUG("determining minimum and maximum pixel values for input data");
187  register T2 *p = Data;
188  register unsigned long i;
189  const unsigned long ocnt = OFstatic_cast(unsigned long, getAbsMaxRange());
190  Uint8 *lut = NULL;
191  if ((sizeof(T2) <= 2) && (Count > 3 * ocnt)) // optimization criteria
192  {
193  lut = new Uint8[ocnt];
194  if (lut != NULL)
195  {
196  DCMIMGLE_DEBUG("using optimized routine with additional LUT");
198  register Uint8 *q = lut - OFstatic_cast(T2, getAbsMinimum());
199  for (i = Count; i != 0; --i) // fill lookup table
200  *(q + *(p++)) = 1;
201  q = lut;
202  for (i = 0; i < ocnt; ++i) // search for minimum
203  {
204  if (*(q++) != 0)
205  {
206  MinValue[0] = OFstatic_cast(T2, OFstatic_cast(double, i) + getAbsMinimum());
207  break;
208  }
209  }
210  q = lut + ocnt;
211  for (i = ocnt; i != 0; --i) // search for maximum
212  {
213  if (*(--q) != 0)
214  {
215  MaxValue[0] = OFstatic_cast(T2, OFstatic_cast(double, i - 1) + getAbsMinimum());
216  break;
217  }
218  }
219  if (Count >= PixelCount) // use global min/max value
220  {
221  MinValue[1] = MinValue[0];
222  MaxValue[1] = MaxValue[0];
223  } else { // calculate min/max for selected range
225  p = Data + PixelStart;
226  q = lut - OFstatic_cast(T2, getAbsMinimum());
227  for (i = PixelCount; i != 0; --i) // fill lookup table
228  *(q + *(p++)) = 1;
229  q = lut;
230  for (i = 0; i < ocnt; ++i) // search for minimum
231  {
232  if (*(q++) != 0)
233  {
234  MinValue[1] = OFstatic_cast(T2, OFstatic_cast(double, i) + getAbsMinimum());
235  break;
236  }
237  }
238  q = lut + ocnt;
239  for (i = ocnt; i != 0; --i) // search for maximum
240  {
241  if (*(--q) != 0)
242  {
243  MaxValue[1] = OFstatic_cast(T2, OFstatic_cast(double, i - 1) + getAbsMinimum());
244  break;
245  }
246  }
247  }
248  }
249  }
250  if (lut == NULL) // use conventional method
251  {
252  register T2 value = *p;
253  MinValue[0] = value;
254  MaxValue[0] = value;
255  for (i = Count; i > 1; --i)
256  {
257  value = *(++p);
258  if (value < MinValue[0])
259  MinValue[0] = value;
260  else if (value > MaxValue[0])
261  MaxValue[0] = value;
262  }
263  if (Count <= PixelCount) // use global min/max value
264  {
265  MinValue[1] = MinValue[0];
266  MaxValue[1] = MaxValue[0];
267  } else { // calculate min/max for selected range
268  p = Data + PixelStart;
269  value = *p;
270  MinValue[1] = value;
271  MaxValue[1] = value;
272  for (i = PixelCount; i > 1; --i)
273  {
274  value = *(++p);
275  if (value < MinValue[1])
276  MinValue[1] = value;
277  else if (value > MaxValue[1])
278  MaxValue[1] = value;
279  }
280  }
281  }
282  delete[] lut;
283  return 1;
284  }
285  return 0;
286  }
287 
292  inline EP_Representation getRepresentation() const
293  {
295  }
296 
301  inline const void *getData() const
302  {
303  return OFstatic_cast(const void *, Data);
304  }
305 
310  virtual void *getDataPtr()
311  {
312  return OFstatic_cast(void *, Data);
313  }
314 
317  inline void removeDataReference()
318  {
319  Data = NULL;
320  }
321 
329  inline double getMinValue(const int idx) const
330  {
331  return (idx == 0) ? OFstatic_cast(double, MinValue[0]) : OFstatic_cast(double, MinValue[1]);
332  }
333 
341  inline double getMaxValue(const int idx) const
342  {
343  return (idx == 0) ? OFstatic_cast(double, MaxValue[0]) : OFstatic_cast(double, MaxValue[1]);
344  }
345 
346 
347  private:
348 
358  void convert(const DiDocument *document,
359  const Uint16 bitsAllocated,
360  const Uint16 bitsStored,
361  const Uint16 highBit,
362  DcmFileCache *fileCache,
363  Uint32 &fragment)
364  {
365  T1 *pixel = NULL;
366  OFBool deletePixel = OFFalse;
367  Uint32 lengthBytes = 0;
368  DcmPixelData *pixelData = document->getPixelData();
369  const Uint16 bitsof_T1 = bitsof(T1);
370  const Uint16 bitsof_T2 = bitsof(T2);
371  const OFBool uncompressed = pixelData->canWriteXfer(EXS_LittleEndianExplicit, EXS_Unknown);
372  /* check whether to use partial read */
373  if ((document->getFlags() & CIF_UsePartialAccessToPixelData) && (PixelCount > 0) &&
374  (!uncompressed || !pixelData->valueLoaded()) && (bitsAllocated % 8 == 0))
375  {
376  /* Bits Allocated is always a multiple of 8 (see above), same for bits of T1 */
377  const Uint32 byteFactor = bitsAllocated / 8;
378  const Uint32 bytes_T1 = bitsof_T1 / 8;
379  const Uint32 count_T1 = (byteFactor == bytes_T1) ? PixelCount : (PixelCount * byteFactor + bytes_T1 - 1) / bytes_T1;
380 #ifdef DEBUG
381  DCMIMGLE_TRACE("PixelCount: " << PixelCount << ", byteFactor: " << byteFactor << ", bytes_T1: " << bytes_T1 << ", count_T1: " << count_T1);
382 #endif
383  /* allocate temporary buffer, even number of bytes required for getUncompressedFrame() */
384  const Uint32 extraByte = ((sizeof(T1) == 1) && (count_T1 & 1)) ? 1 : 0;
385  pixel = new T1[count_T1 + extraByte];
386  if (pixel != NULL)
387  {
388  if (uncompressed)
389  {
390  DCMIMGLE_DEBUG("using partial read access to uncompressed pixel data");
391  const Uint32 offset = PixelStart * byteFactor;
392  const Uint32 bufSize = PixelCount * byteFactor;
393  const OFCondition status = pixelData->getPartialValue(pixel, offset, bufSize, fileCache);
394  if (status.good())
395  {
396  PixelStart = 0;
397  lengthBytes = bufSize;
398  } else {
399  DCMIMGLE_ERROR("can't access partial value from byte offset " << offset << " to "
400  << (offset + bufSize - 1) << ": " << status.text());
401  }
402  } else {
403  DCMIMGLE_DEBUG("using partial read access to compressed pixel data");
404  OFCondition status = EC_IllegalCall;
405  OFString decompressedColorModel;
406  const Uint32 fsize = FrameSize * byteFactor;
407  for (Uint32 frame = 0; frame < NumberOfFrames; ++frame)
408  {
409  /* make sure that the buffer always has an even number of bytes as required for getUncompressedFrame() */
410  const Uint32 bufSize = (fsize & 1) ? fsize + 1 : fsize;
411  status = pixelData->getUncompressedFrame(document->getDataset(), FirstFrame + frame, fragment,
412  OFreinterpret_cast(Uint8 *, pixel) + lengthBytes, bufSize, decompressedColorModel, fileCache);
413  if (status.good())
414  {
415  DCMIMGLE_TRACE("successfully decompressed frame " << FirstFrame + frame);
416  lengthBytes += fsize;
417  } else {
418  DCMIMGLE_ERROR("can't decompress frame " << FirstFrame + frame << ": " << status.text());
419  break;
420  }
421  }
422  if (status.good())
423  PixelStart = 0;
424  /* check whether color model changed during decompression */
425  if (!decompressedColorModel.empty() && (decompressedColorModel != document->getPhotometricInterpretation()))
426  {
427  DCMIMGLE_WARN("Photometric Interpretation of decompressed pixel data deviates from original image: "
428  << decompressedColorModel);
429  }
430  }
431  deletePixel = OFTrue;
432  }
433  } else {
434  DCMIMGLE_DEBUG("reading uncompressed pixel data completely into memory");
435  /* always access complete pixel data */
436  lengthBytes = getPixelData(pixelData, pixel);
437  }
438  if ((pixel != NULL) && (lengthBytes > 0))
439  {
440  const Uint32 length_T1 = lengthBytes / sizeof(T1);
441  /* need to split 'length' in order to avoid integer overflow for large pixel data */
442  const Uint32 length_B1 = lengthBytes / bitsAllocated;
443  const Uint32 length_B2 = lengthBytes % bitsAllocated;
444 // # old code: Count = ((lengthBytes * 8) + bitsAllocated - 1) / bitsAllocated;
445  Count = 8 * length_B1 + (8 * length_B2 + bitsAllocated - 1) / bitsAllocated;
446  register unsigned long i;
447  Data = new T2[Count];
448  if (Data != NULL)
449  {
450  DCMIMGLE_TRACE("Input length: " << lengthBytes << " bytes, Pixel count: " << Count
451  << " (" << PixelCount << "), In: " << bitsof_T1 << " bits, Out: " << bitsof_T2
452  << " bits (" << (this->isSigned() ? "signed" : "unsigned") << ")");
453  register const T1 *p = pixel;
454  register T2 *q = Data;
455  if (bitsof_T1 == bitsAllocated) // case 1: equal 8/16 bit
456  {
457  if (bitsStored == bitsAllocated)
458  {
459  DCMIMGLE_DEBUG("convert input pixel data: case 1a (single copy)");
460  for (i = Count; i != 0; --i)
461  *(q++) = OFstatic_cast(T2, *(p++));
462  }
463  else /* bitsStored < bitsAllocated */
464  {
465  register T1 mask = 0;
466  for (i = 0; i < bitsStored; ++i)
467  mask |= OFstatic_cast(T1, 1 << i);
468  const T2 sign = 1 << (bitsStored - 1);
469  T2 smask = 0;
470  for (i = bitsStored; i < bitsof_T2; ++i)
471  smask |= OFstatic_cast(T2, 1 << i);
472  const Uint16 shift = highBit + 1 - bitsStored;
473  if (shift == 0)
474  {
475  DCMIMGLE_DEBUG("convert input pixel data: case 1b (mask & sign)");
476  for (i = length_T1; i != 0; --i)
477  *(q++) = expandSign(OFstatic_cast(T2, *(p++) & mask), sign, smask);
478  }
479  else /* shift > 0 */
480  {
481  DCMIMGLE_DEBUG("convert input pixel data: case 1c (shift & mask & sign)");
482  for (i = length_T1; i != 0; --i)
483  *(q++) = expandSign(OFstatic_cast(T2, (*(p++) >> shift) & mask), sign, smask);
484  }
485  }
486  }
487  else if ((bitsof_T1 > bitsAllocated) && (bitsof_T1 % bitsAllocated == 0)) // case 2: divisor of 8/16 bit
488  {
489  const Uint16 times = bitsof_T1 / bitsAllocated;
490  register T1 mask = 0;
491  for (i = 0; i < bitsStored; ++i)
492  mask |= OFstatic_cast(T1, 1 << i);
493  register Uint16 j;
494  register T1 value;
495  if ((bitsStored == bitsAllocated) && (bitsStored == bitsof_T2))
496  {
497  if (times == 2)
498  {
499  DCMIMGLE_DEBUG("convert input pixel data: case 2a (simple mask)");
500  for (i = length_T1; i != 0; --i, ++p)
501  {
502  *(q++) = OFstatic_cast(T2, *p & mask);
503  *(q++) = OFstatic_cast(T2, *p >> bitsAllocated);
504  }
505  }
506  else
507  {
508  DCMIMGLE_DEBUG("convert input pixel data: case 2b (mask)");
509  for (i = length_T1; i != 0; --i)
510  {
511  value = *(p++);
512  for (j = times; j != 0; --j)
513  {
514  *(q++) = OFstatic_cast(T2, value & mask);
515  value >>= bitsAllocated;
516  }
517  }
518  }
519  }
520  else
521  {
522  DCMIMGLE_DEBUG("convert input pixel data: case 2c (shift & mask & sign)");
523  const T2 sign = 1 << (bitsStored - 1);
524  T2 smask = 0;
525  for (i = bitsStored; i < bitsof_T2; ++i)
526  smask |= OFstatic_cast(T2, 1 << i);
527  const Uint16 shift = highBit + 1 - bitsStored;
528  for (i = length_T1; i != 0; --i)
529  {
530  value = *(p++) >> shift;
531  for (j = times; j != 0; --j)
532  {
533  *(q++) = expandSign(OFstatic_cast(T2, value & mask), sign, smask);
534  value >>= bitsAllocated;
535  }
536  }
537  }
538  }
539  else if ((bitsof_T1 < bitsAllocated) && (bitsAllocated % bitsof_T1 == 0) // case 3: multiplicant of 8/16
540  && (bitsStored == bitsAllocated))
541  {
542  DCMIMGLE_DEBUG("convert input pixel data: case 3 (multi copy)");
543  const Uint16 times = bitsAllocated / bitsof_T1;
544  register Uint16 j;
545  register Uint16 shift;
546  register T2 value;
547  for (i = length_T1; i != 0; --i)
548  {
549  shift = 0;
550  value = OFstatic_cast(T2, *(p++));
551  for (j = times; j > 1; --j, --i)
552  {
553  shift += bitsof_T1;
554  value |= OFstatic_cast(T2, *(p++)) << shift;
555  }
556  *(q++) = value;
557  }
558  }
559  else // case 4: anything else
560  {
561  DCMIMGLE_DEBUG("convert input pixel data: case 4 (general)");
562  register T2 value = 0;
563  register Uint16 bits = 0;
564  register Uint32 skip = highBit + 1 - bitsStored;
565  register Uint32 times;
566  T1 mask[bitsof_T1];
567  mask[0] = 1;
568  for (i = 1; i < bitsof_T1; ++i)
569  mask[i] = (mask[i - 1] << 1) | 1;
570  T2 smask = 0;
571  for (i = bitsStored; i < bitsof_T2; ++i)
572  smask |= OFstatic_cast(T2, 1 << i);
573  const T2 sign = 1 << (bitsStored - 1);
574  const Uint32 gap = bitsAllocated - bitsStored;
575  i = 0;
576  while (i < length_T1)
577  {
578  if (skip < bitsof_T1)
579  {
580  if (skip + bitsStored - bits < bitsof_T1) // -++- --++
581  {
582  value |= (OFstatic_cast(T2, (*p >> skip) & mask[bitsStored - bits - 1]) << bits);
583  skip += bitsStored - bits + gap;
584  bits = bitsStored;
585  }
586  else // ++-- ++++
587  {
588  value |= (OFstatic_cast(T2, (*p >> skip) & mask[bitsof_T1 - skip - 1]) << bits);
589  bits += bitsof_T1 - OFstatic_cast(Uint16, skip);
590  skip = (bits == bitsStored) ? gap : 0;
591  ++i;
592  ++p;
593  }
594  if (bits == bitsStored)
595  {
596  *(q++) = expandSign(value, sign, smask);
597  value = 0;
598  bits = 0;
599  }
600  }
601  else
602  {
603  times = skip / bitsof_T1;
604  i += times;
605  p += times;
606  skip -= times * bitsof_T1;
607  }
608  }
609  }
610  }
611  } else {
612  // in case of error, reset pixel count variable
613  Count = 0;
614  }
615  if (deletePixel)
616  {
617  // delete temporary buffer
618  delete[] pixel;
619  }
620  }
621 
623  T2 *Data;
624 
626  T2 MinValue[2];
628  T2 MaxValue[2];
629 
630  // --- declarations to avoid compiler warnings
631 
634 };
635 
636 
637 #endif
638 
639 
640 /*
641  *
642  * CVS/RCS Log:
643  * $Log: diinpxt.h,v $
644  * Revision 1.42 2010-10-14 13:16:26 joergr
645  * Updated copyright header. Added reference to COPYRIGHT file.
646  *
647  * Revision 1.41 2010-07-22 10:27:30 joergr
648  * Made sure that the size of the buffer for partial access to pixel data is
649  * always an even number of bytes.
650  *
651  * Revision 1.40 2010-04-16 12:56:46 joergr
652  * Further enhanced computation of buffer size when using partial read access
653  * to pixel data. Now also some rare cases of BitsAllocated are supported.
654  *
655  * Revision 1.39 2010-04-15 14:18:36 joergr
656  * Fixed possibly wrong computation of a buffer size when using partial read
657  * access to pixel data. This could lead to a crash under certain conditions.
658  *
659  * Revision 1.38 2010-03-01 09:08:46 uli
660  * Removed some unnecessary include directives in the headers.
661  *
662  * Revision 1.37 2009-11-25 16:05:40 joergr
663  * Adapted code for new approach to access individual frames of a DICOM image.
664  * Added more logging messages. Revised logging messages.
665  *
666  * Revision 1.36 2009-10-28 14:38:16 joergr
667  * Fixed minor issues in log output.
668  *
669  * Revision 1.35 2009-10-28 09:53:40 uli
670  * Switched to logging mechanism provided by the "new" oflog module.
671  *
672  * Revision 1.34 2007-08-30 13:39:30 joergr
673  * Added further check on pixel pointer (possibly avoids crash under certain
674  * conditions).
675  *
676  * Revision 1.33 2006/10/27 14:59:26 joergr
677  * Fixed possible integer overflow for images with very large pixel data.
678  *
679  * Revision 1.32 2006/08/15 16:30:11 meichel
680  * Updated the code in module dcmimgle to correctly compile when
681  * all standard C++ classes remain in namespace std.
682  *
683  * Revision 1.31 2006/01/17 18:35:42 joergr
684  * Fixed compilation problem with gcc 4.0 on Linux x86_64.
685  *
686  * Revision 1.30 2005/12/08 16:47:44 meichel
687  * Changed include path schema for all DCMTK header files
688  *
689  * Revision 1.29 2004/04/21 10:00:36 meichel
690  * Minor modifications for compilation with gcc 3.4.0
691  *
692  * Revision 1.28 2004/02/06 11:07:50 joergr
693  * Distinguish more clearly between const and non-const access to pixel data.
694  *
695  * Revision 1.27 2004/01/05 14:52:20 joergr
696  * Removed acknowledgements with e-mail addresses from CVS log.
697  *
698  * Revision 1.26 2003/12/23 15:53:22 joergr
699  * Replaced post-increment/decrement operators by pre-increment/decrement
700  * operators where appropriate (e.g. 'i++' by '++i').
701  *
702  * Revision 1.25 2003/12/08 19:10:52 joergr
703  * Adapted type casts to new-style typecast operators defined in ofcast.h.
704  * Removed leading underscore characters from preprocessor symbols (reserved
705  * symbols). Updated copyright header.
706  *
707  * Revision 1.24 2002/10/21 10:13:50 joergr
708  * Corrected wrong calculation of min/max pixel value in cases where the
709  * stored pixel data exceeds the expected size.
710  *
711  * Revision 1.23 2001/11/13 18:07:36 joergr
712  * Fixed bug occurring when processing monochrome images with an odd number of
713  * pixels.
714  *
715  * Revision 1.22 2001/10/10 15:25:09 joergr
716  * Removed redundant variable declarations to avoid compiler warnings
717  * ("declaration of ... shadows previous local").
718  *
719  * Revision 1.21 2001/09/28 13:04:59 joergr
720  * Enhanced algorithm to determine the min and max value.
721  *
722  * Revision 1.20 2001/06/01 15:49:42 meichel
723  * Updated copyright header
724  *
725  * Revision 1.19 2000/05/03 09:46:28 joergr
726  * Removed most informational and some warning messages from release built
727  * (#ifndef DEBUG).
728  *
729  * Revision 1.18 2000/04/28 12:32:30 joergr
730  * DebugLevel - global for the module - now derived from OFGlobal (MF-safe).
731  *
732  * Revision 1.17 2000/04/27 13:08:39 joergr
733  * Dcmimgle library code now consistently uses ofConsole for error output.
734  *
735  * Revision 1.16 2000/03/08 16:24:17 meichel
736  * Updated copyright header.
737  *
738  * Revision 1.15 2000/03/03 14:09:12 meichel
739  * Implemented library support for redirecting error messages into memory
740  * instead of printing them to stdout/stderr for GUI applications.
741  *
742  * Revision 1.14 1999/09/17 12:21:57 joergr
743  * Added/changed/completed DOC++ style comments in the header files.
744  * Enhanced efficiency of some "for" loops and of the implementation to
745  * determine min/max values of the input pixels.
746  *
747  * Revision 1.13 1999/07/23 13:54:38 joergr
748  * Optimized memory usage for converting input pixel data (reference instead
749  * of copying where possible).
750  *
751  * Revision 1.12 1999/05/04 09:20:39 meichel
752  * Minor code purifications to keep IBM xlC quiet
753  *
754  * Revision 1.11 1999/04/30 16:23:59 meichel
755  * Minor code purifications to keep IBM xlC quiet
756  *
757  * Revision 1.10 1999/04/28 14:48:39 joergr
758  * Introduced new scheme for the debug level variable: now each level can be
759  * set separately (there is no "include" relationship).
760  *
761  * Revision 1.9 1999/03/24 17:20:03 joergr
762  * Added/Modified comments and formatting.
763  *
764  * Revision 1.8 1999/02/11 16:00:54 joergr
765  * Removed inline declarations from several methods.
766  *
767  * Revision 1.7 1999/02/03 17:04:37 joergr
768  * Moved global functions maxval() and determineRepresentation() to class
769  * DicomImageClass (as static methods).
770  *
771  * Revision 1.6 1999/01/20 15:01:31 joergr
772  * Replaced invocation of getCount() by member variable Count where possible.
773  *
774  * Revision 1.5 1999/01/11 09:34:28 joergr
775  * Corrected bug in determing 'AbsMaximum' (removed '+ 1').
776  *
777  * Revision 1.4 1998/12/22 14:23:16 joergr
778  * Added calculation of member variables AbsMinimum/AbsMaximum.
779  * Replaced method copyMem by for-loop copying each item.
780  * Removed some '#ifdef DEBUG'.
781  *
782  * Revision 1.3 1998/12/16 16:30:34 joergr
783  * Added methods to determine absolute minimum and maximum value for given
784  * value representation.
785  *
786  * Revision 1.2 1998/12/14 17:18:23 joergr
787  * Reformatted source code.
788  *
789  * Revision 1.1 1998/11/27 15:08:21 joergr
790  * Added copyright message.
791  * Introduced global debug level for dcmimage module to control error output.
792  * Added support for new bit manipulation class.
793  *
794  * Revision 1.8 1998/07/01 08:39:21 joergr
795  * Minor changes to avoid compiler warnings (gcc 2.8.1 with additional
796  * options), e.g. add copy constructors.
797  *
798  * Revision 1.7 1998/05/11 14:53:17 joergr
799  * Added CVS/RCS header to each file.
800  *
801  *
802  */


Generated on Thu Dec 20 2012 for OFFIS DCMTK Version 3.6.0 by Doxygen 1.8.2