granicus.if.org Git - imagemagick/blob - coders/dcm.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                            DDDD    CCCC  M   M                              %
   7 %                            D   D  C      MM MM                              %
   8 %                            D   D  C      M M M                              %
   9 %                            D   D  C      M   M                              %
  10 %                            DDDD    CCCC  M   M                              %
  11 %                                                                             %
  12 %                                                                             %
  13 %                          Read DICOM Image Format                            %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                 July 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  42 #include "MagickCore/studio.h"
  43 #include "MagickCore/property.h"
  44 #include "MagickCore/blob.h"
  45 #include "MagickCore/blob-private.h"
  46 #include "MagickCore/cache.h"
  47 #include "MagickCore/color.h"
  48 #include "MagickCore/color-private.h"
  49 #include "MagickCore/colormap.h"
  50 #include "MagickCore/colormap-private.h"
  51 #include "MagickCore/constitute.h"
  52 #include "MagickCore/enhance.h"
  53 #include "MagickCore/exception.h"
  54 #include "MagickCore/exception-private.h"
  55 #include "MagickCore/image.h"
  56 #include "MagickCore/image-private.h"
  57 #include "MagickCore/list.h"
  58 #include "MagickCore/magick.h"
  59 #include "MagickCore/memory_.h"
  60 #include "MagickCore/monitor.h"
  61 #include "MagickCore/monitor-private.h"
  62 #include "MagickCore/option.h"
  63 #include "MagickCore/pixel-accessor.h"
  64 #include "MagickCore/resource_.h"
  65 #include "MagickCore/quantum-private.h"
  66 #include "MagickCore/static.h"
  67 #include "MagickCore/string_.h"
  68 #include "MagickCore/string-private.h"
  69 #include "MagickCore/module.h"
  70 \f
  71 /*
  72   Dicom medical image declarations.
  73 */
  74
  75 typedef struct _DicomInfo
  76 {
  77   unsigned short
  78     group,
  79     element;
  80
  81   const char
  82     *vr,
  83     *description;
  84 } DicomInfo;
  85
  86 static const DicomInfo
  87   dicom_info[] =
  88   {
  89     { 0x0000, 0x0000, "UL", "Group Length" },
  90     { 0x0000, 0x0001, "UL", "Command Length to End" },
  91     { 0x0000, 0x0002, "UI", "Affected SOP Class UID" },
  92     { 0x0000, 0x0003, "UI", "Requested SOP Class UID" },
  93     { 0x0000, 0x0010, "LO", "Command Recognition Code" },
  94     { 0x0000, 0x0100, "US", "Command Field" },
  95     { 0x0000, 0x0110, "US", "Message ID" },
  96     { 0x0000, 0x0120, "US", "Message ID Being Responded To" },
  97     { 0x0000, 0x0200, "AE", "Initiator" },
  98     { 0x0000, 0x0300, "AE", "Receiver" },
  99     { 0x0000, 0x0400, "AE", "Find Location" },
 100     { 0x0000, 0x0600, "AE", "Move Destination" },
 101     { 0x0000, 0x0700, "US", "Priority" },
 102     { 0x0000, 0x0800, "US", "Data Set Type" },
 103     { 0x0000, 0x0850, "US", "Number of Matches" },
 104     { 0x0000, 0x0860, "US", "Response Sequence Number" },
 105     { 0x0000, 0x0900, "US", "Status" },
 106     { 0x0000, 0x0901, "AT", "Offending Element" },
 107     { 0x0000, 0x0902, "LO", "Exception Comment" },
 108     { 0x0000, 0x0903, "US", "Exception ID" },
 109     { 0x0000, 0x1000, "UI", "Affected SOP Instance UID" },
 110     { 0x0000, 0x1001, "UI", "Requested SOP Instance UID" },
 111     { 0x0000, 0x1002, "US", "Event Type ID" },
 112     { 0x0000, 0x1005, "AT", "Attribute Identifier List" },
 113     { 0x0000, 0x1008, "US", "Action Type ID" },
 114     { 0x0000, 0x1020, "US", "Number of Remaining Suboperations" },
 115     { 0x0000, 0x1021, "US", "Number of Completed Suboperations" },
 116     { 0x0000, 0x1022, "US", "Number of Failed Suboperations" },
 117     { 0x0000, 0x1023, "US", "Number of Warning Suboperations" },
 118     { 0x0000, 0x1030, "AE", "Move Originator Application Entity Title" },
 119     { 0x0000, 0x1031, "US", "Move Originator Message ID" },
 120     { 0x0000, 0x4000, "LO", "Dialog Receiver" },
 121     { 0x0000, 0x4010, "LO", "Terminal Type" },
 122     { 0x0000, 0x5010, "SH", "Message Set ID" },
 123     { 0x0000, 0x5020, "SH", "End Message Set" },
 124     { 0x0000, 0x5110, "LO", "Display Format" },
 125     { 0x0000, 0x5120, "LO", "Page Position ID" },
 126     { 0x0000, 0x5130, "LO", "Text Format ID" },
 127     { 0x0000, 0x5140, "LO", "Normal Reverse" },
 128     { 0x0000, 0x5150, "LO", "Add Gray Scale" },
 129     { 0x0000, 0x5160, "LO", "Borders" },
 130     { 0x0000, 0x5170, "IS", "Copies" },
 131     { 0x0000, 0x5180, "LO", "OldMagnificationType" },
 132     { 0x0000, 0x5190, "LO", "Erase" },
 133     { 0x0000, 0x51a0, "LO", "Print" },
 134     { 0x0000, 0x51b0, "US", "Overlays" },
 135     { 0x0002, 0x0000, "UL", "Meta Element Group Length" },
 136     { 0x0002, 0x0001, "OB", "File Meta Information Version" },
 137     { 0x0002, 0x0002, "UI", "Media Storage SOP Class UID" },
 138     { 0x0002, 0x0003, "UI", "Media Storage SOP Instance UID" },
 139     { 0x0002, 0x0010, "UI", "Transfer Syntax UID" },
 140     { 0x0002, 0x0012, "UI", "Implementation Class UID" },
 141     { 0x0002, 0x0013, "SH", "Implementation Version Name" },
 142     { 0x0002, 0x0016, "AE", "Source Application Entity Title" },
 143     { 0x0002, 0x0100, "UI", "Private Information Creator UID" },
 144     { 0x0002, 0x0102, "OB", "Private Information" },
 145     { 0x0003, 0x0000, "US", "?" },
 146     { 0x0003, 0x0008, "US", "ISI Command Field" },
 147     { 0x0003, 0x0011, "US", "Attach ID Application Code" },
 148     { 0x0003, 0x0012, "UL", "Attach ID Message Count" },
 149     { 0x0003, 0x0013, "DA", "Attach ID Date" },
 150     { 0x0003, 0x0014, "TM", "Attach ID Time" },
 151     { 0x0003, 0x0020, "US", "Message Type" },
 152     { 0x0003, 0x0030, "DA", "Max Waiting Date" },
 153     { 0x0003, 0x0031, "TM", "Max Waiting Time" },
 154     { 0x0004, 0x0000, "UL", "File Set Group Length" },
 155     { 0x0004, 0x1130, "CS", "File Set ID" },
 156     { 0x0004, 0x1141, "CS", "File Set Descriptor File ID" },
 157     { 0x0004, 0x1142, "CS", "File Set Descriptor File Specific Character Set" },
 158     { 0x0004, 0x1200, "UL", "Root Directory Entity First Directory Record Offset" },
 159     { 0x0004, 0x1202, "UL", "Root Directory Entity Last Directory Record Offset" },
 160     { 0x0004, 0x1212, "US", "File Set Consistency Flag" },
 161     { 0x0004, 0x1220, "SQ", "Directory Record Sequence" },
 162     { 0x0004, 0x1400, "UL", "Next Directory Record Offset" },
 163     { 0x0004, 0x1410, "US", "Record In Use Flag" },
 164     { 0x0004, 0x1420, "UL", "Referenced Lower Level Directory Entity Offset" },
 165     { 0x0004, 0x1430, "CS", "Directory Record Type" },
 166     { 0x0004, 0x1432, "UI", "Private Record UID" },
 167     { 0x0004, 0x1500, "CS", "Referenced File ID" },
 168     { 0x0004, 0x1504, "UL", "MRDR Directory Record Offset" },
 169     { 0x0004, 0x1510, "UI", "Referenced SOP Class UID In File" },
 170     { 0x0004, 0x1511, "UI", "Referenced SOP Instance UID In File" },
 171     { 0x0004, 0x1512, "UI", "Referenced Transfer Syntax UID In File" },
 172     { 0x0004, 0x1600, "UL", "Number of References" },
 173     { 0x0005, 0x0000, "US", "?" },
 174     { 0x0006, 0x0000, "US", "?" },
 175     { 0x0008, 0x0000, "UL", "Identifying Group Length" },
 176     { 0x0008, 0x0001, "UL", "Length to End" },
 177     { 0x0008, 0x0005, "CS", "Specific Character Set" },
 178     { 0x0008, 0x0008, "CS", "Image Type" },
 179     { 0x0008, 0x0010, "LO", "Recognition Code" },
 180     { 0x0008, 0x0012, "DA", "Instance Creation Date" },
 181     { 0x0008, 0x0013, "TM", "Instance Creation Time" },
 182     { 0x0008, 0x0014, "UI", "Instance Creator UID" },
 183     { 0x0008, 0x0016, "UI", "SOP Class UID" },
 184     { 0x0008, 0x0018, "UI", "SOP Instance UID" },
 185     { 0x0008, 0x0020, "DA", "Study Date" },
 186     { 0x0008, 0x0021, "DA", "Series Date" },
 187     { 0x0008, 0x0022, "DA", "Acquisition Date" },
 188     { 0x0008, 0x0023, "DA", "Image Date" },
 189     { 0x0008, 0x0024, "DA", "Overlay Date" },
 190     { 0x0008, 0x0025, "DA", "Curve Date" },
 191     { 0x0008, 0x0030, "TM", "Study Time" },
 192     { 0x0008, 0x0031, "TM", "Series Time" },
 193     { 0x0008, 0x0032, "TM", "Acquisition Time" },
 194     { 0x0008, 0x0033, "TM", "Image Time" },
 195     { 0x0008, 0x0034, "TM", "Overlay Time" },
 196     { 0x0008, 0x0035, "TM", "Curve Time" },
 197     { 0x0008, 0x0040, "xs", "Old Data Set Type" },
 198     { 0x0008, 0x0041, "xs", "Old Data Set Subtype" },
 199     { 0x0008, 0x0042, "CS", "Nuclear Medicine Series Type" },
 200     { 0x0008, 0x0050, "SH", "Accession Number" },
 201     { 0x0008, 0x0052, "CS", "Query/Retrieve Level" },
 202     { 0x0008, 0x0054, "AE", "Retrieve AE Title" },
 203     { 0x0008, 0x0058, "UI", "Failed SOP Instance UID List" },
 204     { 0x0008, 0x0060, "CS", "Modality" },
 205     { 0x0008, 0x0062, "SQ", "Modality Subtype" },
 206     { 0x0008, 0x0064, "CS", "Conversion Type" },
 207     { 0x0008, 0x0068, "CS", "Presentation Intent Type" },
 208     { 0x0008, 0x0070, "LO", "Manufacturer" },
 209     { 0x0008, 0x0080, "LO", "Institution Name" },
 210     { 0x0008, 0x0081, "ST", "Institution Address" },
 211     { 0x0008, 0x0082, "SQ", "Institution Code Sequence" },
 212     { 0x0008, 0x0090, "PN", "Referring Physician's Name" },
 213     { 0x0008, 0x0092, "ST", "Referring Physician's Address" },
 214     { 0x0008, 0x0094, "SH", "Referring Physician's Telephone Numbers" },
 215     { 0x0008, 0x0100, "SH", "Code Value" },
 216     { 0x0008, 0x0102, "SH", "Coding Scheme Designator" },
 217     { 0x0008, 0x0103, "SH", "Coding Scheme Version" },
 218     { 0x0008, 0x0104, "LO", "Code Meaning" },
 219     { 0x0008, 0x0105, "CS", "Mapping Resource" },
 220     { 0x0008, 0x0106, "DT", "Context Group Version" },
 221     { 0x0008, 0x010b, "CS", "Code Set Extension Flag" },
 222     { 0x0008, 0x010c, "UI", "Private Coding Scheme Creator UID" },
 223     { 0x0008, 0x010d, "UI", "Code Set Extension Creator UID" },
 224     { 0x0008, 0x010f, "CS", "Context Identifier" },
 225     { 0x0008, 0x1000, "LT", "Network ID" },
 226     { 0x0008, 0x1010, "SH", "Station Name" },
 227     { 0x0008, 0x1030, "LO", "Study Description" },
 228     { 0x0008, 0x1032, "SQ", "Procedure Code Sequence" },
 229     { 0x0008, 0x103e, "LO", "Series Description" },
 230     { 0x0008, 0x1040, "LO", "Institutional Department Name" },
 231     { 0x0008, 0x1048, "PN", "Physician of Record" },
 232     { 0x0008, 0x1050, "PN", "Performing Physician's Name" },
 233     { 0x0008, 0x1060, "PN", "Name of Physician(s) Reading Study" },
 234     { 0x0008, 0x1070, "PN", "Operator's Name" },
 235     { 0x0008, 0x1080, "LO", "Admitting Diagnosis Description" },
 236     { 0x0008, 0x1084, "SQ", "Admitting Diagnosis Code Sequence" },
 237     { 0x0008, 0x1090, "LO", "Manufacturer's Model Name" },
 238     { 0x0008, 0x1100, "SQ", "Referenced Results Sequence" },
 239     { 0x0008, 0x1110, "SQ", "Referenced Study Sequence" },
 240     { 0x0008, 0x1111, "SQ", "Referenced Study Component Sequence" },
 241     { 0x0008, 0x1115, "SQ", "Referenced Series Sequence" },
 242     { 0x0008, 0x1120, "SQ", "Referenced Patient Sequence" },
 243     { 0x0008, 0x1125, "SQ", "Referenced Visit Sequence" },
 244     { 0x0008, 0x1130, "SQ", "Referenced Overlay Sequence" },
 245     { 0x0008, 0x1140, "SQ", "Referenced Image Sequence" },
 246     { 0x0008, 0x1145, "SQ", "Referenced Curve Sequence" },
 247     { 0x0008, 0x1148, "SQ", "Referenced Previous Waveform" },
 248     { 0x0008, 0x114a, "SQ", "Referenced Simultaneous Waveforms" },
 249     { 0x0008, 0x114c, "SQ", "Referenced Subsequent Waveform" },
 250     { 0x0008, 0x1150, "UI", "Referenced SOP Class UID" },
 251     { 0x0008, 0x1155, "UI", "Referenced SOP Instance UID" },
 252     { 0x0008, 0x1160, "IS", "Referenced Frame Number" },
 253     { 0x0008, 0x1195, "UI", "Transaction UID" },
 254     { 0x0008, 0x1197, "US", "Failure Reason" },
 255     { 0x0008, 0x1198, "SQ", "Failed SOP Sequence" },
 256     { 0x0008, 0x1199, "SQ", "Referenced SOP Sequence" },
 257     { 0x0008, 0x2110, "CS", "Old Lossy Image Compression" },
 258     { 0x0008, 0x2111, "ST", "Derivation Description" },
 259     { 0x0008, 0x2112, "SQ", "Source Image Sequence" },
 260     { 0x0008, 0x2120, "SH", "Stage Name" },
 261     { 0x0008, 0x2122, "IS", "Stage Number" },
 262     { 0x0008, 0x2124, "IS", "Number of Stages" },
 263     { 0x0008, 0x2128, "IS", "View Number" },
 264     { 0x0008, 0x2129, "IS", "Number of Event Timers" },
 265     { 0x0008, 0x212a, "IS", "Number of Views in Stage" },
 266     { 0x0008, 0x2130, "DS", "Event Elapsed Time(s)" },
 267     { 0x0008, 0x2132, "LO", "Event Timer Name(s)" },
 268     { 0x0008, 0x2142, "IS", "Start Trim" },
 269     { 0x0008, 0x2143, "IS", "Stop Trim" },
 270     { 0x0008, 0x2144, "IS", "Recommended Display Frame Rate" },
 271     { 0x0008, 0x2200, "CS", "Transducer Position" },
 272     { 0x0008, 0x2204, "CS", "Transducer Orientation" },
 273     { 0x0008, 0x2208, "CS", "Anatomic Structure" },
 274     { 0x0008, 0x2218, "SQ", "Anatomic Region Sequence" },
 275     { 0x0008, 0x2220, "SQ", "Anatomic Region Modifier Sequence" },
 276     { 0x0008, 0x2228, "SQ", "Primary Anatomic Structure Sequence" },
 277     { 0x0008, 0x2230, "SQ", "Primary Anatomic Structure Modifier Sequence" },
 278     { 0x0008, 0x2240, "SQ", "Transducer Position Sequence" },
 279     { 0x0008, 0x2242, "SQ", "Transducer Position Modifier Sequence" },
 280     { 0x0008, 0x2244, "SQ", "Transducer Orientation Sequence" },
 281     { 0x0008, 0x2246, "SQ", "Transducer Orientation Modifier Sequence" },
 282     { 0x0008, 0x2251, "SQ", "Anatomic Structure Space Or Region Code Sequence" },
 283     { 0x0008, 0x2253, "SQ", "Anatomic Portal Of Entrance Code Sequence" },
 284     { 0x0008, 0x2255, "SQ", "Anatomic Approach Direction Code Sequence" },
 285     { 0x0008, 0x2256, "ST", "Anatomic Perspective Description" },
 286     { 0x0008, 0x2257, "SQ", "Anatomic Perspective Code Sequence" },
 287     { 0x0008, 0x2258, "ST", "Anatomic Location Of Examining Instrument Description" },
 288     { 0x0008, 0x2259, "SQ", "Anatomic Location Of Examining Instrument Code Sequence" },
 289     { 0x0008, 0x225a, "SQ", "Anatomic Structure Space Or Region Modifier Code Sequence" },
 290     { 0x0008, 0x225c, "SQ", "OnAxis Background Anatomic Structure Code Sequence" },
 291     { 0x0008, 0x4000, "LT", "Identifying Comments" },
 292     { 0x0009, 0x0000, "xs", "?" },
 293     { 0x0009, 0x0001, "xs", "?" },
 294     { 0x0009, 0x0002, "xs", "?" },
 295     { 0x0009, 0x0003, "xs", "?" },
 296     { 0x0009, 0x0004, "xs", "?" },
 297     { 0x0009, 0x0005, "UN", "?" },
 298     { 0x0009, 0x0006, "UN", "?" },
 299     { 0x0009, 0x0007, "UN", "?" },
 300     { 0x0009, 0x0008, "xs", "?" },
 301     { 0x0009, 0x0009, "LT", "?" },
 302     { 0x0009, 0x000a, "IS", "?" },
 303     { 0x0009, 0x000b, "IS", "?" },
 304     { 0x0009, 0x000c, "IS", "?" },
 305     { 0x0009, 0x000d, "IS", "?" },
 306     { 0x0009, 0x000e, "IS", "?" },
 307     { 0x0009, 0x000f, "UN", "?" },
 308     { 0x0009, 0x0010, "xs", "?" },
 309     { 0x0009, 0x0011, "xs", "?" },
 310     { 0x0009, 0x0012, "xs", "?" },
 311     { 0x0009, 0x0013, "xs", "?" },
 312     { 0x0009, 0x0014, "xs", "?" },
 313     { 0x0009, 0x0015, "xs", "?" },
 314     { 0x0009, 0x0016, "xs", "?" },
 315     { 0x0009, 0x0017, "LT", "?" },
 316     { 0x0009, 0x0018, "LT", "Data Set Identifier" },
 317     { 0x0009, 0x001a, "US", "?" },
 318     { 0x0009, 0x001e, "UI", "?" },
 319     { 0x0009, 0x0020, "xs", "?" },
 320     { 0x0009, 0x0021, "xs", "?" },
 321     { 0x0009, 0x0022, "SH", "User Orientation" },
 322     { 0x0009, 0x0023, "SL", "Initiation Type" },
 323     { 0x0009, 0x0024, "xs", "?" },
 324     { 0x0009, 0x0025, "xs", "?" },
 325     { 0x0009, 0x0026, "xs", "?" },
 326     { 0x0009, 0x0027, "xs", "?" },
 327     { 0x0009, 0x0029, "xs", "?" },
 328     { 0x0009, 0x002a, "SL", "?" },
 329     { 0x0009, 0x002c, "LO", "Series Comments" },
 330     { 0x0009, 0x002d, "SL", "Track Beat Average" },
 331     { 0x0009, 0x002e, "FD", "Distance Prescribed" },
 332     { 0x0009, 0x002f, "LT", "?" },
 333     { 0x0009, 0x0030, "xs", "?" },
 334     { 0x0009, 0x0031, "xs", "?" },
 335     { 0x0009, 0x0032, "LT", "?" },
 336     { 0x0009, 0x0034, "xs", "?" },
 337     { 0x0009, 0x0035, "SL", "Gantry Locus Type" },
 338     { 0x0009, 0x0037, "SL", "Starting Heart Rate" },
 339     { 0x0009, 0x0038, "xs", "?" },
 340     { 0x0009, 0x0039, "SL", "RR Window Offset" },
 341     { 0x0009, 0x003a, "SL", "Percent Cycle Imaged" },
 342     { 0x0009, 0x003e, "US", "?" },
 343     { 0x0009, 0x003f, "US", "?" },
 344     { 0x0009, 0x0040, "xs", "?" },
 345     { 0x0009, 0x0041, "xs", "?" },
 346     { 0x0009, 0x0042, "xs", "?" },
 347     { 0x0009, 0x0043, "xs", "?" },
 348     { 0x0009, 0x0050, "LT", "?" },
 349     { 0x0009, 0x0051, "xs", "?" },
 350     { 0x0009, 0x0060, "LT", "?" },
 351     { 0x0009, 0x0061, "LT", "Series Unique Identifier" },
 352     { 0x0009, 0x0070, "LT", "?" },
 353     { 0x0009, 0x0080, "LT", "?" },
 354     { 0x0009, 0x0091, "LT", "?" },
 355     { 0x0009, 0x00e2, "LT", "?" },
 356     { 0x0009, 0x00e3, "UI", "Equipment UID" },
 357     { 0x0009, 0x00e6, "SH", "Genesis Version Now" },
 358     { 0x0009, 0x00e7, "UL", "Exam Record Checksum" },
 359     { 0x0009, 0x00e8, "UL", "?" },
 360     { 0x0009, 0x00e9, "SL", "Actual Series Data Time Stamp" },
 361     { 0x0009, 0x00f2, "UN", "?" },
 362     { 0x0009, 0x00f3, "UN", "?" },
 363     { 0x0009, 0x00f4, "LT", "?" },
 364     { 0x0009, 0x00f5, "xs", "?" },
 365     { 0x0009, 0x00f6, "LT", "PDM Data Object Type Extension" },
 366     { 0x0009, 0x00f8, "US", "?" },
 367     { 0x0009, 0x00fb, "IS", "?" },
 368     { 0x0009, 0x1002, "OB", "?" },
 369     { 0x0009, 0x1003, "OB", "?" },
 370     { 0x0009, 0x1010, "UN", "?" },
 371     { 0x0010, 0x0000, "UL", "Patient Group Length" },
 372     { 0x0010, 0x0010, "PN", "Patient's Name" },
 373     { 0x0010, 0x0020, "LO", "Patient's ID" },
 374     { 0x0010, 0x0021, "LO", "Issuer of Patient's ID" },
 375     { 0x0010, 0x0030, "DA", "Patient's Birth Date" },
 376     { 0x0010, 0x0032, "TM", "Patient's Birth Time" },
 377     { 0x0010, 0x0040, "CS", "Patient's Sex" },
 378     { 0x0010, 0x0050, "SQ", "Patient's Insurance Plan Code Sequence" },
 379     { 0x0010, 0x1000, "LO", "Other Patient's ID's" },
 380     { 0x0010, 0x1001, "PN", "Other Patient's Names" },
 381     { 0x0010, 0x1005, "PN", "Patient's Birth Name" },
 382     { 0x0010, 0x1010, "AS", "Patient's Age" },
 383     { 0x0010, 0x1020, "DS", "Patient's Size" },
 384     { 0x0010, 0x1030, "DS", "Patient's Weight" },
 385     { 0x0010, 0x1040, "LO", "Patient's Address" },
 386     { 0x0010, 0x1050, "LT", "Insurance Plan Identification" },
 387     { 0x0010, 0x1060, "PN", "Patient's Mother's Birth Name" },
 388     { 0x0010, 0x1080, "LO", "Military Rank" },
 389     { 0x0010, 0x1081, "LO", "Branch of Service" },
 390     { 0x0010, 0x1090, "LO", "Medical Record Locator" },
 391     { 0x0010, 0x2000, "LO", "Medical Alerts" },
 392     { 0x0010, 0x2110, "LO", "Contrast Allergies" },
 393     { 0x0010, 0x2150, "LO", "Country of Residence" },
 394     { 0x0010, 0x2152, "LO", "Region of Residence" },
 395     { 0x0010, 0x2154, "SH", "Patients Telephone Numbers" },
 396     { 0x0010, 0x2160, "SH", "Ethnic Group" },
 397     { 0x0010, 0x2180, "SH", "Occupation" },
 398     { 0x0010, 0x21a0, "CS", "Smoking Status" },
 399     { 0x0010, 0x21b0, "LT", "Additional Patient History" },
 400     { 0x0010, 0x21c0, "US", "Pregnancy Status" },
 401     { 0x0010, 0x21d0, "DA", "Last Menstrual Date" },
 402     { 0x0010, 0x21f0, "LO", "Patients Religious Preference" },
 403     { 0x0010, 0x4000, "LT", "Patient Comments" },
 404     { 0x0011, 0x0001, "xs", "?" },
 405     { 0x0011, 0x0002, "US", "?" },
 406     { 0x0011, 0x0003, "LT", "Patient UID" },
 407     { 0x0011, 0x0004, "LT", "Patient ID" },
 408     { 0x0011, 0x000a, "xs", "?" },
 409     { 0x0011, 0x000b, "SL", "Effective Series Duration" },
 410     { 0x0011, 0x000c, "SL", "Num Beats" },
 411     { 0x0011, 0x000d, "LO", "Radio Nuclide Name" },
 412     { 0x0011, 0x0010, "xs", "?" },
 413     { 0x0011, 0x0011, "xs", "?" },
 414     { 0x0011, 0x0012, "LO", "Dataset Name" },
 415     { 0x0011, 0x0013, "LO", "Dataset Type" },
 416     { 0x0011, 0x0015, "xs", "?" },
 417     { 0x0011, 0x0016, "SL", "Energy Number" },
 418     { 0x0011, 0x0017, "SL", "RR Interval Window Number" },
 419     { 0x0011, 0x0018, "SL", "MG Bin Number" },
 420     { 0x0011, 0x0019, "FD", "Radius Of Rotation" },
 421     { 0x0011, 0x001a, "SL", "Detector Count Zone" },
 422     { 0x0011, 0x001b, "SL", "Num Energy Windows" },
 423     { 0x0011, 0x001c, "SL", "Energy Offset" },
 424     { 0x0011, 0x001d, "SL", "Energy Range" },
 425     { 0x0011, 0x001f, "SL", "Image Orientation" },
 426     { 0x0011, 0x0020, "xs", "?" },
 427     { 0x0011, 0x0021, "xs", "?" },
 428     { 0x0011, 0x0022, "xs", "?" },
 429     { 0x0011, 0x0023, "xs", "?" },
 430     { 0x0011, 0x0024, "SL", "FOV Mask Y Cutoff Angle" },
 431     { 0x0011, 0x0025, "xs", "?" },
 432     { 0x0011, 0x0026, "SL", "Table Orientation" },
 433     { 0x0011, 0x0027, "SL", "ROI Top Left" },
 434     { 0x0011, 0x0028, "SL", "ROI Bottom Right" },
 435     { 0x0011, 0x0030, "xs", "?" },
 436     { 0x0011, 0x0031, "xs", "?" },
 437     { 0x0011, 0x0032, "UN", "?" },
 438     { 0x0011, 0x0033, "LO", "Energy Correct Name" },
 439     { 0x0011, 0x0034, "LO", "Spatial Correct Name" },
 440     { 0x0011, 0x0035, "xs", "?" },
 441     { 0x0011, 0x0036, "LO", "Uniformity Correct Name" },
 442     { 0x0011, 0x0037, "LO", "Acquisition Specific Correct Name" },
 443     { 0x0011, 0x0038, "SL", "Byte Order" },
 444     { 0x0011, 0x003a, "SL", "Picture Format" },
 445     { 0x0011, 0x003b, "FD", "Pixel Scale" },
 446     { 0x0011, 0x003c, "FD", "Pixel Offset" },
 447     { 0x0011, 0x003e, "SL", "FOV Shape" },
 448     { 0x0011, 0x003f, "SL", "Dataset Flags" },
 449     { 0x0011, 0x0040, "xs", "?" },
 450     { 0x0011, 0x0041, "LT", "Medical Alerts" },
 451     { 0x0011, 0x0042, "LT", "Contrast Allergies" },
 452     { 0x0011, 0x0044, "FD", "Threshold Center" },
 453     { 0x0011, 0x0045, "FD", "Threshold Width" },
 454     { 0x0011, 0x0046, "SL", "Interpolation Type" },
 455     { 0x0011, 0x0055, "FD", "Period" },
 456     { 0x0011, 0x0056, "FD", "ElapsedTime" },
 457     { 0x0011, 0x00a1, "DA", "Patient Registration Date" },
 458     { 0x0011, 0x00a2, "TM", "Patient Registration Time" },
 459     { 0x0011, 0x00b0, "LT", "Patient Last Name" },
 460     { 0x0011, 0x00b2, "LT", "Patient First Name" },
 461     { 0x0011, 0x00b4, "LT", "Patient Hospital Status" },
 462     { 0x0011, 0x00bc, "TM", "Current Location Time" },
 463     { 0x0011, 0x00c0, "LT", "Patient Insurance Status" },
 464     { 0x0011, 0x00d0, "LT", "Patient Billing Type" },
 465     { 0x0011, 0x00d2, "LT", "Patient Billing Address" },
 466     { 0x0013, 0x0000, "LT", "Modifying Physician" },
 467     { 0x0013, 0x0010, "xs", "?" },
 468     { 0x0013, 0x0011, "SL", "?" },
 469     { 0x0013, 0x0012, "xs", "?" },
 470     { 0x0013, 0x0016, "SL", "AutoTrack Peak" },
 471     { 0x0013, 0x0017, "SL", "AutoTrack Width" },
 472     { 0x0013, 0x0018, "FD", "Transmission Scan Time" },
 473     { 0x0013, 0x0019, "FD", "Transmission Mask Width" },
 474     { 0x0013, 0x001a, "FD", "Copper Attenuator Thickness" },
 475     { 0x0013, 0x001c, "FD", "?" },
 476     { 0x0013, 0x001d, "FD", "?" },
 477     { 0x0013, 0x001e, "FD", "Tomo View Offset" },
 478     { 0x0013, 0x0020, "LT", "Patient Name" },
 479     { 0x0013, 0x0022, "LT", "Patient Id" },
 480     { 0x0013, 0x0026, "LT", "Study Comments" },
 481     { 0x0013, 0x0030, "DA", "Patient Birthdate" },
 482     { 0x0013, 0x0031, "DS", "Patient Weight" },
 483     { 0x0013, 0x0032, "LT", "Patients Maiden Name" },
 484     { 0x0013, 0x0033, "LT", "Referring Physician" },
 485     { 0x0013, 0x0034, "LT", "Admitting Diagnosis" },
 486     { 0x0013, 0x0035, "LT", "Patient Sex" },
 487     { 0x0013, 0x0040, "LT", "Procedure Description" },
 488     { 0x0013, 0x0042, "LT", "Patient Rest Direction" },
 489     { 0x0013, 0x0044, "LT", "Patient Position" },
 490     { 0x0013, 0x0046, "LT", "View Direction" },
 491     { 0x0015, 0x0001, "DS", "Stenosis Calibration Ratio" },
 492     { 0x0015, 0x0002, "DS", "Stenosis Magnification" },
 493     { 0x0015, 0x0003, "DS", "Cardiac Calibration Ratio" },
 494     { 0x0018, 0x0000, "UL", "Acquisition Group Length" },
 495     { 0x0018, 0x0010, "LO", "Contrast/Bolus Agent" },
 496     { 0x0018, 0x0012, "SQ", "Contrast/Bolus Agent Sequence" },
 497     { 0x0018, 0x0014, "SQ", "Contrast/Bolus Administration Route Sequence" },
 498     { 0x0018, 0x0015, "CS", "Body Part Examined" },
 499     { 0x0018, 0x0020, "CS", "Scanning Sequence" },
 500     { 0x0018, 0x0021, "CS", "Sequence Variant" },
 501     { 0x0018, 0x0022, "CS", "Scan Options" },
 502     { 0x0018, 0x0023, "CS", "MR Acquisition Type" },
 503     { 0x0018, 0x0024, "SH", "Sequence Name" },
 504     { 0x0018, 0x0025, "CS", "Angio Flag" },
 505     { 0x0018, 0x0026, "SQ", "Intervention Drug Information Sequence" },
 506     { 0x0018, 0x0027, "TM", "Intervention Drug Stop Time" },
 507     { 0x0018, 0x0028, "DS", "Intervention Drug Dose" },
 508     { 0x0018, 0x0029, "SQ", "Intervention Drug Code Sequence" },
 509     { 0x0018, 0x002a, "SQ", "Additional Drug Sequence" },
 510     { 0x0018, 0x0030, "LO", "Radionuclide" },
 511     { 0x0018, 0x0031, "LO", "Radiopharmaceutical" },
 512     { 0x0018, 0x0032, "DS", "Energy Window Centerline" },
 513     { 0x0018, 0x0033, "DS", "Energy Window Total Width" },
 514     { 0x0018, 0x0034, "LO", "Intervention Drug Name" },
 515     { 0x0018, 0x0035, "TM", "Intervention Drug Start Time" },
 516     { 0x0018, 0x0036, "SQ", "Intervention Therapy Sequence" },
 517     { 0x0018, 0x0037, "CS", "Therapy Type" },
 518     { 0x0018, 0x0038, "CS", "Intervention Status" },
 519     { 0x0018, 0x0039, "CS", "Therapy Description" },
 520     { 0x0018, 0x0040, "IS", "Cine Rate" },
 521     { 0x0018, 0x0050, "DS", "Slice Thickness" },
 522     { 0x0018, 0x0060, "DS", "KVP" },
 523     { 0x0018, 0x0070, "IS", "Counts Accumulated" },
 524     { 0x0018, 0x0071, "CS", "Acquisition Termination Condition" },
 525     { 0x0018, 0x0072, "DS", "Effective Series Duration" },
 526     { 0x0018, 0x0073, "CS", "Acquisition Start Condition" },
 527     { 0x0018, 0x0074, "IS", "Acquisition Start Condition Data" },
 528     { 0x0018, 0x0075, "IS", "Acquisition Termination Condition Data" },
 529     { 0x0018, 0x0080, "DS", "Repetition Time" },
 530     { 0x0018, 0x0081, "DS", "Echo Time" },
 531     { 0x0018, 0x0082, "DS", "Inversion Time" },
 532     { 0x0018, 0x0083, "DS", "Number of Averages" },
 533     { 0x0018, 0x0084, "DS", "Imaging Frequency" },
 534     { 0x0018, 0x0085, "SH", "Imaged Nucleus" },
 535     { 0x0018, 0x0086, "IS", "Echo Number(s)" },
 536     { 0x0018, 0x0087, "DS", "Magnetic Field Strength" },
 537     { 0x0018, 0x0088, "DS", "Spacing Between Slices" },
 538     { 0x0018, 0x0089, "IS", "Number of Phase Encoding Steps" },
 539     { 0x0018, 0x0090, "DS", "Data Collection Diameter" },
 540     { 0x0018, 0x0091, "IS", "Echo Train Length" },
 541     { 0x0018, 0x0093, "DS", "Percent Sampling" },
 542     { 0x0018, 0x0094, "DS", "Percent Phase Field of View" },
 543     { 0x0018, 0x0095, "DS", "Pixel Bandwidth" },
 544     { 0x0018, 0x1000, "LO", "Device Serial Number" },
 545     { 0x0018, 0x1004, "LO", "Plate ID" },
 546     { 0x0018, 0x1010, "LO", "Secondary Capture Device ID" },
 547     { 0x0018, 0x1012, "DA", "Date of Secondary Capture" },
 548     { 0x0018, 0x1014, "TM", "Time of Secondary Capture" },
 549     { 0x0018, 0x1016, "LO", "Secondary Capture Device Manufacturer" },
 550     { 0x0018, 0x1018, "LO", "Secondary Capture Device Manufacturer Model Name" },
 551     { 0x0018, 0x1019, "LO", "Secondary Capture Device Software Version(s)" },
 552     { 0x0018, 0x1020, "LO", "Software Version(s)" },
 553     { 0x0018, 0x1022, "SH", "Video Image Format Acquired" },
 554     { 0x0018, 0x1023, "LO", "Digital Image Format Acquired" },
 555     { 0x0018, 0x1030, "LO", "Protocol Name" },
 556     { 0x0018, 0x1040, "LO", "Contrast/Bolus Route" },
 557     { 0x0018, 0x1041, "DS", "Contrast/Bolus Volume" },
 558     { 0x0018, 0x1042, "TM", "Contrast/Bolus Start Time" },
 559     { 0x0018, 0x1043, "TM", "Contrast/Bolus Stop Time" },
 560     { 0x0018, 0x1044, "DS", "Contrast/Bolus Total Dose" },
 561     { 0x0018, 0x1045, "IS", "Syringe Counts" },
 562     { 0x0018, 0x1046, "DS", "Contrast Flow Rate" },
 563     { 0x0018, 0x1047, "DS", "Contrast Flow Duration" },
 564     { 0x0018, 0x1048, "CS", "Contrast/Bolus Ingredient" },
 565     { 0x0018, 0x1049, "DS", "Contrast/Bolus Ingredient Concentration" },
 566     { 0x0018, 0x1050, "DS", "Spatial Resolution" },
 567     { 0x0018, 0x1060, "DS", "Trigger Time" },
 568     { 0x0018, 0x1061, "LO", "Trigger Source or Type" },
 569     { 0x0018, 0x1062, "IS", "Nominal Interval" },
 570     { 0x0018, 0x1063, "DS", "Frame Time" },
 571     { 0x0018, 0x1064, "LO", "Framing Type" },
 572     { 0x0018, 0x1065, "DS", "Frame Time Vector" },
 573     { 0x0018, 0x1066, "DS", "Frame Delay" },
 574     { 0x0018, 0x1067, "DS", "Image Trigger Delay" },
 575     { 0x0018, 0x1068, "DS", "Group Time Offset" },
 576     { 0x0018, 0x1069, "DS", "Trigger Time Offset" },
 577     { 0x0018, 0x106a, "CS", "Synchronization Trigger" },
 578     { 0x0018, 0x106b, "UI", "Synchronization Frame of Reference" },
 579     { 0x0018, 0x106e, "UL", "Trigger Sample Position" },
 580     { 0x0018, 0x1070, "LO", "Radiopharmaceutical Route" },
 581     { 0x0018, 0x1071, "DS", "Radiopharmaceutical Volume" },
 582     { 0x0018, 0x1072, "TM", "Radiopharmaceutical Start Time" },
 583     { 0x0018, 0x1073, "TM", "Radiopharmaceutical Stop Time" },
 584     { 0x0018, 0x1074, "DS", "Radionuclide Total Dose" },
 585     { 0x0018, 0x1075, "DS", "Radionuclide Half Life" },
 586     { 0x0018, 0x1076, "DS", "Radionuclide Positron Fraction" },
 587     { 0x0018, 0x1077, "DS", "Radiopharmaceutical Specific Activity" },
 588     { 0x0018, 0x1080, "CS", "Beat Rejection Flag" },
 589     { 0x0018, 0x1081, "IS", "Low R-R Value" },
 590     { 0x0018, 0x1082, "IS", "High R-R Value" },
 591     { 0x0018, 0x1083, "IS", "Intervals Acquired" },
 592     { 0x0018, 0x1084, "IS", "Intervals Rejected" },
 593     { 0x0018, 0x1085, "LO", "PVC Rejection" },
 594     { 0x0018, 0x1086, "IS", "Skip Beats" },
 595     { 0x0018, 0x1088, "IS", "Heart Rate" },
 596     { 0x0018, 0x1090, "IS", "Cardiac Number of Images" },
 597     { 0x0018, 0x1094, "IS", "Trigger Window" },
 598     { 0x0018, 0x1100, "DS", "Reconstruction Diameter" },
 599     { 0x0018, 0x1110, "DS", "Distance Source to Detector" },
 600     { 0x0018, 0x1111, "DS", "Distance Source to Patient" },
 601     { 0x0018, 0x1114, "DS", "Estimated Radiographic Magnification Factor" },
 602     { 0x0018, 0x1120, "DS", "Gantry/Detector Tilt" },
 603     { 0x0018, 0x1121, "DS", "Gantry/Detector Slew" },
 604     { 0x0018, 0x1130, "DS", "Table Height" },
 605     { 0x0018, 0x1131, "DS", "Table Traverse" },
 606     { 0x0018, 0x1134, "CS", "Table Motion" },
 607     { 0x0018, 0x1135, "DS", "Table Vertical Increment" },
 608     { 0x0018, 0x1136, "DS", "Table Lateral Increment" },
 609     { 0x0018, 0x1137, "DS", "Table Longitudinal Increment" },
 610     { 0x0018, 0x1138, "DS", "Table Angle" },
 611     { 0x0018, 0x113a, "CS", "Table Type" },
 612     { 0x0018, 0x1140, "CS", "Rotation Direction" },
 613     { 0x0018, 0x1141, "DS", "Angular Position" },
 614     { 0x0018, 0x1142, "DS", "Radial Position" },
 615     { 0x0018, 0x1143, "DS", "Scan Arc" },
 616     { 0x0018, 0x1144, "DS", "Angular Step" },
 617     { 0x0018, 0x1145, "DS", "Center of Rotation Offset" },
 618     { 0x0018, 0x1146, "DS", "Rotation Offset" },
 619     { 0x0018, 0x1147, "CS", "Field of View Shape" },
 620     { 0x0018, 0x1149, "IS", "Field of View Dimension(s)" },
 621     { 0x0018, 0x1150, "IS", "Exposure Time" },
 622     { 0x0018, 0x1151, "IS", "X-ray Tube Current" },
 623     { 0x0018, 0x1152, "IS", "Exposure" },
 624     { 0x0018, 0x1153, "IS", "Exposure in uAs" },
 625     { 0x0018, 0x1154, "DS", "AveragePulseWidth" },
 626     { 0x0018, 0x1155, "CS", "RadiationSetting" },
 627     { 0x0018, 0x1156, "CS", "Rectification Type" },
 628     { 0x0018, 0x115a, "CS", "RadiationMode" },
 629     { 0x0018, 0x115e, "DS", "ImageAreaDoseProduct" },
 630     { 0x0018, 0x1160, "SH", "Filter Type" },
 631     { 0x0018, 0x1161, "LO", "TypeOfFilters" },
 632     { 0x0018, 0x1162, "DS", "IntensifierSize" },
 633     { 0x0018, 0x1164, "DS", "ImagerPixelSpacing" },
 634     { 0x0018, 0x1166, "CS", "Grid" },
 635     { 0x0018, 0x1170, "IS", "Generator Power" },
 636     { 0x0018, 0x1180, "SH", "Collimator/Grid Name" },
 637     { 0x0018, 0x1181, "CS", "Collimator Type" },
 638     { 0x0018, 0x1182, "IS", "Focal Distance" },
 639     { 0x0018, 0x1183, "DS", "X Focus Center" },
 640     { 0x0018, 0x1184, "DS", "Y Focus Center" },
 641     { 0x0018, 0x1190, "DS", "Focal Spot(s)" },
 642     { 0x0018, 0x1191, "CS", "Anode Target Material" },
 643     { 0x0018, 0x11a0, "DS", "Body Part Thickness" },
 644     { 0x0018, 0x11a2, "DS", "Compression Force" },
 645     { 0x0018, 0x1200, "DA", "Date of Last Calibration" },
 646     { 0x0018, 0x1201, "TM", "Time of Last Calibration" },
 647     { 0x0018, 0x1210, "SH", "Convolution Kernel" },
 648     { 0x0018, 0x1240, "IS", "Upper/Lower Pixel Values" },
 649     { 0x0018, 0x1242, "IS", "Actual Frame Duration" },
 650     { 0x0018, 0x1243, "IS", "Count Rate" },
 651     { 0x0018, 0x1244, "US", "Preferred Playback Sequencing" },
 652     { 0x0018, 0x1250, "SH", "Receiving Coil" },
 653     { 0x0018, 0x1251, "SH", "Transmitting Coil" },
 654     { 0x0018, 0x1260, "SH", "Plate Type" },
 655     { 0x0018, 0x1261, "LO", "Phosphor Type" },
 656     { 0x0018, 0x1300, "DS", "Scan Velocity" },
 657     { 0x0018, 0x1301, "CS", "Whole Body Technique" },
 658     { 0x0018, 0x1302, "IS", "Scan Length" },
 659     { 0x0018, 0x1310, "US", "Acquisition Matrix" },
 660     { 0x0018, 0x1312, "CS", "Phase Encoding Direction" },
 661     { 0x0018, 0x1314, "DS", "Flip Angle" },
 662     { 0x0018, 0x1315, "CS", "Variable Flip Angle Flag" },
 663     { 0x0018, 0x1316, "DS", "SAR" },
 664     { 0x0018, 0x1318, "DS", "dB/dt" },
 665     { 0x0018, 0x1400, "LO", "Acquisition Device Processing Description" },
 666     { 0x0018, 0x1401, "LO", "Acquisition Device Processing Code" },
 667     { 0x0018, 0x1402, "CS", "Cassette Orientation" },
 668     { 0x0018, 0x1403, "CS", "Cassette Size" },
 669     { 0x0018, 0x1404, "US", "Exposures on Plate" },
 670     { 0x0018, 0x1405, "IS", "Relative X-ray Exposure" },
 671     { 0x0018, 0x1450, "DS", "Column Angulation" },
 672     { 0x0018, 0x1460, "DS", "Tomo Layer Height" },
 673     { 0x0018, 0x1470, "DS", "Tomo Angle" },
 674     { 0x0018, 0x1480, "DS", "Tomo Time" },
 675     { 0x0018, 0x1490, "CS", "Tomo Type" },
 676     { 0x0018, 0x1491, "CS", "Tomo Class" },
 677     { 0x0018, 0x1495, "IS", "Number of Tomosynthesis Source Images" },
 678     { 0x0018, 0x1500, "CS", "PositionerMotion" },
 679     { 0x0018, 0x1508, "CS", "Positioner Type" },
 680     { 0x0018, 0x1510, "DS", "PositionerPrimaryAngle" },
 681     { 0x0018, 0x1511, "DS", "PositionerSecondaryAngle" },
 682     { 0x0018, 0x1520, "DS", "PositionerPrimaryAngleIncrement" },
 683     { 0x0018, 0x1521, "DS", "PositionerSecondaryAngleIncrement" },
 684     { 0x0018, 0x1530, "DS", "DetectorPrimaryAngle" },
 685     { 0x0018, 0x1531, "DS", "DetectorSecondaryAngle" },
 686     { 0x0018, 0x1600, "CS", "Shutter Shape" },
 687     { 0x0018, 0x1602, "IS", "Shutter Left Vertical Edge" },
 688     { 0x0018, 0x1604, "IS", "Shutter Right Vertical Edge" },
 689     { 0x0018, 0x1606, "IS", "Shutter Upper Horizontal Edge" },
 690     { 0x0018, 0x1608, "IS", "Shutter Lower Horizonta lEdge" },
 691     { 0x0018, 0x1610, "IS", "Center of Circular Shutter" },
 692     { 0x0018, 0x1612, "IS", "Radius of Circular Shutter" },
 693     { 0x0018, 0x1620, "IS", "Vertices of Polygonal Shutter" },
 694     { 0x0018, 0x1622, "US", "Shutter Presentation Value" },
 695     { 0x0018, 0x1623, "US", "Shutter Overlay Group" },
 696     { 0x0018, 0x1700, "CS", "Collimator Shape" },
 697     { 0x0018, 0x1702, "IS", "Collimator Left Vertical Edge" },
 698     { 0x0018, 0x1704, "IS", "Collimator Right Vertical Edge" },
 699     { 0x0018, 0x1706, "IS", "Collimator Upper Horizontal Edge" },
 700     { 0x0018, 0x1708, "IS", "Collimator Lower Horizontal Edge" },
 701     { 0x0018, 0x1710, "IS", "Center of Circular Collimator" },
 702     { 0x0018, 0x1712, "IS", "Radius of Circular Collimator" },
 703     { 0x0018, 0x1720, "IS", "Vertices of Polygonal Collimator" },
 704     { 0x0018, 0x1800, "CS", "Acquisition Time Synchronized" },
 705     { 0x0018, 0x1801, "SH", "Time Source" },
 706     { 0x0018, 0x1802, "CS", "Time Distribution Protocol" },
 707     { 0x0018, 0x4000, "LT", "Acquisition Comments" },
 708     { 0x0018, 0x5000, "SH", "Output Power" },
 709     { 0x0018, 0x5010, "LO", "Transducer Data" },
 710     { 0x0018, 0x5012, "DS", "Focus Depth" },
 711     { 0x0018, 0x5020, "LO", "Processing Function" },
 712     { 0x0018, 0x5021, "LO", "Postprocessing Function" },
 713     { 0x0018, 0x5022, "DS", "Mechanical Index" },
 714     { 0x0018, 0x5024, "DS", "Thermal Index" },
 715     { 0x0018, 0x5026, "DS", "Cranial Thermal Index" },
 716     { 0x0018, 0x5027, "DS", "Soft Tissue Thermal Index" },
 717     { 0x0018, 0x5028, "DS", "Soft Tissue-Focus Thermal Index" },
 718     { 0x0018, 0x5029, "DS", "Soft Tissue-Surface Thermal Index" },
 719     { 0x0018, 0x5030, "DS", "Dynamic Range" },
 720     { 0x0018, 0x5040, "DS", "Total Gain" },
 721     { 0x0018, 0x5050, "IS", "Depth of Scan Field" },
 722     { 0x0018, 0x5100, "CS", "Patient Position" },
 723     { 0x0018, 0x5101, "CS", "View Position" },
 724     { 0x0018, 0x5104, "SQ", "Projection Eponymous Name Code Sequence" },
 725     { 0x0018, 0x5210, "DS", "Image Transformation Matrix" },
 726     { 0x0018, 0x5212, "DS", "Image Translation Vector" },
 727     { 0x0018, 0x6000, "DS", "Sensitivity" },
 728     { 0x0018, 0x6011, "IS", "Sequence of Ultrasound Regions" },
 729     { 0x0018, 0x6012, "US", "Region Spatial Format" },
 730     { 0x0018, 0x6014, "US", "Region Data Type" },
 731     { 0x0018, 0x6016, "UL", "Region Flags" },
 732     { 0x0018, 0x6018, "UL", "Region Location Min X0" },
 733     { 0x0018, 0x601a, "UL", "Region Location Min Y0" },
 734     { 0x0018, 0x601c, "UL", "Region Location Max X1" },
 735     { 0x0018, 0x601e, "UL", "Region Location Max Y1" },
 736     { 0x0018, 0x6020, "SL", "Reference Pixel X0" },
 737     { 0x0018, 0x6022, "SL", "Reference Pixel Y0" },
 738     { 0x0018, 0x6024, "US", "Physical Units X Direction" },
 739     { 0x0018, 0x6026, "US", "Physical Units Y Direction" },
 740     { 0x0018, 0x6028, "FD", "Reference Pixel Physical Value X" },
 741     { 0x0018, 0x602a, "US", "Reference Pixel Physical Value Y" },
 742     { 0x0018, 0x602c, "US", "Physical Delta X" },
 743     { 0x0018, 0x602e, "US", "Physical Delta Y" },
 744     { 0x0018, 0x6030, "UL", "Transducer Frequency" },
 745     { 0x0018, 0x6031, "CS", "Transducer Type" },
 746     { 0x0018, 0x6032, "UL", "Pulse Repetition Frequency" },
 747     { 0x0018, 0x6034, "FD", "Doppler Correction Angle" },
 748     { 0x0018, 0x6036, "FD", "Steering Angle" },
 749     { 0x0018, 0x6038, "UL", "Doppler Sample Volume X Position" },
 750     { 0x0018, 0x603a, "UL", "Doppler Sample Volume Y Position" },
 751     { 0x0018, 0x603c, "UL", "TM-Line Position X0" },
 752     { 0x0018, 0x603e, "UL", "TM-Line Position Y0" },
 753     { 0x0018, 0x6040, "UL", "TM-Line Position X1" },
 754     { 0x0018, 0x6042, "UL", "TM-Line Position Y1" },
 755     { 0x0018, 0x6044, "US", "Pixel Component Organization" },
 756     { 0x0018, 0x6046, "UL", "Pixel Component Mask" },
 757     { 0x0018, 0x6048, "UL", "Pixel Component Range Start" },
 758     { 0x0018, 0x604a, "UL", "Pixel Component Range Stop" },
 759     { 0x0018, 0x604c, "US", "Pixel Component Physical Units" },
 760     { 0x0018, 0x604e, "US", "Pixel Component Data Type" },
 761     { 0x0018, 0x6050, "UL", "Number of Table Break Points" },
 762     { 0x0018, 0x6052, "UL", "Table of X Break Points" },
 763     { 0x0018, 0x6054, "FD", "Table of Y Break Points" },
 764     { 0x0018, 0x6056, "UL", "Number of Table Entries" },
 765     { 0x0018, 0x6058, "UL", "Table of Pixel Values" },
 766     { 0x0018, 0x605a, "FL", "Table of Parameter Values" },
 767     { 0x0018, 0x7000, "CS", "Detector Conditions Nominal Flag" },
 768     { 0x0018, 0x7001, "DS", "Detector Temperature" },
 769     { 0x0018, 0x7004, "CS", "Detector Type" },
 770     { 0x0018, 0x7005, "CS", "Detector Configuration" },
 771     { 0x0018, 0x7006, "LT", "Detector Description" },
 772     { 0x0018, 0x7008, "LT", "Detector Mode" },
 773     { 0x0018, 0x700a, "SH", "Detector ID" },
 774     { 0x0018, 0x700c, "DA", "Date of Last Detector Calibration " },
 775     { 0x0018, 0x700e, "TM", "Time of Last Detector Calibration" },
 776     { 0x0018, 0x7010, "IS", "Exposures on Detector Since Last Calibration" },
 777     { 0x0018, 0x7011, "IS", "Exposures on Detector Since Manufactured" },
 778     { 0x0018, 0x7012, "DS", "Detector Time Since Last Exposure" },
 779     { 0x0018, 0x7014, "DS", "Detector Active Time" },
 780     { 0x0018, 0x7016, "DS", "Detector Activation Offset From Exposure" },
 781     { 0x0018, 0x701a, "DS", "Detector Binning" },
 782     { 0x0018, 0x7020, "DS", "Detector Element Physical Size" },
 783     { 0x0018, 0x7022, "DS", "Detector Element Spacing" },
 784     { 0x0018, 0x7024, "CS", "Detector Active Shape" },
 785     { 0x0018, 0x7026, "DS", "Detector Active Dimensions" },
 786     { 0x0018, 0x7028, "DS", "Detector Active Origin" },
 787     { 0x0018, 0x7030, "DS", "Field of View Origin" },
 788     { 0x0018, 0x7032, "DS", "Field of View Rotation" },
 789     { 0x0018, 0x7034, "CS", "Field of View Horizontal Flip" },
 790     { 0x0018, 0x7040, "LT", "Grid Absorbing Material" },
 791     { 0x0018, 0x7041, "LT", "Grid Spacing Material" },
 792     { 0x0018, 0x7042, "DS", "Grid Thickness" },
 793     { 0x0018, 0x7044, "DS", "Grid Pitch" },
 794     { 0x0018, 0x7046, "IS", "Grid Aspect Ratio" },
 795     { 0x0018, 0x7048, "DS", "Grid Period" },
 796     { 0x0018, 0x704c, "DS", "Grid Focal Distance" },
 797     { 0x0018, 0x7050, "LT", "Filter Material" },
 798     { 0x0018, 0x7052, "DS", "Filter Thickness Minimum" },
 799     { 0x0018, 0x7054, "DS", "Filter Thickness Maximum" },
 800     { 0x0018, 0x7060, "CS", "Exposure Control Mode" },
 801     { 0x0018, 0x7062, "LT", "Exposure Control Mode Description" },
 802     { 0x0018, 0x7064, "CS", "Exposure Status" },
 803     { 0x0018, 0x7065, "DS", "Phototimer Setting" },
 804     { 0x0019, 0x0000, "xs", "?" },
 805     { 0x0019, 0x0001, "xs", "?" },
 806     { 0x0019, 0x0002, "xs", "?" },
 807     { 0x0019, 0x0003, "xs", "?" },
 808     { 0x0019, 0x0004, "xs", "?" },
 809     { 0x0019, 0x0005, "xs", "?" },
 810     { 0x0019, 0x0006, "xs", "?" },
 811     { 0x0019, 0x0007, "xs", "?" },
 812     { 0x0019, 0x0008, "xs", "?" },
 813     { 0x0019, 0x0009, "xs", "?" },
 814     { 0x0019, 0x000a, "xs", "?" },
 815     { 0x0019, 0x000b, "DS", "?" },
 816     { 0x0019, 0x000c, "US", "?" },
 817     { 0x0019, 0x000d, "TM", "Time" },
 818     { 0x0019, 0x000e, "xs", "?" },
 819     { 0x0019, 0x000f, "DS", "Horizontal Frame Of Reference" },
 820     { 0x0019, 0x0010, "xs", "?" },
 821     { 0x0019, 0x0011, "xs", "?" },
 822     { 0x0019, 0x0012, "xs", "?" },
 823     { 0x0019, 0x0013, "xs", "?" },
 824     { 0x0019, 0x0014, "xs", "?" },
 825     { 0x0019, 0x0015, "xs", "?" },
 826     { 0x0019, 0x0016, "xs", "?" },
 827     { 0x0019, 0x0017, "xs", "?" },
 828     { 0x0019, 0x0018, "xs", "?" },
 829     { 0x0019, 0x0019, "xs", "?" },
 830     { 0x0019, 0x001a, "xs", "?" },
 831     { 0x0019, 0x001b, "xs", "?" },
 832     { 0x0019, 0x001c, "CS", "Dose" },
 833     { 0x0019, 0x001d, "IS", "Side Mark" },
 834     { 0x0019, 0x001e, "xs", "?" },
 835     { 0x0019, 0x001f, "DS", "Exposure Duration" },
 836     { 0x0019, 0x0020, "xs", "?" },
 837     { 0x0019, 0x0021, "xs", "?" },
 838     { 0x0019, 0x0022, "xs", "?" },
 839     { 0x0019, 0x0023, "xs", "?" },
 840     { 0x0019, 0x0024, "xs", "?" },
 841     { 0x0019, 0x0025, "xs", "?" },
 842     { 0x0019, 0x0026, "xs", "?" },
 843     { 0x0019, 0x0027, "xs", "?" },
 844     { 0x0019, 0x0028, "xs", "?" },
 845     { 0x0019, 0x0029, "IS", "?" },
 846     { 0x0019, 0x002a, "xs", "?" },
 847     { 0x0019, 0x002b, "DS", "Xray Off Position" },
 848     { 0x0019, 0x002c, "xs", "?" },
 849     { 0x0019, 0x002d, "US", "?" },
 850     { 0x0019, 0x002e, "xs", "?" },
 851     { 0x0019, 0x002f, "DS", "Trigger Frequency" },
 852     { 0x0019, 0x0030, "xs", "?" },
 853     { 0x0019, 0x0031, "xs", "?" },
 854     { 0x0019, 0x0032, "xs", "?" },
 855     { 0x0019, 0x0033, "UN", "ECG 2 Offset 2" },
 856     { 0x0019, 0x0034, "US", "?" },
 857     { 0x0019, 0x0036, "US", "?" },
 858     { 0x0019, 0x0038, "US", "?" },
 859     { 0x0019, 0x0039, "xs", "?" },
 860     { 0x0019, 0x003a, "xs", "?" },
 861     { 0x0019, 0x003b, "LT", "?" },
 862     { 0x0019, 0x003c, "xs", "?" },
 863     { 0x0019, 0x003e, "xs", "?" },
 864     { 0x0019, 0x003f, "UN", "?" },
 865     { 0x0019, 0x0040, "xs", "?" },
 866     { 0x0019, 0x0041, "xs", "?" },
 867     { 0x0019, 0x0042, "xs", "?" },
 868     { 0x0019, 0x0043, "xs", "?" },
 869     { 0x0019, 0x0044, "xs", "?" },
 870     { 0x0019, 0x0045, "xs", "?" },
 871     { 0x0019, 0x0046, "xs", "?" },
 872     { 0x0019, 0x0047, "xs", "?" },
 873     { 0x0019, 0x0048, "xs", "?" },
 874     { 0x0019, 0x0049, "US", "?" },
 875     { 0x0019, 0x004a, "xs", "?" },
 876     { 0x0019, 0x004b, "SL", "Data Size For Scan Data" },
 877     { 0x0019, 0x004c, "US", "?" },
 878     { 0x0019, 0x004e, "US", "?" },
 879     { 0x0019, 0x0050, "xs", "?" },
 880     { 0x0019, 0x0051, "xs", "?" },
 881     { 0x0019, 0x0052, "xs", "?" },
 882     { 0x0019, 0x0053, "LT", "Barcode" },
 883     { 0x0019, 0x0054, "xs", "?" },
 884     { 0x0019, 0x0055, "DS", "Receiver Reference Gain" },
 885     { 0x0019, 0x0056, "xs", "?" },
 886     { 0x0019, 0x0057, "SS", "CT Water Number" },
 887     { 0x0019, 0x0058, "xs", "?" },
 888     { 0x0019, 0x005a, "xs", "?" },
 889     { 0x0019, 0x005c, "xs", "?" },
 890     { 0x0019, 0x005d, "US", "?" },
 891     { 0x0019, 0x005e, "xs", "?" },
 892     { 0x0019, 0x005f, "SL", "Increment Between Channels" },
 893     { 0x0019, 0x0060, "xs", "?" },
 894     { 0x0019, 0x0061, "xs", "?" },
 895     { 0x0019, 0x0062, "xs", "?" },
 896     { 0x0019, 0x0063, "xs", "?" },
 897     { 0x0019, 0x0064, "xs", "?" },
 898     { 0x0019, 0x0065, "xs", "?" },
 899     { 0x0019, 0x0066, "xs", "?" },
 900     { 0x0019, 0x0067, "xs", "?" },
 901     { 0x0019, 0x0068, "xs", "?" },
 902     { 0x0019, 0x0069, "UL", "Convolution Mode" },
 903     { 0x0019, 0x006a, "xs", "?" },
 904     { 0x0019, 0x006b, "SS", "Field Of View In Detector Cells" },
 905     { 0x0019, 0x006c, "US", "?" },
 906     { 0x0019, 0x006e, "US", "?" },
 907     { 0x0019, 0x0070, "xs", "?" },
 908     { 0x0019, 0x0071, "xs", "?" },
 909     { 0x0019, 0x0072, "xs", "?" },
 910     { 0x0019, 0x0073, "xs", "?" },
 911     { 0x0019, 0x0074, "xs", "?" },
 912     { 0x0019, 0x0075, "xs", "?" },
 913     { 0x0019, 0x0076, "xs", "?" },
 914     { 0x0019, 0x0077, "US", "?" },
 915     { 0x0019, 0x0078, "US", "?" },
 916     { 0x0019, 0x007a, "US", "?" },
 917     { 0x0019, 0x007c, "US", "?" },
 918     { 0x0019, 0x007d, "DS", "Second Echo" },
 919     { 0x0019, 0x007e, "xs", "?" },
 920     { 0x0019, 0x007f, "DS", "Table Delta" },
 921     { 0x0019, 0x0080, "xs", "?" },
 922     { 0x0019, 0x0081, "xs", "?" },
 923     { 0x0019, 0x0082, "xs", "?" },
 924     { 0x0019, 0x0083, "xs", "?" },
 925     { 0x0019, 0x0084, "xs", "?" },
 926     { 0x0019, 0x0085, "xs", "?" },
 927     { 0x0019, 0x0086, "xs", "?" },
 928     { 0x0019, 0x0087, "xs", "?" },
 929     { 0x0019, 0x0088, "xs", "?" },
 930     { 0x0019, 0x008a, "xs", "?" },
 931     { 0x0019, 0x008b, "SS", "Actual Receive Gain Digital" },
 932     { 0x0019, 0x008c, "US", "?" },
 933     { 0x0019, 0x008d, "DS", "Delay After Trigger" },
 934     { 0x0019, 0x008e, "US", "?" },
 935     { 0x0019, 0x008f, "SS", "Swap Phase Frequency" },
 936     { 0x0019, 0x0090, "xs", "?" },
 937     { 0x0019, 0x0091, "xs", "?" },
 938     { 0x0019, 0x0092, "xs", "?" },
 939     { 0x0019, 0x0093, "xs", "?" },
 940     { 0x0019, 0x0094, "xs", "?" },
 941     { 0x0019, 0x0095, "SS", "Analog Receiver Gain" },
 942     { 0x0019, 0x0096, "xs", "?" },
 943     { 0x0019, 0x0097, "xs", "?" },
 944     { 0x0019, 0x0098, "xs", "?" },
 945     { 0x0019, 0x0099, "US", "?" },
 946     { 0x0019, 0x009a, "US", "?" },
 947     { 0x0019, 0x009b, "SS", "Pulse Sequence Mode" },
 948     { 0x0019, 0x009c, "xs", "?" },
 949     { 0x0019, 0x009d, "DT", "Pulse Sequence Date" },
 950     { 0x0019, 0x009e, "xs", "?" },
 951     { 0x0019, 0x009f, "xs", "?" },
 952     { 0x0019, 0x00a0, "xs", "?" },
 953     { 0x0019, 0x00a1, "xs", "?" },
 954     { 0x0019, 0x00a2, "xs", "?" },
 955     { 0x0019, 0x00a3, "xs", "?" },
 956     { 0x0019, 0x00a4, "xs", "?" },
 957     { 0x0019, 0x00a5, "xs", "?" },
 958     { 0x0019, 0x00a6, "xs", "?" },
 959     { 0x0019, 0x00a7, "xs", "?" },
 960     { 0x0019, 0x00a8, "xs", "?" },
 961     { 0x0019, 0x00a9, "xs", "?" },
 962     { 0x0019, 0x00aa, "xs", "?" },
 963     { 0x0019, 0x00ab, "xs", "?" },
 964     { 0x0019, 0x00ac, "xs", "?" },
 965     { 0x0019, 0x00ad, "xs", "?" },
 966     { 0x0019, 0x00ae, "xs", "?" },
 967     { 0x0019, 0x00af, "xs", "?" },
 968     { 0x0019, 0x00b0, "xs", "?" },
 969     { 0x0019, 0x00b1, "xs", "?" },
 970     { 0x0019, 0x00b2, "xs", "?" },
 971     { 0x0019, 0x00b3, "xs", "?" },
 972     { 0x0019, 0x00b4, "xs", "?" },
 973     { 0x0019, 0x00b5, "xs", "?" },
 974     { 0x0019, 0x00b6, "DS", "User Data" },
 975     { 0x0019, 0x00b7, "DS", "User Data" },
 976     { 0x0019, 0x00b8, "DS", "User Data" },
 977     { 0x0019, 0x00b9, "DS", "User Data" },
 978     { 0x0019, 0x00ba, "DS", "User Data" },
 979     { 0x0019, 0x00bb, "DS", "User Data" },
 980     { 0x0019, 0x00bc, "DS", "User Data" },
 981     { 0x0019, 0x00bd, "DS", "User Data" },
 982     { 0x0019, 0x00be, "DS", "Projection Angle" },
 983     { 0x0019, 0x00c0, "xs", "?" },
 984     { 0x0019, 0x00c1, "xs", "?" },
 985     { 0x0019, 0x00c2, "xs", "?" },
 986     { 0x0019, 0x00c3, "xs", "?" },
 987     { 0x0019, 0x00c4, "xs", "?" },
 988     { 0x0019, 0x00c5, "xs", "?" },
 989     { 0x0019, 0x00c6, "SS", "SAT Location H" },
 990     { 0x0019, 0x00c7, "SS", "SAT Location F" },
 991     { 0x0019, 0x00c8, "SS", "SAT Thickness R L" },
 992     { 0x0019, 0x00c9, "SS", "SAT Thickness A P" },
 993     { 0x0019, 0x00ca, "SS", "SAT Thickness H F" },
 994     { 0x0019, 0x00cb, "xs", "?" },
 995     { 0x0019, 0x00cc, "xs", "?" },
 996     { 0x0019, 0x00cd, "SS", "Thickness Disclaimer" },
 997     { 0x0019, 0x00ce, "SS", "Prescan Type" },
 998     { 0x0019, 0x00cf, "SS", "Prescan Status" },
 999     { 0x0019, 0x00d0, "SH", "Raw Data Type" },
1000     { 0x0019, 0x00d1, "DS", "Flow Sensitivity" },
1001     { 0x0019, 0x00d2, "xs", "?" },
1002     { 0x0019, 0x00d3, "xs", "?" },
1003     { 0x0019, 0x00d4, "xs", "?" },
1004     { 0x0019, 0x00d5, "xs", "?" },
1005     { 0x0019, 0x00d6, "xs", "?" },
1006     { 0x0019, 0x00d7, "xs", "?" },
1007     { 0x0019, 0x00d8, "xs", "?" },
1008     { 0x0019, 0x00d9, "xs", "?" },
1009     { 0x0019, 0x00da, "xs", "?" },
1010     { 0x0019, 0x00db, "DS", "Back Projector Coefficient" },
1011     { 0x0019, 0x00dc, "SS", "Primary Speed Correction Used" },
1012     { 0x0019, 0x00dd, "SS", "Overrange Correction Used" },
1013     { 0x0019, 0x00de, "DS", "Dynamic Z Alpha Value" },
1014     { 0x0019, 0x00df, "DS", "User Data" },
1015     { 0x0019, 0x00e0, "DS", "User Data" },
1016     { 0x0019, 0x00e1, "xs", "?" },
1017     { 0x0019, 0x00e2, "xs", "?" },
1018     { 0x0019, 0x00e3, "xs", "?" },
1019     { 0x0019, 0x00e4, "LT", "?" },
1020     { 0x0019, 0x00e5, "IS", "?" },
1021     { 0x0019, 0x00e6, "US", "?" },
1022     { 0x0019, 0x00e8, "DS", "?" },
1023     { 0x0019, 0x00e9, "DS", "?" },
1024     { 0x0019, 0x00eb, "DS", "?" },
1025     { 0x0019, 0x00ec, "US", "?" },
1026     { 0x0019, 0x00f0, "xs", "?" },
1027     { 0x0019, 0x00f1, "xs", "?" },
1028     { 0x0019, 0x00f2, "xs", "?" },
1029     { 0x0019, 0x00f3, "xs", "?" },
1030     { 0x0019, 0x00f4, "LT", "?" },
1031     { 0x0019, 0x00f9, "DS", "Transmission Gain" },
1032     { 0x0019, 0x1015, "UN", "?" },
1033     { 0x0020, 0x0000, "UL", "Relationship Group Length" },
1034     { 0x0020, 0x000d, "UI", "Study Instance UID" },
1035     { 0x0020, 0x000e, "UI", "Series Instance UID" },
1036     { 0x0020, 0x0010, "SH", "Study ID" },
1037     { 0x0020, 0x0011, "IS", "Series Number" },
1038     { 0x0020, 0x0012, "IS", "Acquisition Number" },
1039     { 0x0020, 0x0013, "IS", "Instance (formerly Image) Number" },
1040     { 0x0020, 0x0014, "IS", "Isotope Number" },
1041     { 0x0020, 0x0015, "IS", "Phase Number" },
1042     { 0x0020, 0x0016, "IS", "Interval Number" },
1043     { 0x0020, 0x0017, "IS", "Time Slot Number" },
1044     { 0x0020, 0x0018, "IS", "Angle Number" },
1045     { 0x0020, 0x0020, "CS", "Patient Orientation" },
1046     { 0x0020, 0x0022, "IS", "Overlay Number" },
1047     { 0x0020, 0x0024, "IS", "Curve Number" },
1048     { 0x0020, 0x0026, "IS", "LUT Number" },
1049     { 0x0020, 0x0030, "DS", "Image Position" },
1050     { 0x0020, 0x0032, "DS", "Image Position (Patient)" },
1051     { 0x0020, 0x0035, "DS", "Image Orientation" },
1052     { 0x0020, 0x0037, "DS", "Image Orientation (Patient)" },
1053     { 0x0020, 0x0050, "DS", "Location" },
1054     { 0x0020, 0x0052, "UI", "Frame of Reference UID" },
1055     { 0x0020, 0x0060, "CS", "Laterality" },
1056     { 0x0020, 0x0062, "CS", "Image Laterality" },
1057     { 0x0020, 0x0070, "LT", "Image Geometry Type" },
1058     { 0x0020, 0x0080, "LO", "Masking Image" },
1059     { 0x0020, 0x0100, "IS", "Temporal Position Identifier" },
1060     { 0x0020, 0x0105, "IS", "Number of Temporal Positions" },
1061     { 0x0020, 0x0110, "DS", "Temporal Resolution" },
1062     { 0x0020, 0x1000, "IS", "Series in Study" },
1063     { 0x0020, 0x1001, "DS", "Acquisitions in Series" },
1064     { 0x0020, 0x1002, "IS", "Images in Acquisition" },
1065     { 0x0020, 0x1003, "IS", "Images in Series" },
1066     { 0x0020, 0x1004, "IS", "Acquisitions in Study" },
1067     { 0x0020, 0x1005, "IS", "Images in Study" },
1068     { 0x0020, 0x1020, "LO", "Reference" },
1069     { 0x0020, 0x1040, "LO", "Position Reference Indicator" },
1070     { 0x0020, 0x1041, "DS", "Slice Location" },
1071     { 0x0020, 0x1070, "IS", "Other Study Numbers" },
1072     { 0x0020, 0x1200, "IS", "Number of Patient Related Studies" },
1073     { 0x0020, 0x1202, "IS", "Number of Patient Related Series" },
1074     { 0x0020, 0x1204, "IS", "Number of Patient Related Images" },
1075     { 0x0020, 0x1206, "IS", "Number of Study Related Series" },
1076     { 0x0020, 0x1208, "IS", "Number of Study Related Series" },
1077     { 0x0020, 0x3100, "LO", "Source Image IDs" },
1078     { 0x0020, 0x3401, "LO", "Modifying Device ID" },
1079     { 0x0020, 0x3402, "LO", "Modified Image ID" },
1080     { 0x0020, 0x3403, "xs", "Modified Image Date" },
1081     { 0x0020, 0x3404, "LO", "Modifying Device Manufacturer" },
1082     { 0x0020, 0x3405, "xs", "Modified Image Time" },
1083     { 0x0020, 0x3406, "xs", "Modified Image Description" },
1084     { 0x0020, 0x4000, "LT", "Image Comments" },
1085     { 0x0020, 0x5000, "AT", "Original Image Identification" },
1086     { 0x0020, 0x5002, "LO", "Original Image Identification Nomenclature" },
1087     { 0x0021, 0x0000, "xs", "?" },
1088     { 0x0021, 0x0001, "xs", "?" },
1089     { 0x0021, 0x0002, "xs", "?" },
1090     { 0x0021, 0x0003, "xs", "?" },
1091     { 0x0021, 0x0004, "DS", "VOI Position" },
1092     { 0x0021, 0x0005, "xs", "?" },
1093     { 0x0021, 0x0006, "IS", "CSI Matrix Size Original" },
1094     { 0x0021, 0x0007, "xs", "?" },
1095     { 0x0021, 0x0008, "DS", "Spatial Grid Shift" },
1096     { 0x0021, 0x0009, "DS", "Signal Limits Minimum" },
1097     { 0x0021, 0x0010, "xs", "?" },
1098     { 0x0021, 0x0011, "xs", "?" },
1099     { 0x0021, 0x0012, "xs", "?" },
1100     { 0x0021, 0x0013, "xs", "?" },
1101     { 0x0021, 0x0014, "xs", "?" },
1102     { 0x0021, 0x0015, "xs", "?" },
1103     { 0x0021, 0x0016, "xs", "?" },
1104     { 0x0021, 0x0017, "DS", "EPI Operation Mode Flag" },
1105     { 0x0021, 0x0018, "xs", "?" },
1106     { 0x0021, 0x0019, "xs", "?" },
1107     { 0x0021, 0x0020, "xs", "?" },
1108     { 0x0021, 0x0021, "xs", "?" },
1109     { 0x0021, 0x0022, "xs", "?" },
1110     { 0x0021, 0x0024, "xs", "?" },
1111     { 0x0021, 0x0025, "US", "?" },
1112     { 0x0021, 0x0026, "IS", "Image Pixel Offset" },
1113     { 0x0021, 0x0030, "xs", "?" },
1114     { 0x0021, 0x0031, "xs", "?" },
1115     { 0x0021, 0x0032, "xs", "?" },
1116     { 0x0021, 0x0034, "xs", "?" },
1117     { 0x0021, 0x0035, "SS", "Series From Which Prescribed" },
1118     { 0x0021, 0x0036, "xs", "?" },
1119     { 0x0021, 0x0037, "SS", "Screen Format" },
1120     { 0x0021, 0x0039, "DS", "Slab Thickness" },
1121     { 0x0021, 0x0040, "xs", "?" },
1122     { 0x0021, 0x0041, "xs", "?" },
1123     { 0x0021, 0x0042, "xs", "?" },
1124     { 0x0021, 0x0043, "xs", "?" },
1125     { 0x0021, 0x0044, "xs", "?" },
1126     { 0x0021, 0x0045, "xs", "?" },
1127     { 0x0021, 0x0046, "xs", "?" },
1128     { 0x0021, 0x0047, "xs", "?" },
1129     { 0x0021, 0x0048, "xs", "?" },
1130     { 0x0021, 0x0049, "xs", "?" },
1131     { 0x0021, 0x004a, "xs", "?" },
1132     { 0x0021, 0x004e, "US", "?" },
1133     { 0x0021, 0x004f, "xs", "?" },
1134     { 0x0021, 0x0050, "xs", "?" },
1135     { 0x0021, 0x0051, "xs", "?" },
1136     { 0x0021, 0x0052, "xs", "?" },
1137     { 0x0021, 0x0053, "xs", "?" },
1138     { 0x0021, 0x0054, "xs", "?" },
1139     { 0x0021, 0x0055, "xs", "?" },
1140     { 0x0021, 0x0056, "xs", "?" },
1141     { 0x0021, 0x0057, "xs", "?" },
1142     { 0x0021, 0x0058, "xs", "?" },
1143     { 0x0021, 0x0059, "xs", "?" },
1144     { 0x0021, 0x005a, "SL", "Integer Slop" },
1145     { 0x0021, 0x005b, "DS", "Float Slop" },
1146     { 0x0021, 0x005c, "DS", "Float Slop" },
1147     { 0x0021, 0x005d, "DS", "Float Slop" },
1148     { 0x0021, 0x005e, "DS", "Float Slop" },
1149     { 0x0021, 0x005f, "DS", "Float Slop" },
1150     { 0x0021, 0x0060, "xs", "?" },
1151     { 0x0021, 0x0061, "DS", "Image Normal" },
1152     { 0x0021, 0x0062, "IS", "Reference Type Code" },
1153     { 0x0021, 0x0063, "DS", "Image Distance" },
1154     { 0x0021, 0x0065, "US", "Image Positioning History Mask" },
1155     { 0x0021, 0x006a, "DS", "Image Row" },
1156     { 0x0021, 0x006b, "DS", "Image Column" },
1157     { 0x0021, 0x0070, "xs", "?" },
1158     { 0x0021, 0x0071, "xs", "?" },
1159     { 0x0021, 0x0072, "xs", "?" },
1160     { 0x0021, 0x0073, "DS", "Second Repetition Time" },
1161     { 0x0021, 0x0075, "DS", "Light Brightness" },
1162     { 0x0021, 0x0076, "DS", "Light Contrast" },
1163     { 0x0021, 0x007a, "IS", "Overlay Threshold" },
1164     { 0x0021, 0x007b, "IS", "Surface Threshold" },
1165     { 0x0021, 0x007c, "IS", "Grey Scale Threshold" },
1166     { 0x0021, 0x0080, "xs", "?" },
1167     { 0x0021, 0x0081, "DS", "Auto Window Level Alpha" },
1168     { 0x0021, 0x0082, "xs", "?" },
1169     { 0x0021, 0x0083, "DS", "Auto Window Level Window" },
1170     { 0x0021, 0x0084, "DS", "Auto Window Level Level" },
1171     { 0x0021, 0x0090, "xs", "?" },
1172     { 0x0021, 0x0091, "xs", "?" },
1173     { 0x0021, 0x0092, "xs", "?" },
1174     { 0x0021, 0x0093, "xs", "?" },
1175     { 0x0021, 0x0094, "DS", "EPI Change Value of X Component" },
1176     { 0x0021, 0x0095, "DS", "EPI Change Value of Y Component" },
1177     { 0x0021, 0x0096, "DS", "EPI Change Value of Z Component" },
1178     { 0x0021, 0x00a0, "xs", "?" },
1179     { 0x0021, 0x00a1, "DS", "?" },
1180     { 0x0021, 0x00a2, "xs", "?" },
1181     { 0x0021, 0x00a3, "LT", "?" },
1182     { 0x0021, 0x00a4, "LT", "?" },
1183     { 0x0021, 0x00a7, "LT", "?" },
1184     { 0x0021, 0x00b0, "IS", "?" },
1185     { 0x0021, 0x00c0, "IS", "?" },
1186     { 0x0023, 0x0000, "xs", "?" },
1187     { 0x0023, 0x0001, "SL", "Number Of Series In Study" },
1188     { 0x0023, 0x0002, "SL", "Number Of Unarchived Series" },
1189     { 0x0023, 0x0010, "xs", "?" },
1190     { 0x0023, 0x0020, "xs", "?" },
1191     { 0x0023, 0x0030, "xs", "?" },
1192     { 0x0023, 0x0040, "xs", "?" },
1193     { 0x0023, 0x0050, "xs", "?" },
1194     { 0x0023, 0x0060, "xs", "?" },
1195     { 0x0023, 0x0070, "xs", "?" },
1196     { 0x0023, 0x0074, "SL", "Number Of Updates To Info" },
1197     { 0x0023, 0x007d, "SS", "Indicates If Study Has Complete Info" },
1198     { 0x0023, 0x0080, "xs", "?" },
1199     { 0x0023, 0x0090, "xs", "?" },
1200     { 0x0023, 0x00ff, "US", "?" },
1201     { 0x0025, 0x0000, "UL", "Group Length" },
1202     { 0x0025, 0x0006, "SS", "Last Pulse Sequence Used" },
1203     { 0x0025, 0x0007, "SL", "Images In Series" },
1204     { 0x0025, 0x0010, "SS", "Landmark Counter" },
1205     { 0x0025, 0x0011, "SS", "Number Of Acquisitions" },
1206     { 0x0025, 0x0014, "SL", "Indicates Number Of Updates To Info" },
1207     { 0x0025, 0x0017, "SL", "Series Complete Flag" },
1208     { 0x0025, 0x0018, "SL", "Number Of Images Archived" },
1209     { 0x0025, 0x0019, "SL", "Last Image Number Used" },
1210     { 0x0025, 0x001a, "SH", "Primary Receiver Suite And Host" },
1211     { 0x0027, 0x0000, "US", "?" },
1212     { 0x0027, 0x0006, "SL", "Image Archive Flag" },
1213     { 0x0027, 0x0010, "SS", "Scout Type" },
1214     { 0x0027, 0x0011, "UN", "?" },
1215     { 0x0027, 0x0012, "IS", "?" },
1216     { 0x0027, 0x0013, "IS", "?" },
1217     { 0x0027, 0x0014, "IS", "?" },
1218     { 0x0027, 0x0015, "IS", "?" },
1219     { 0x0027, 0x0016, "LT", "?" },
1220     { 0x0027, 0x001c, "SL", "Vma Mamp" },
1221     { 0x0027, 0x001d, "SS", "Vma Phase" },
1222     { 0x0027, 0x001e, "SL", "Vma Mod" },
1223     { 0x0027, 0x001f, "SL", "Vma Clip" },
1224     { 0x0027, 0x0020, "SS", "Smart Scan On Off Flag" },
1225     { 0x0027, 0x0030, "SH", "Foreign Image Revision" },
1226     { 0x0027, 0x0031, "SS", "Imaging Mode" },
1227     { 0x0027, 0x0032, "SS", "Pulse Sequence" },
1228     { 0x0027, 0x0033, "SL", "Imaging Options" },
1229     { 0x0027, 0x0035, "SS", "Plane Type" },
1230     { 0x0027, 0x0036, "SL", "Oblique Plane" },
1231     { 0x0027, 0x0040, "SH", "RAS Letter Of Image Location" },
1232     { 0x0027, 0x0041, "FL", "Image Location" },
1233     { 0x0027, 0x0042, "FL", "Center R Coord Of Plane Image" },
1234     { 0x0027, 0x0043, "FL", "Center A Coord Of Plane Image" },
1235     { 0x0027, 0x0044, "FL", "Center S Coord Of Plane Image" },
1236     { 0x0027, 0x0045, "FL", "Normal R Coord" },
1237     { 0x0027, 0x0046, "FL", "Normal A Coord" },
1238     { 0x0027, 0x0047, "FL", "Normal S Coord" },
1239     { 0x0027, 0x0048, "FL", "R Coord Of Top Right Corner" },
1240     { 0x0027, 0x0049, "FL", "A Coord Of Top Right Corner" },
1241     { 0x0027, 0x004a, "FL", "S Coord Of Top Right Corner" },
1242     { 0x0027, 0x004b, "FL", "R Coord Of Bottom Right Corner" },
1243     { 0x0027, 0x004c, "FL", "A Coord Of Bottom Right Corner" },
1244     { 0x0027, 0x004d, "FL", "S Coord Of Bottom Right Corner" },
1245     { 0x0027, 0x0050, "FL", "Table Start Location" },
1246     { 0x0027, 0x0051, "FL", "Table End Location" },
1247     { 0x0027, 0x0052, "SH", "RAS Letter For Side Of Image" },
1248     { 0x0027, 0x0053, "SH", "RAS Letter For Anterior Posterior" },
1249     { 0x0027, 0x0054, "SH", "RAS Letter For Scout Start Loc" },
1250     { 0x0027, 0x0055, "SH", "RAS Letter For Scout End Loc" },
1251     { 0x0027, 0x0060, "FL", "Image Dimension X" },
1252     { 0x0027, 0x0061, "FL", "Image Dimension Y" },
1253     { 0x0027, 0x0062, "FL", "Number Of Excitations" },
1254     { 0x0028, 0x0000, "UL", "Image Presentation Group Length" },
1255     { 0x0028, 0x0002, "US", "Samples per Pixel" },
1256     { 0x0028, 0x0004, "CS", "Photometric Interpretation" },
1257     { 0x0028, 0x0005, "US", "Image Dimensions" },
1258     { 0x0028, 0x0006, "US", "Planar Configuration" },
1259     { 0x0028, 0x0008, "IS", "Number of Frames" },
1260     { 0x0028, 0x0009, "AT", "Frame Increment Pointer" },
1261     { 0x0028, 0x0010, "US", "Rows" },
1262     { 0x0028, 0x0011, "US", "Columns" },
1263     { 0x0028, 0x0012, "US", "Planes" },
1264     { 0x0028, 0x0014, "US", "Ultrasound Color Data Present" },
1265     { 0x0028, 0x0030, "DS", "Pixel Spacing" },
1266     { 0x0028, 0x0031, "DS", "Zoom Factor" },
1267     { 0x0028, 0x0032, "DS", "Zoom Center" },
1268     { 0x0028, 0x0034, "IS", "Pixel Aspect Ratio" },
1269     { 0x0028, 0x0040, "LO", "Image Format" },
1270     { 0x0028, 0x0050, "LT", "Manipulated Image" },
1271     { 0x0028, 0x0051, "CS", "Corrected Image" },
1272     { 0x0028, 0x005f, "LO", "Compression Recognition Code" },
1273     { 0x0028, 0x0060, "LO", "Compression Code" },
1274     { 0x0028, 0x0061, "SH", "Compression Originator" },
1275     { 0x0028, 0x0062, "SH", "Compression Label" },
1276     { 0x0028, 0x0063, "SH", "Compression Description" },
1277     { 0x0028, 0x0065, "LO", "Compression Sequence" },
1278     { 0x0028, 0x0066, "AT", "Compression Step Pointers" },
1279     { 0x0028, 0x0068, "US", "Repeat Interval" },
1280     { 0x0028, 0x0069, "US", "Bits Grouped" },
1281     { 0x0028, 0x0070, "US", "Perimeter Table" },
1282     { 0x0028, 0x0071, "xs", "Perimeter Value" },
1283     { 0x0028, 0x0080, "US", "Predictor Rows" },
1284     { 0x0028, 0x0081, "US", "Predictor Columns" },
1285     { 0x0028, 0x0082, "US", "Predictor Constants" },
1286     { 0x0028, 0x0090, "LO", "Blocked Pixels" },
1287     { 0x0028, 0x0091, "US", "Block Rows" },
1288     { 0x0028, 0x0092, "US", "Block Columns" },
1289     { 0x0028, 0x0093, "US", "Row Overlap" },
1290     { 0x0028, 0x0094, "US", "Column Overlap" },
1291     { 0x0028, 0x0100, "US", "Bits Allocated" },
1292     { 0x0028, 0x0101, "US", "Bits Stored" },
1293     { 0x0028, 0x0102, "US", "High Bit" },
1294     { 0x0028, 0x0103, "US", "Pixel Representation" },
1295     { 0x0028, 0x0104, "xs", "Smallest Valid Pixel Value" },
1296     { 0x0028, 0x0105, "xs", "Largest Valid Pixel Value" },
1297     { 0x0028, 0x0106, "xs", "Smallest Image Pixel Value" },
1298     { 0x0028, 0x0107, "xs", "Largest Image Pixel Value" },
1299     { 0x0028, 0x0108, "xs", "Smallest Pixel Value in Series" },
1300     { 0x0028, 0x0109, "xs", "Largest Pixel Value in Series" },
1301     { 0x0028, 0x0110, "xs", "Smallest Pixel Value in Plane" },
1302     { 0x0028, 0x0111, "xs", "Largest Pixel Value in Plane" },
1303     { 0x0028, 0x0120, "xs", "Pixel Padding Value" },
1304     { 0x0028, 0x0200, "xs", "Image Location" },
1305     { 0x0028, 0x0300, "CS", "Quality Control Image" },
1306     { 0x0028, 0x0301, "CS", "Burned In Annotation" },
1307     { 0x0028, 0x0400, "xs", "?" },
1308     { 0x0028, 0x0401, "xs", "?" },
1309     { 0x0028, 0x0402, "xs", "?" },
1310     { 0x0028, 0x0403, "xs", "?" },
1311     { 0x0028, 0x0404, "AT", "Details of Coefficients" },
1312     { 0x0028, 0x0700, "LO", "DCT Label" },
1313     { 0x0028, 0x0701, "LO", "Data Block Description" },
1314     { 0x0028, 0x0702, "AT", "Data Block" },
1315     { 0x0028, 0x0710, "US", "Normalization Factor Format" },
1316     { 0x0028, 0x0720, "US", "Zonal Map Number Format" },
1317     { 0x0028, 0x0721, "AT", "Zonal Map Location" },
1318     { 0x0028, 0x0722, "US", "Zonal Map Format" },
1319     { 0x0028, 0x0730, "US", "Adaptive Map Format" },
1320     { 0x0028, 0x0740, "US", "Code Number Format" },
1321     { 0x0028, 0x0800, "LO", "Code Label" },
1322     { 0x0028, 0x0802, "US", "Number of Tables" },
1323     { 0x0028, 0x0803, "AT", "Code Table Location" },
1324     { 0x0028, 0x0804, "US", "Bits For Code Word" },
1325     { 0x0028, 0x0808, "AT", "Image Data Location" },
1326     { 0x0028, 0x1040, "CS", "Pixel Intensity Relationship" },
1327     { 0x0028, 0x1041, "SS", "Pixel Intensity Relationship Sign" },
1328     { 0x0028, 0x1050, "DS", "Window Center" },
1329     { 0x0028, 0x1051, "DS", "Window Width" },
1330     { 0x0028, 0x1052, "DS", "Rescale Intercept" },
1331     { 0x0028, 0x1053, "DS", "Rescale Slope" },
1332     { 0x0028, 0x1054, "LO", "Rescale Type" },
1333     { 0x0028, 0x1055, "LO", "Window Center & Width Explanation" },
1334     { 0x0028, 0x1080, "LO", "Gray Scale" },
1335     { 0x0028, 0x1090, "CS", "Recommended Viewing Mode" },
1336     { 0x0028, 0x1100, "xs", "Gray Lookup Table Descriptor" },
1337     { 0x0028, 0x1101, "xs", "Red Palette Color Lookup Table Descriptor" },
1338     { 0x0028, 0x1102, "xs", "Green Palette Color Lookup Table Descriptor" },
1339     { 0x0028, 0x1103, "xs", "Blue Palette Color Lookup Table Descriptor" },
1340     { 0x0028, 0x1111, "OW", "Large Red Palette Color Lookup Table Descriptor" },
1341     { 0x0028, 0x1112, "OW", "Large Green Palette Color Lookup Table Descriptor" },
1342     { 0x0028, 0x1113, "OW", "Large Blue Palette Color Lookup Table Descriptor" },
1343     { 0x0028, 0x1199, "UI", "Palette Color Lookup Table UID" },
1344     { 0x0028, 0x1200, "xs", "Gray Lookup Table Data" },
1345     { 0x0028, 0x1201, "OW", "Red Palette Color Lookup Table Data" },
1346     { 0x0028, 0x1202, "OW", "Green Palette Color Lookup Table Data" },
1347     { 0x0028, 0x1203, "OW", "Blue Palette Color Lookup Table Data" },
1348     { 0x0028, 0x1211, "OW", "Large Red Palette Color Lookup Table Data" },
1349     { 0x0028, 0x1212, "OW", "Large Green Palette Color Lookup Table Data" },
1350     { 0x0028, 0x1213, "OW", "Large Blue Palette Color Lookup Table Data" },
1351     { 0x0028, 0x1214, "UI", "Large Palette Color Lookup Table UID" },
1352     { 0x0028, 0x1221, "OW", "Segmented Red Palette Color Lookup Table Data" },
1353     { 0x0028, 0x1222, "OW", "Segmented Green Palette Color Lookup Table Data" },
1354     { 0x0028, 0x1223, "OW", "Segmented Blue Palette Color Lookup Table Data" },
1355     { 0x0028, 0x1300, "CS", "Implant Present" },
1356     { 0x0028, 0x2110, "CS", "Lossy Image Compression" },
1357     { 0x0028, 0x2112, "DS", "Lossy Image Compression Ratio" },
1358     { 0x0028, 0x3000, "SQ", "Modality LUT Sequence" },
1359     { 0x0028, 0x3002, "US", "LUT Descriptor" },
1360     { 0x0028, 0x3003, "LO", "LUT Explanation" },
1361     { 0x0028, 0x3004, "LO", "Modality LUT Type" },
1362     { 0x0028, 0x3006, "US", "LUT Data" },
1363     { 0x0028, 0x3010, "xs", "VOI LUT Sequence" },
1364     { 0x0028, 0x4000, "LT", "Image Presentation Comments" },
1365     { 0x0028, 0x5000, "SQ", "Biplane Acquisition Sequence" },
1366     { 0x0028, 0x6010, "US", "Representative Frame Number" },
1367     { 0x0028, 0x6020, "US", "Frame Numbers of Interest" },
1368     { 0x0028, 0x6022, "LO", "Frame of Interest Description" },
1369     { 0x0028, 0x6030, "US", "Mask Pointer" },
1370     { 0x0028, 0x6040, "US", "R Wave Pointer" },
1371     { 0x0028, 0x6100, "SQ", "Mask Subtraction Sequence" },
1372     { 0x0028, 0x6101, "CS", "Mask Operation" },
1373     { 0x0028, 0x6102, "US", "Applicable Frame Range" },
1374     { 0x0028, 0x6110, "US", "Mask Frame Numbers" },
1375     { 0x0028, 0x6112, "US", "Contrast Frame Averaging" },
1376     { 0x0028, 0x6114, "FL", "Mask Sub-Pixel Shift" },
1377     { 0x0028, 0x6120, "SS", "TID Offset" },
1378     { 0x0028, 0x6190, "ST", "Mask Operation Explanation" },
1379     { 0x0029, 0x0000, "xs", "?" },
1380     { 0x0029, 0x0001, "xs", "?" },
1381     { 0x0029, 0x0002, "xs", "?" },
1382     { 0x0029, 0x0003, "xs", "?" },
1383     { 0x0029, 0x0004, "xs", "?" },
1384     { 0x0029, 0x0005, "xs", "?" },
1385     { 0x0029, 0x0006, "xs", "?" },
1386     { 0x0029, 0x0007, "SL", "Lower Range Of Pixels" },
1387     { 0x0029, 0x0008, "SH", "Lower Range Of Pixels" },
1388     { 0x0029, 0x0009, "SH", "Lower Range Of Pixels" },
1389     { 0x0029, 0x000a, "SS", "Lower Range Of Pixels" },
1390     { 0x0029, 0x000c, "xs", "?" },
1391     { 0x0029, 0x000e, "CS", "Zoom Enable Status" },
1392     { 0x0029, 0x000f, "CS", "Zoom Select Status" },
1393     { 0x0029, 0x0010, "xs", "?" },
1394     { 0x0029, 0x0011, "xs", "?" },
1395     { 0x0029, 0x0013, "LT", "?" },
1396     { 0x0029, 0x0015, "xs", "?" },
1397     { 0x0029, 0x0016, "SL", "Lower Range Of Pixels" },
1398     { 0x0029, 0x0017, "SL", "Lower Range Of Pixels" },
1399     { 0x0029, 0x0018, "SL", "Upper Range Of Pixels" },
1400     { 0x0029, 0x001a, "SL", "Length Of Total Info In Bytes" },
1401     { 0x0029, 0x001e, "xs", "?" },
1402     { 0x0029, 0x001f, "xs", "?" },
1403     { 0x0029, 0x0020, "xs", "?" },
1404     { 0x0029, 0x0022, "IS", "Pixel Quality Value" },
1405     { 0x0029, 0x0025, "LT", "Processed Pixel Data Quality" },
1406     { 0x0029, 0x0026, "SS", "Version Of Info Structure" },
1407     { 0x0029, 0x0030, "xs", "?" },
1408     { 0x0029, 0x0031, "xs", "?" },
1409     { 0x0029, 0x0032, "xs", "?" },
1410     { 0x0029, 0x0033, "xs", "?" },
1411     { 0x0029, 0x0034, "xs", "?" },
1412     { 0x0029, 0x0035, "SL", "Advantage Comp Underflow" },
1413     { 0x0029, 0x0038, "US", "?" },
1414     { 0x0029, 0x0040, "xs", "?" },
1415     { 0x0029, 0x0041, "DS", "Magnifying Glass Rectangle" },
1416     { 0x0029, 0x0043, "DS", "Magnifying Glass Factor" },
1417     { 0x0029, 0x0044, "US", "Magnifying Glass Function" },
1418     { 0x0029, 0x004e, "CS", "Magnifying Glass Enable Status" },
1419     { 0x0029, 0x004f, "CS", "Magnifying Glass Select Status" },
1420     { 0x0029, 0x0050, "xs", "?" },
1421     { 0x0029, 0x0051, "LT", "Exposure Code" },
1422     { 0x0029, 0x0052, "LT", "Sort Code" },
1423     { 0x0029, 0x0053, "LT", "?" },
1424     { 0x0029, 0x0060, "xs", "?" },
1425     { 0x0029, 0x0061, "xs", "?" },
1426     { 0x0029, 0x0067, "LT", "?" },
1427     { 0x0029, 0x0070, "xs", "?" },
1428     { 0x0029, 0x0071, "xs", "?" },
1429     { 0x0029, 0x0072, "xs", "?" },
1430     { 0x0029, 0x0077, "CS", "Window Select Status" },
1431     { 0x0029, 0x0078, "LT", "ECG Display Printing ID" },
1432     { 0x0029, 0x0079, "CS", "ECG Display Printing" },
1433     { 0x0029, 0x007e, "CS", "ECG Display Printing Enable Status" },
1434     { 0x0029, 0x007f, "CS", "ECG Display Printing Select Status" },
1435     { 0x0029, 0x0080, "xs", "?" },
1436     { 0x0029, 0x0081, "xs", "?" },
1437     { 0x0029, 0x0082, "IS", "View Zoom" },
1438     { 0x0029, 0x0083, "IS", "View Transform" },
1439     { 0x0029, 0x008e, "CS", "Physiological Display Enable Status" },
1440     { 0x0029, 0x008f, "CS", "Physiological Display Select Status" },
1441     { 0x0029, 0x0090, "IS", "?" },
1442     { 0x0029, 0x0099, "LT", "Shutter Type" },
1443     { 0x0029, 0x00a0, "US", "Rows of Rectangular Shutter" },
1444     { 0x0029, 0x00a1, "US", "Columns of Rectangular Shutter" },
1445     { 0x0029, 0x00a2, "US", "Origin of Rectangular Shutter" },
1446     { 0x0029, 0x00b0, "US", "Radius of Circular Shutter" },
1447     { 0x0029, 0x00b2, "US", "Origin of Circular Shutter" },
1448     { 0x0029, 0x00c0, "LT", "Functional Shutter ID" },
1449     { 0x0029, 0x00c1, "xs", "?" },
1450     { 0x0029, 0x00c3, "IS", "Scan Resolution" },
1451     { 0x0029, 0x00c4, "IS", "Field of View" },
1452     { 0x0029, 0x00c5, "LT", "Field Of Shutter Rectangle" },
1453     { 0x0029, 0x00ce, "CS", "Shutter Enable Status" },
1454     { 0x0029, 0x00cf, "CS", "Shutter Select Status" },
1455     { 0x0029, 0x00d0, "IS", "?" },
1456     { 0x0029, 0x00d1, "IS", "?" },
1457     { 0x0029, 0x00d5, "LT", "Slice Thickness" },
1458     { 0x0031, 0x0010, "LT", "Request UID" },
1459     { 0x0031, 0x0012, "LT", "Examination Reason" },
1460     { 0x0031, 0x0030, "DA", "Requested Date" },
1461     { 0x0031, 0x0032, "TM", "Worklist Request Start Time" },
1462     { 0x0031, 0x0033, "TM", "Worklist Request End Time" },
1463     { 0x0031, 0x0045, "LT", "Requesting Physician" },
1464     { 0x0031, 0x004a, "TM", "Requested Time" },
1465     { 0x0031, 0x0050, "LT", "Requested Physician" },
1466     { 0x0031, 0x0080, "LT", "Requested Location" },
1467     { 0x0032, 0x0000, "UL", "Study Group Length" },
1468     { 0x0032, 0x000a, "CS", "Study Status ID" },
1469     { 0x0032, 0x000c, "CS", "Study Priority ID" },
1470     { 0x0032, 0x0012, "LO", "Study ID Issuer" },
1471     { 0x0032, 0x0032, "DA", "Study Verified Date" },
1472     { 0x0032, 0x0033, "TM", "Study Verified Time" },
1473     { 0x0032, 0x0034, "DA", "Study Read Date" },
1474     { 0x0032, 0x0035, "TM", "Study Read Time" },
1475     { 0x0032, 0x1000, "DA", "Scheduled Study Start Date" },
1476     { 0x0032, 0x1001, "TM", "Scheduled Study Start Time" },
1477     { 0x0032, 0x1010, "DA", "Scheduled Study Stop Date" },
1478     { 0x0032, 0x1011, "TM", "Scheduled Study Stop Time" },
1479     { 0x0032, 0x1020, "LO", "Scheduled Study Location" },
1480     { 0x0032, 0x1021, "AE", "Scheduled Study Location AE Title(s)" },
1481     { 0x0032, 0x1030, "LO", "Reason for Study" },
1482     { 0x0032, 0x1032, "PN", "Requesting Physician" },
1483     { 0x0032, 0x1033, "LO", "Requesting Service" },
1484     { 0x0032, 0x1040, "DA", "Study Arrival Date" },
1485     { 0x0032, 0x1041, "TM", "Study Arrival Time" },
1486     { 0x0032, 0x1050, "DA", "Study Completion Date" },
1487     { 0x0032, 0x1051, "TM", "Study Completion Time" },
1488     { 0x0032, 0x1055, "CS", "Study Component Status ID" },
1489     { 0x0032, 0x1060, "LO", "Requested Procedure Description" },
1490     { 0x0032, 0x1064, "SQ", "Requested Procedure Code Sequence" },
1491     { 0x0032, 0x1070, "LO", "Requested Contrast Agent" },
1492     { 0x0032, 0x4000, "LT", "Study Comments" },
1493     { 0x0033, 0x0001, "UN", "?" },
1494     { 0x0033, 0x0002, "UN", "?" },
1495     { 0x0033, 0x0005, "UN", "?" },
1496     { 0x0033, 0x0006, "UN", "?" },
1497     { 0x0033, 0x0010, "LT", "Patient Study UID" },
1498     { 0x0037, 0x0010, "LO", "ReferringDepartment" },
1499     { 0x0037, 0x0020, "US", "ScreenNumber" },
1500     { 0x0037, 0x0040, "SH", "LeftOrientation" },
1501     { 0x0037, 0x0042, "SH", "RightOrientation" },
1502     { 0x0037, 0x0050, "CS", "Inversion" },
1503     { 0x0037, 0x0060, "US", "DSA" },
1504     { 0x0038, 0x0000, "UL", "Visit Group Length" },
1505     { 0x0038, 0x0004, "SQ", "Referenced Patient Alias Sequence" },
1506     { 0x0038, 0x0008, "CS", "Visit Status ID" },
1507     { 0x0038, 0x0010, "LO", "Admission ID" },
1508     { 0x0038, 0x0011, "LO", "Issuer of Admission ID" },
1509     { 0x0038, 0x0016, "LO", "Route of Admissions" },
1510     { 0x0038, 0x001a, "DA", "Scheduled Admission Date" },
1511     { 0x0038, 0x001b, "TM", "Scheduled Admission Time" },
1512     { 0x0038, 0x001c, "DA", "Scheduled Discharge Date" },
1513     { 0x0038, 0x001d, "TM", "Scheduled Discharge Time" },
1514     { 0x0038, 0x001e, "LO", "Scheduled Patient Institution Residence" },
1515     { 0x0038, 0x0020, "DA", "Admitting Date" },
1516     { 0x0038, 0x0021, "TM", "Admitting Time" },
1517     { 0x0038, 0x0030, "DA", "Discharge Date" },
1518     { 0x0038, 0x0032, "TM", "Discharge Time" },
1519     { 0x0038, 0x0040, "LO", "Discharge Diagnosis Description" },
1520     { 0x0038, 0x0044, "SQ", "Discharge Diagnosis Code Sequence" },
1521     { 0x0038, 0x0050, "LO", "Special Needs" },
1522     { 0x0038, 0x0300, "LO", "Current Patient Location" },
1523     { 0x0038, 0x0400, "LO", "Patient's Institution Residence" },
1524     { 0x0038, 0x0500, "LO", "Patient State" },
1525     { 0x0038, 0x4000, "LT", "Visit Comments" },
1526     { 0x0039, 0x0080, "IS", "Private Entity Number" },
1527     { 0x0039, 0x0085, "DA", "Private Entity Date" },
1528     { 0x0039, 0x0090, "TM", "Private Entity Time" },
1529     { 0x0039, 0x0095, "LO", "Private Entity Launch Command" },
1530     { 0x0039, 0x00aa, "CS", "Private Entity Type" },
1531     { 0x003a, 0x0002, "SQ", "Waveform Sequence" },
1532     { 0x003a, 0x0005, "US", "Waveform Number of Channels" },
1533     { 0x003a, 0x0010, "UL", "Waveform Number of Samples" },
1534     { 0x003a, 0x001a, "DS", "Sampling Frequency" },
1535     { 0x003a, 0x0020, "SH", "Group Label" },
1536     { 0x003a, 0x0103, "CS", "Waveform Sample Value Representation" },
1537     { 0x003a, 0x0122, "OB", "Waveform Padding Value" },
1538     { 0x003a, 0x0200, "SQ", "Channel Definition" },
1539     { 0x003a, 0x0202, "IS", "Waveform Channel Number" },
1540     { 0x003a, 0x0203, "SH", "Channel Label" },
1541     { 0x003a, 0x0205, "CS", "Channel Status" },
1542     { 0x003a, 0x0208, "SQ", "Channel Source" },
1543     { 0x003a, 0x0209, "SQ", "Channel Source Modifiers" },
1544     { 0x003a, 0x020a, "SQ", "Differential Channel Source" },
1545     { 0x003a, 0x020b, "SQ", "Differential Channel Source Modifiers" },
1546     { 0x003a, 0x0210, "DS", "Channel Sensitivity" },
1547     { 0x003a, 0x0211, "SQ", "Channel Sensitivity Units" },
1548     { 0x003a, 0x0212, "DS", "Channel Sensitivity Correction Factor" },
1549     { 0x003a, 0x0213, "DS", "Channel Baseline" },
1550     { 0x003a, 0x0214, "DS", "Channel Time Skew" },
1551     { 0x003a, 0x0215, "DS", "Channel Sample Skew" },
1552     { 0x003a, 0x0216, "OB", "Channel Minimum Value" },
1553     { 0x003a, 0x0217, "OB", "Channel Maximum Value" },
1554     { 0x003a, 0x0218, "DS", "Channel Offset" },
1555     { 0x003a, 0x021a, "US", "Bits Per Sample" },
1556     { 0x003a, 0x0220, "DS", "Filter Low Frequency" },
1557     { 0x003a, 0x0221, "DS", "Filter High Frequency" },
1558     { 0x003a, 0x0222, "DS", "Notch Filter Frequency" },
1559     { 0x003a, 0x0223, "DS", "Notch Filter Bandwidth" },
1560     { 0x003a, 0x1000, "OB", "Waveform Data" },
1561     { 0x0040, 0x0001, "AE", "Scheduled Station AE Title" },
1562     { 0x0040, 0x0002, "DA", "Scheduled Procedure Step Start Date" },
1563     { 0x0040, 0x0003, "TM", "Scheduled Procedure Step Start Time" },
1564     { 0x0040, 0x0004, "DA", "Scheduled Procedure Step End Date" },
1565     { 0x0040, 0x0005, "TM", "Scheduled Procedure Step End Time" },
1566     { 0x0040, 0x0006, "PN", "Scheduled Performing Physician Name" },
1567     { 0x0040, 0x0007, "LO", "Scheduled Procedure Step Description" },
1568     { 0x0040, 0x0008, "SQ", "Scheduled Action Item Code Sequence" },
1569     { 0x0040, 0x0009, "SH", "Scheduled Procedure Step ID" },
1570     { 0x0040, 0x0010, "SH", "Scheduled Station Name" },
1571     { 0x0040, 0x0011, "SH", "Scheduled Procedure Step Location" },
1572     { 0x0040, 0x0012, "LO", "Pre-Medication" },
1573     { 0x0040, 0x0020, "CS", "Scheduled Procedure Step Status" },
1574     { 0x0040, 0x0100, "SQ", "Scheduled Procedure Step Sequence" },
1575     { 0x0040, 0x0302, "US", "Entrance Dose" },
1576     { 0x0040, 0x0303, "US", "Exposed Area" },
1577     { 0x0040, 0x0306, "DS", "Distance Source to Entrance" },
1578     { 0x0040, 0x0307, "DS", "Distance Source to Support" },
1579     { 0x0040, 0x0310, "ST", "Comments On Radiation Dose" },
1580     { 0x0040, 0x0312, "DS", "X-Ray Output" },
1581     { 0x0040, 0x0314, "DS", "Half Value Layer" },
1582     { 0x0040, 0x0316, "DS", "Organ Dose" },
1583     { 0x0040, 0x0318, "CS", "Organ Exposed" },
1584     { 0x0040, 0x0400, "LT", "Comments On Scheduled Procedure Step" },
1585     { 0x0040, 0x050a, "LO", "Specimen Accession Number" },
1586     { 0x0040, 0x0550, "SQ", "Specimen Sequence" },
1587     { 0x0040, 0x0551, "LO", "Specimen Identifier" },
1588     { 0x0040, 0x0552, "SQ", "Specimen Description Sequence" },
1589     { 0x0040, 0x0553, "ST", "Specimen Description" },
1590     { 0x0040, 0x0555, "SQ", "Acquisition Context Sequence" },
1591     { 0x0040, 0x0556, "ST", "Acquisition Context Description" },
1592     { 0x0040, 0x059a, "SQ", "Specimen Type Code Sequence" },
1593     { 0x0040, 0x06fa, "LO", "Slide Identifier" },
1594     { 0x0040, 0x071a, "SQ", "Image Center Point Coordinates Sequence" },
1595     { 0x0040, 0x072a, "DS", "X Offset In Slide Coordinate System" },
1596     { 0x0040, 0x073a, "DS", "Y Offset In Slide Coordinate System" },
1597     { 0x0040, 0x074a, "DS", "Z Offset In Slide Coordinate System" },
1598     { 0x0040, 0x08d8, "SQ", "Pixel Spacing Sequence" },
1599     { 0x0040, 0x08da, "SQ", "Coordinate System Axis Code Sequence" },
1600     { 0x0040, 0x08ea, "SQ", "Measurement Units Code Sequence" },
1601     { 0x0040, 0x09f8, "SQ", "Vital Stain Code Sequence" },
1602     { 0x0040, 0x1001, "SH", "Requested Procedure ID" },
1603     { 0x0040, 0x1002, "LO", "Reason For Requested Procedure" },
1604     { 0x0040, 0x1003, "SH", "Requested Procedure Priority" },
1605     { 0x0040, 0x1004, "LO", "Patient Transport Arrangements" },
1606     { 0x0040, 0x1005, "LO", "Requested Procedure Location" },
1607     { 0x0040, 0x1006, "SH", "Placer Order Number of Procedure" },
1608     { 0x0040, 0x1007, "SH", "Filler Order Number of Procedure" },
1609     { 0x0040, 0x1008, "LO", "Confidentiality Code" },
1610     { 0x0040, 0x1009, "SH", "Reporting Priority" },
1611     { 0x0040, 0x1010, "PN", "Names of Intended Recipients of Results" },
1612     { 0x0040, 0x1400, "LT", "Requested Procedure Comments" },
1613     { 0x0040, 0x2001, "LO", "Reason For Imaging Service Request" },
1614     { 0x0040, 0x2004, "DA", "Issue Date of Imaging Service Request" },
1615     { 0x0040, 0x2005, "TM", "Issue Time of Imaging Service Request" },
1616     { 0x0040, 0x2006, "SH", "Placer Order Number of Imaging Service Request" },
1617     { 0x0040, 0x2007, "SH", "Filler Order Number of Imaging Service Request" },
1618     { 0x0040, 0x2008, "PN", "Order Entered By" },
1619     { 0x0040, 0x2009, "SH", "Order Enterer Location" },
1620     { 0x0040, 0x2010, "SH", "Order Callback Phone Number" },
1621     { 0x0040, 0x2400, "LT", "Imaging Service Request Comments" },
1622     { 0x0040, 0x3001, "LO", "Confidentiality Constraint On Patient Data" },
1623     { 0x0040, 0xa007, "CS", "Findings Flag" },
1624     { 0x0040, 0xa020, "SQ", "Findings Sequence" },
1625     { 0x0040, 0xa021, "UI", "Findings Group UID" },
1626     { 0x0040, 0xa022, "UI", "Referenced Findings Group UID" },
1627     { 0x0040, 0xa023, "DA", "Findings Group Recording Date" },
1628     { 0x0040, 0xa024, "TM", "Findings Group Recording Time" },
1629     { 0x0040, 0xa026, "SQ", "Findings Source Category Code Sequence" },
1630     { 0x0040, 0xa027, "LO", "Documenting Organization" },
1631     { 0x0040, 0xa028, "SQ", "Documenting Organization Identifier Code Sequence" },
1632     { 0x0040, 0xa032, "LO", "History Reliability Qualifier Description" },
1633     { 0x0040, 0xa043, "SQ", "Concept Name Code Sequence" },
1634     { 0x0040, 0xa047, "LO", "Measurement Precision Description" },
1635     { 0x0040, 0xa057, "CS", "Urgency or Priority Alerts" },
1636     { 0x0040, 0xa060, "LO", "Sequencing Indicator" },
1637     { 0x0040, 0xa066, "SQ", "Document Identifier Code Sequence" },
1638     { 0x0040, 0xa067, "PN", "Document Author" },
1639     { 0x0040, 0xa068, "SQ", "Document Author Identifier Code Sequence" },
1640     { 0x0040, 0xa070, "SQ", "Identifier Code Sequence" },
1641     { 0x0040, 0xa073, "LO", "Object String Identifier" },
1642     { 0x0040, 0xa074, "OB", "Object Binary Identifier" },
1643     { 0x0040, 0xa075, "PN", "Documenting Observer" },
1644     { 0x0040, 0xa076, "SQ", "Documenting Observer Identifier Code Sequence" },
1645     { 0x0040, 0xa078, "SQ", "Observation Subject Identifier Code Sequence" },
1646     { 0x0040, 0xa080, "SQ", "Person Identifier Code Sequence" },
1647     { 0x0040, 0xa085, "SQ", "Procedure Identifier Code Sequence" },
1648     { 0x0040, 0xa088, "LO", "Object Directory String Identifier" },
1649     { 0x0040, 0xa089, "OB", "Object Directory Binary Identifier" },
1650     { 0x0040, 0xa090, "CS", "History Reliability Qualifier" },
1651     { 0x0040, 0xa0a0, "CS", "Referenced Type of Data" },
1652     { 0x0040, 0xa0b0, "US", "Referenced Waveform Channels" },
1653     { 0x0040, 0xa110, "DA", "Date of Document or Verbal Transaction" },
1654     { 0x0040, 0xa112, "TM", "Time of Document Creation or Verbal Transaction" },
1655     { 0x0040, 0xa121, "DA", "Date" },
1656     { 0x0040, 0xa122, "TM", "Time" },
1657     { 0x0040, 0xa123, "PN", "Person Name" },
1658     { 0x0040, 0xa124, "SQ", "Referenced Person Sequence" },
1659     { 0x0040, 0xa125, "CS", "Report Status ID" },
1660     { 0x0040, 0xa130, "CS", "Temporal Range Type" },
1661     { 0x0040, 0xa132, "UL", "Referenced Sample Offsets" },
1662     { 0x0040, 0xa136, "US", "Referenced Frame Numbers" },
1663     { 0x0040, 0xa138, "DS", "Referenced Time Offsets" },
1664     { 0x0040, 0xa13a, "DT", "Referenced Datetime" },
1665     { 0x0040, 0xa160, "UT", "Text Value" },
1666     { 0x0040, 0xa167, "SQ", "Observation Category Code Sequence" },
1667     { 0x0040, 0xa168, "SQ", "Concept Code Sequence" },
1668     { 0x0040, 0xa16a, "ST", "Bibliographic Citation" },
1669     { 0x0040, 0xa170, "CS", "Observation Class" },
1670     { 0x0040, 0xa171, "UI", "Observation UID" },
1671     { 0x0040, 0xa172, "UI", "Referenced Observation UID" },
1672     { 0x0040, 0xa173, "CS", "Referenced Observation Class" },
1673     { 0x0040, 0xa174, "CS", "Referenced Object Observation Class" },
1674     { 0x0040, 0xa180, "US", "Annotation Group Number" },
1675     { 0x0040, 0xa192, "DA", "Observation Date" },
1676     { 0x0040, 0xa193, "TM", "Observation Time" },
1677     { 0x0040, 0xa194, "CS", "Measurement Automation" },
1678     { 0x0040, 0xa195, "SQ", "Concept Name Code Sequence Modifier" },
1679     { 0x0040, 0xa224, "ST", "Identification Description" },
1680     { 0x0040, 0xa290, "CS", "Coordinates Set Geometric Type" },
1681     { 0x0040, 0xa296, "SQ", "Algorithm Code Sequence" },
1682     { 0x0040, 0xa297, "ST", "Algorithm Description" },
1683     { 0x0040, 0xa29a, "SL", "Pixel Coordinates Set" },
1684     { 0x0040, 0xa300, "SQ", "Measured Value Sequence" },
1685     { 0x0040, 0xa307, "PN", "Current Observer" },
1686     { 0x0040, 0xa30a, "DS", "Numeric Value" },
1687     { 0x0040, 0xa313, "SQ", "Referenced Accession Sequence" },
1688     { 0x0040, 0xa33a, "ST", "Report Status Comment" },
1689     { 0x0040, 0xa340, "SQ", "Procedure Context Sequence" },
1690     { 0x0040, 0xa352, "PN", "Verbal Source" },
1691     { 0x0040, 0xa353, "ST", "Address" },
1692     { 0x0040, 0xa354, "LO", "Telephone Number" },
1693     { 0x0040, 0xa358, "SQ", "Verbal Source Identifier Code Sequence" },
1694     { 0x0040, 0xa380, "SQ", "Report Detail Sequence" },
1695     { 0x0040, 0xa402, "UI", "Observation Subject UID" },
1696     { 0x0040, 0xa403, "CS", "Observation Subject Class" },
1697     { 0x0040, 0xa404, "SQ", "Observation Subject Type Code Sequence" },
1698     { 0x0040, 0xa600, "CS", "Observation Subject Context Flag" },
1699     { 0x0040, 0xa601, "CS", "Observer Context Flag" },
1700     { 0x0040, 0xa603, "CS", "Procedure Context Flag" },
1701     { 0x0040, 0xa730, "SQ", "Observations Sequence" },
1702     { 0x0040, 0xa731, "SQ", "Relationship Sequence" },
1703     { 0x0040, 0xa732, "SQ", "Relationship Type Code Sequence" },
1704     { 0x0040, 0xa744, "SQ", "Language Code Sequence" },
1705     { 0x0040, 0xa992, "ST", "Uniform Resource Locator" },
1706     { 0x0040, 0xb020, "SQ", "Annotation Sequence" },
1707     { 0x0040, 0xdb73, "SQ", "Relationship Type Code Sequence Modifier" },
1708     { 0x0041, 0x0000, "LT", "Papyrus Comments" },
1709     { 0x0041, 0x0010, "xs", "?" },
1710     { 0x0041, 0x0011, "xs", "?" },
1711     { 0x0041, 0x0012, "UL", "Pixel Offset" },
1712     { 0x0041, 0x0013, "SQ", "Image Identifier Sequence" },
1713     { 0x0041, 0x0014, "SQ", "External File Reference Sequence" },
1714     { 0x0041, 0x0015, "US", "Number of Images" },
1715     { 0x0041, 0x0020, "xs", "?" },
1716     { 0x0041, 0x0021, "UI", "Referenced SOP Class UID" },
1717     { 0x0041, 0x0022, "UI", "Referenced SOP Instance UID" },
1718     { 0x0041, 0x0030, "xs", "?" },
1719     { 0x0041, 0x0031, "xs", "?" },
1720     { 0x0041, 0x0032, "xs", "?" },
1721     { 0x0041, 0x0034, "DA", "Modified Date" },
1722     { 0x0041, 0x0036, "TM", "Modified Time" },
1723     { 0x0041, 0x0040, "LT", "Owner Name" },
1724     { 0x0041, 0x0041, "UI", "Referenced Image SOP Class UID" },
1725     { 0x0041, 0x0042, "UI", "Referenced Image SOP Instance UID" },
1726     { 0x0041, 0x0050, "xs", "?" },
1727     { 0x0041, 0x0060, "UL", "Number of Images" },
1728     { 0x0041, 0x0062, "UL", "Number of Other" },
1729     { 0x0041, 0x00a0, "LT", "External Folder Element DSID" },
1730     { 0x0041, 0x00a1, "US", "External Folder Element Data Set Type" },
1731     { 0x0041, 0x00a2, "LT", "External Folder Element File Location" },
1732     { 0x0041, 0x00a3, "UL", "External Folder Element Length" },
1733     { 0x0041, 0x00b0, "LT", "Internal Folder Element DSID" },
1734     { 0x0041, 0x00b1, "US", "Internal Folder Element Data Set Type" },
1735     { 0x0041, 0x00b2, "UL", "Internal Offset To Data Set" },
1736     { 0x0041, 0x00b3, "UL", "Internal Offset To Image" },
1737     { 0x0043, 0x0001, "SS", "Bitmap Of Prescan Options" },
1738     { 0x0043, 0x0002, "SS", "Gradient Offset In X" },
1739     { 0x0043, 0x0003, "SS", "Gradient Offset In Y" },
1740     { 0x0043, 0x0004, "SS", "Gradient Offset In Z" },
1741     { 0x0043, 0x0005, "SS", "Image Is Original Or Unoriginal" },
1742     { 0x0043, 0x0006, "SS", "Number Of EPI Shots" },
1743     { 0x0043, 0x0007, "SS", "Views Per Segment" },
1744     { 0x0043, 0x0008, "SS", "Respiratory Rate In BPM" },
1745     { 0x0043, 0x0009, "SS", "Respiratory Trigger Point" },
1746     { 0x0043, 0x000a, "SS", "Type Of Receiver Used" },
1747     { 0x0043, 0x000b, "DS", "Peak Rate Of Change Of Gradient Field" },
1748     { 0x0043, 0x000c, "DS", "Limits In Units Of Percent" },
1749     { 0x0043, 0x000d, "DS", "PSD Estimated Limit" },
1750     { 0x0043, 0x000e, "DS", "PSD Estimated Limit In Tesla Per Second" },
1751     { 0x0043, 0x000f, "DS", "SAR Avg Head" },
1752     { 0x0043, 0x0010, "US", "Window Value" },
1753     { 0x0043, 0x0011, "US", "Total Input Views" },
1754     { 0x0043, 0x0012, "SS", "Xray Chain" },
1755     { 0x0043, 0x0013, "SS", "Recon Kernel Parameters" },
1756     { 0x0043, 0x0014, "SS", "Calibration Parameters" },
1757     { 0x0043, 0x0015, "SS", "Total Output Views" },
1758     { 0x0043, 0x0016, "SS", "Number Of Overranges" },
1759     { 0x0043, 0x0017, "DS", "IBH Image Scale Factors" },
1760     { 0x0043, 0x0018, "DS", "BBH Coefficients" },
1761     { 0x0043, 0x0019, "SS", "Number Of BBH Chains To Blend" },
1762     { 0x0043, 0x001a, "SL", "Starting Channel Number" },
1763     { 0x0043, 0x001b, "SS", "PPScan Parameters" },
1764     { 0x0043, 0x001c, "SS", "GE Image Integrity" },
1765     { 0x0043, 0x001d, "SS", "Level Value" },
1766     { 0x0043, 0x001e, "xs", "?" },
1767     { 0x0043, 0x001f, "SL", "Max Overranges In A View" },
1768     { 0x0043, 0x0020, "DS", "Avg Overranges All Views" },
1769     { 0x0043, 0x0021, "SS", "Corrected Afterglow Terms" },
1770     { 0x0043, 0x0025, "SS", "Reference Channels" },
1771     { 0x0043, 0x0026, "US", "No Views Ref Channels Blocked" },
1772     { 0x0043, 0x0027, "xs", "?" },
1773     { 0x0043, 0x0028, "OB", "Unique Image Identifier" },
1774     { 0x0043, 0x0029, "OB", "Histogram Tables" },
1775     { 0x0043, 0x002a, "OB", "User Defined Data" },
1776     { 0x0043, 0x002b, "SS", "Private Scan Options" },
1777     { 0x0043, 0x002c, "SS", "Effective Echo Spacing" },
1778     { 0x0043, 0x002d, "SH", "String Slop Field 1" },
1779     { 0x0043, 0x002e, "SH", "String Slop Field 2" },
1780     { 0x0043, 0x002f, "SS", "Raw Data Type" },
1781     { 0x0043, 0x0030, "SS", "Raw Data Type" },
1782     { 0x0043, 0x0031, "DS", "RA Coord Of Target Recon Centre" },
1783     { 0x0043, 0x0032, "SS", "Raw Data Type" },
1784     { 0x0043, 0x0033, "FL", "Neg Scan Spacing" },
1785     { 0x0043, 0x0034, "IS", "Offset Frequency" },
1786     { 0x0043, 0x0035, "UL", "User Usage Tag" },
1787     { 0x0043, 0x0036, "UL", "User Fill Map MSW" },
1788     { 0x0043, 0x0037, "UL", "User Fill Map LSW" },
1789     { 0x0043, 0x0038, "FL", "User 25 To User 48" },
1790     { 0x0043, 0x0039, "IS", "Slop Integer 6 To Slop Integer 9" },
1791     { 0x0043, 0x0040, "FL", "Trigger On Position" },
1792     { 0x0043, 0x0041, "FL", "Degree Of Rotation" },
1793     { 0x0043, 0x0042, "SL", "DAS Trigger Source" },
1794     { 0x0043, 0x0043, "SL", "DAS Fpa Gain" },
1795     { 0x0043, 0x0044, "SL", "DAS Output Source" },
1796     { 0x0043, 0x0045, "SL", "DAS Ad Input" },
1797     { 0x0043, 0x0046, "SL", "DAS Cal Mode" },
1798     { 0x0043, 0x0047, "SL", "DAS Cal Frequency" },
1799     { 0x0043, 0x0048, "SL", "DAS Reg Xm" },
1800     { 0x0043, 0x0049, "SL", "DAS Auto Zero" },
1801     { 0x0043, 0x004a, "SS", "Starting Channel Of View" },
1802     { 0x0043, 0x004b, "SL", "DAS Xm Pattern" },
1803     { 0x0043, 0x004c, "SS", "TGGC Trigger Mode" },
1804     { 0x0043, 0x004d, "FL", "Start Scan To Xray On Delay" },
1805     { 0x0043, 0x004e, "FL", "Duration Of Xray On" },
1806     { 0x0044, 0x0000, "UI", "?" },
1807     { 0x0045, 0x0004, "CS", "AES" },
1808     { 0x0045, 0x0006, "DS", "Angulation" },
1809     { 0x0045, 0x0009, "DS", "Real Magnification Factor" },
1810     { 0x0045, 0x000b, "CS", "Senograph Type" },
1811     { 0x0045, 0x000c, "DS", "Integration Time" },
1812     { 0x0045, 0x000d, "DS", "ROI Origin X and Y" },
1813     { 0x0045, 0x0011, "DS", "Receptor Size cm X and Y" },
1814     { 0x0045, 0x0012, "IS", "Receptor Size Pixels X and Y" },
1815     { 0x0045, 0x0013, "ST", "Screen" },
1816     { 0x0045, 0x0014, "DS", "Pixel Pitch Microns" },
1817     { 0x0045, 0x0015, "IS", "Pixel Depth Bits" },
1818     { 0x0045, 0x0016, "IS", "Binning Factor X and Y" },
1819     { 0x0045, 0x001b, "CS", "Clinical View" },
1820     { 0x0045, 0x001d, "DS", "Mean Of Raw Gray Levels" },
1821     { 0x0045, 0x001e, "DS", "Mean Of Offset Gray Levels" },
1822     { 0x0045, 0x001f, "DS", "Mean Of Corrected Gray Levels" },
1823     { 0x0045, 0x0020, "DS", "Mean Of Region Gray Levels" },
1824     { 0x0045, 0x0021, "DS", "Mean Of Log Region Gray Levels" },
1825     { 0x0045, 0x0022, "DS", "Standard Deviation Of Raw Gray Levels" },
1826     { 0x0045, 0x0023, "DS", "Standard Deviation Of Corrected Gray Levels" },
1827     { 0x0045, 0x0024, "DS", "Standard Deviation Of Region Gray Levels" },
1828     { 0x0045, 0x0025, "DS", "Standard Deviation Of Log Region Gray Levels" },
1829     { 0x0045, 0x0026, "OB", "MAO Buffer" },
1830     { 0x0045, 0x0027, "IS", "Set Number" },
1831     { 0x0045, 0x0028, "CS", "WindowingType (LINEAR or GAMMA)" },
1832     { 0x0045, 0x0029, "DS", "WindowingParameters" },
1833     { 0x0045, 0x002a, "IS", "Crosshair Cursor X Coordinates" },
1834     { 0x0045, 0x002b, "IS", "Crosshair Cursor Y Coordinates" },
1835     { 0x0045, 0x0039, "US", "Vignette Rows" },
1836     { 0x0045, 0x003a, "US", "Vignette Columns" },
1837     { 0x0045, 0x003b, "US", "Vignette Bits Allocated" },
1838     { 0x0045, 0x003c, "US", "Vignette Bits Stored" },
1839     { 0x0045, 0x003d, "US", "Vignette High Bit" },
1840     { 0x0045, 0x003e, "US", "Vignette Pixel Representation" },
1841     { 0x0045, 0x003f, "OB", "Vignette Pixel Data" },
1842     { 0x0047, 0x0001, "SQ", "Reconstruction Parameters Sequence" },
1843     { 0x0047, 0x0050, "UL", "Volume Voxel Count" },
1844     { 0x0047, 0x0051, "UL", "Volume Segment Count" },
1845     { 0x0047, 0x0053, "US", "Volume Slice Size" },
1846     { 0x0047, 0x0054, "US", "Volume Slice Count" },
1847     { 0x0047, 0x0055, "SL", "Volume Threshold Value" },
1848     { 0x0047, 0x0057, "DS", "Volume Voxel Ratio" },
1849     { 0x0047, 0x0058, "DS", "Volume Voxel Size" },
1850     { 0x0047, 0x0059, "US", "Volume Z Position Size" },
1851     { 0x0047, 0x0060, "DS", "Volume Base Line" },
1852     { 0x0047, 0x0061, "DS", "Volume Center Point" },
1853     { 0x0047, 0x0063, "SL", "Volume Skew Base" },
1854     { 0x0047, 0x0064, "DS", "Volume Registration Transform Rotation Matrix" },
1855     { 0x0047, 0x0065, "DS", "Volume Registration Transform Translation Vector" },
1856     { 0x0047, 0x0070, "DS", "KVP List" },
1857     { 0x0047, 0x0071, "IS", "XRay Tube Current List" },
1858     { 0x0047, 0x0072, "IS", "Exposure List" },
1859     { 0x0047, 0x0080, "LO", "Acquisition DLX Identifier" },
1860     { 0x0047, 0x0085, "SQ", "Acquisition DLX 2D Series Sequence" },
1861     { 0x0047, 0x0089, "DS", "Contrast Agent Volume List" },
1862     { 0x0047, 0x008a, "US", "Number Of Injections" },
1863     { 0x0047, 0x008b, "US", "Frame Count" },
1864     { 0x0047, 0x0096, "IS", "Used Frames" },
1865     { 0x0047, 0x0091, "LO", "XA 3D Reconstruction Algorithm Name" },
1866     { 0x0047, 0x0092, "CS", "XA 3D Reconstruction Algorithm Version" },
1867     { 0x0047, 0x0093, "DA", "DLX Calibration Date" },
1868     { 0x0047, 0x0094, "TM", "DLX Calibration Time" },
1869     { 0x0047, 0x0095, "CS", "DLX Calibration Status" },
1870     { 0x0047, 0x0098, "US", "Transform Count" },
1871     { 0x0047, 0x0099, "SQ", "Transform Sequence" },
1872     { 0x0047, 0x009a, "DS", "Transform Rotation Matrix" },
1873     { 0x0047, 0x009b, "DS", "Transform Translation Vector" },
1874     { 0x0047, 0x009c, "LO", "Transform Label" },
1875     { 0x0047, 0x00b1, "US", "Wireframe Count" },
1876     { 0x0047, 0x00b2, "US", "Location System" },
1877     { 0x0047, 0x00b0, "SQ", "Wireframe List" },
1878     { 0x0047, 0x00b5, "LO", "Wireframe Name" },
1879     { 0x0047, 0x00b6, "LO", "Wireframe Group Name" },
1880     { 0x0047, 0x00b7, "LO", "Wireframe Color" },
1881     { 0x0047, 0x00b8, "SL", "Wireframe Attributes" },
1882     { 0x0047, 0x00b9, "SL", "Wireframe Point Count" },
1883     { 0x0047, 0x00ba, "SL", "Wireframe Timestamp" },
1884     { 0x0047, 0x00bb, "SQ", "Wireframe Point List" },
1885     { 0x0047, 0x00bc, "DS", "Wireframe Points Coordinates" },
1886     { 0x0047, 0x00c0, "DS", "Volume Upper Left High Corner RAS" },
1887     { 0x0047, 0x00c1, "DS", "Volume Slice To RAS Rotation Matrix" },
1888     { 0x0047, 0x00c2, "DS", "Volume Upper Left High Corner TLOC" },
1889     { 0x0047, 0x00d1, "OB", "Volume Segment List" },
1890     { 0x0047, 0x00d2, "OB", "Volume Gradient List" },
1891     { 0x0047, 0x00d3, "OB", "Volume Density List" },
1892     { 0x0047, 0x00d4, "OB", "Volume Z Position List" },
1893     { 0x0047, 0x00d5, "OB", "Volume Original Index List" },
1894     { 0x0050, 0x0000, "UL", "Calibration Group Length" },
1895     { 0x0050, 0x0004, "CS", "Calibration Object" },
1896     { 0x0050, 0x0010, "SQ", "DeviceSequence" },
1897     { 0x0050, 0x0014, "DS", "DeviceLength" },
1898     { 0x0050, 0x0016, "DS", "DeviceDiameter" },
1899     { 0x0050, 0x0017, "CS", "DeviceDiameterUnits" },
1900     { 0x0050, 0x0018, "DS", "DeviceVolume" },
1901     { 0x0050, 0x0019, "DS", "InterMarkerDistance" },
1902     { 0x0050, 0x0020, "LO", "DeviceDescription" },
1903     { 0x0050, 0x0030, "SQ", "CodedInterventionDeviceSequence" },
1904     { 0x0051, 0x0010, "xs", "Image Text" },
1905     { 0x0054, 0x0000, "UL", "Nuclear Acquisition Group Length" },
1906     { 0x0054, 0x0010, "US", "Energy Window Vector" },
1907     { 0x0054, 0x0011, "US", "Number of Energy Windows" },
1908     { 0x0054, 0x0012, "SQ", "Energy Window Information Sequence" },
1909     { 0x0054, 0x0013, "SQ", "Energy Window Range Sequence" },
1910     { 0x0054, 0x0014, "DS", "Energy Window Lower Limit" },
1911     { 0x0054, 0x0015, "DS", "Energy Window Upper Limit" },
1912     { 0x0054, 0x0016, "SQ", "Radiopharmaceutical Information Sequence" },
1913     { 0x0054, 0x0017, "IS", "Residual Syringe Counts" },
1914     { 0x0054, 0x0018, "SH", "Energy Window Name" },
1915     { 0x0054, 0x0020, "US", "Detector Vector" },
1916     { 0x0054, 0x0021, "US", "Number of Detectors" },
1917     { 0x0054, 0x0022, "SQ", "Detector Information Sequence" },
1918     { 0x0054, 0x0030, "US", "Phase Vector" },
1919     { 0x0054, 0x0031, "US", "Number of Phases" },
1920     { 0x0054, 0x0032, "SQ", "Phase Information Sequence" },
1921     { 0x0054, 0x0033, "US", "Number of Frames In Phase" },
1922     { 0x0054, 0x0036, "IS", "Phase Delay" },
1923     { 0x0054, 0x0038, "IS", "Pause Between Frames" },
1924     { 0x0054, 0x0050, "US", "Rotation Vector" },
1925     { 0x0054, 0x0051, "US", "Number of Rotations" },
1926     { 0x0054, 0x0052, "SQ", "Rotation Information Sequence" },
1927     { 0x0054, 0x0053, "US", "Number of Frames In Rotation" },
1928     { 0x0054, 0x0060, "US", "R-R Interval Vector" },
1929     { 0x0054, 0x0061, "US", "Number of R-R Intervals" },
1930     { 0x0054, 0x0062, "SQ", "Gated Information Sequence" },
1931     { 0x0054, 0x0063, "SQ", "Data Information Sequence" },
1932     { 0x0054, 0x0070, "US", "Time Slot Vector" },
1933     { 0x0054, 0x0071, "US", "Number of Time Slots" },
1934     { 0x0054, 0x0072, "SQ", "Time Slot Information Sequence" },
1935     { 0x0054, 0x0073, "DS", "Time Slot Time" },
1936     { 0x0054, 0x0080, "US", "Slice Vector" },
1937     { 0x0054, 0x0081, "US", "Number of Slices" },
1938     { 0x0054, 0x0090, "US", "Angular View Vector" },
1939     { 0x0054, 0x0100, "US", "Time Slice Vector" },
1940     { 0x0054, 0x0101, "US", "Number Of Time Slices" },
1941     { 0x0054, 0x0200, "DS", "Start Angle" },
1942     { 0x0054, 0x0202, "CS", "Type of Detector Motion" },
1943     { 0x0054, 0x0210, "IS", "Trigger Vector" },
1944     { 0x0054, 0x0211, "US", "Number of Triggers in Phase" },
1945     { 0x0054, 0x0220, "SQ", "View Code Sequence" },
1946     { 0x0054, 0x0222, "SQ", "View Modifier Code Sequence" },
1947     { 0x0054, 0x0300, "SQ", "Radionuclide Code Sequence" },
1948     { 0x0054, 0x0302, "SQ", "Radiopharmaceutical Route Code Sequence" },
1949     { 0x0054, 0x0304, "SQ", "Radiopharmaceutical Code Sequence" },
1950     { 0x0054, 0x0306, "SQ", "Calibration Data Sequence" },
1951     { 0x0054, 0x0308, "US", "Energy Window Number" },
1952     { 0x0054, 0x0400, "SH", "Image ID" },
1953     { 0x0054, 0x0410, "SQ", "Patient Orientation Code Sequence" },
1954     { 0x0054, 0x0412, "SQ", "Patient Orientation Modifier Code Sequence" },
1955     { 0x0054, 0x0414, "SQ", "Patient Gantry Relationship Code Sequence" },
1956     { 0x0054, 0x1000, "CS", "Positron Emission Tomography Series Type" },
1957     { 0x0054, 0x1001, "CS", "Positron Emission Tomography Units" },
1958     { 0x0054, 0x1002, "CS", "Counts Source" },
1959     { 0x0054, 0x1004, "CS", "Reprojection Method" },
1960     { 0x0054, 0x1100, "CS", "Randoms Correction Method" },
1961     { 0x0054, 0x1101, "LO", "Attenuation Correction Method" },
1962     { 0x0054, 0x1102, "CS", "Decay Correction" },
1963     { 0x0054, 0x1103, "LO", "Reconstruction Method" },
1964     { 0x0054, 0x1104, "LO", "Detector Lines of Response Used" },
1965     { 0x0054, 0x1105, "LO", "Scatter Correction Method" },
1966     { 0x0054, 0x1200, "DS", "Axial Acceptance" },
1967     { 0x0054, 0x1201, "IS", "Axial Mash" },
1968     { 0x0054, 0x1202, "IS", "Transverse Mash" },
1969     { 0x0054, 0x1203, "DS", "Detector Element Size" },
1970     { 0x0054, 0x1210, "DS", "Coincidence Window Width" },
1971     { 0x0054, 0x1220, "CS", "Secondary Counts Type" },
1972     { 0x0054, 0x1300, "DS", "Frame Reference Time" },
1973     { 0x0054, 0x1310, "IS", "Primary Prompts Counts Accumulated" },
1974     { 0x0054, 0x1311, "IS", "Secondary Counts Accumulated" },
1975     { 0x0054, 0x1320, "DS", "Slice Sensitivity Factor" },
1976     { 0x0054, 0x1321, "DS", "Decay Factor" },
1977     { 0x0054, 0x1322, "DS", "Dose Calibration Factor" },
1978     { 0x0054, 0x1323, "DS", "Scatter Fraction Factor" },
1979     { 0x0054, 0x1324, "DS", "Dead Time Factor" },
1980     { 0x0054, 0x1330, "US", "Image Index" },
1981     { 0x0054, 0x1400, "CS", "Counts Included" },
1982     { 0x0054, 0x1401, "CS", "Dead Time Correction Flag" },
1983     { 0x0055, 0x0046, "LT", "Current Ward" },
1984     { 0x0058, 0x0000, "SQ", "?" },
1985     { 0x0060, 0x3000, "SQ", "Histogram Sequence" },
1986     { 0x0060, 0x3002, "US", "Histogram Number of Bins" },
1987     { 0x0060, 0x3004, "xs", "Histogram First Bin Value" },
1988     { 0x0060, 0x3006, "xs", "Histogram Last Bin Value" },
1989     { 0x0060, 0x3008, "US", "Histogram Bin Width" },
1990     { 0x0060, 0x3010, "LO", "Histogram Explanation" },
1991     { 0x0060, 0x3020, "UL", "Histogram Data" },
1992     { 0x0070, 0x0001, "SQ", "Graphic Annotation Sequence" },
1993     { 0x0070, 0x0002, "CS", "Graphic Layer" },
1994     { 0x0070, 0x0003, "CS", "Bounding Box Annotation Units" },
1995     { 0x0070, 0x0004, "CS", "Anchor Point Annotation Units" },
1996     { 0x0070, 0x0005, "CS", "Graphic Annotation Units" },
1997     { 0x0070, 0x0006, "ST", "Unformatted Text Value" },
1998     { 0x0070, 0x0008, "SQ", "Text Object Sequence" },
1999     { 0x0070, 0x0009, "SQ", "Graphic Object Sequence" },
2000     { 0x0070, 0x0010, "FL", "Bounding Box TLHC" },
2001     { 0x0070, 0x0011, "FL", "Bounding Box BRHC" },
2002     { 0x0070, 0x0014, "FL", "Anchor Point" },
2003     { 0x0070, 0x0015, "CS", "Anchor Point Visibility" },
2004     { 0x0070, 0x0020, "US", "Graphic Dimensions" },
2005     { 0x0070, 0x0021, "US", "Number Of Graphic Points" },
2006     { 0x0070, 0x0022, "FL", "Graphic Data" },
2007     { 0x0070, 0x0023, "CS", "Graphic Type" },
2008     { 0x0070, 0x0024, "CS", "Graphic Filled" },
2009     { 0x0070, 0x0040, "IS", "Image Rotation" },
2010     { 0x0070, 0x0041, "CS", "Image Horizontal Flip" },
2011     { 0x0070, 0x0050, "US", "Displayed Area TLHC" },
2012     { 0x0070, 0x0051, "US", "Displayed Area BRHC" },
2013     { 0x0070, 0x0060, "SQ", "Graphic Layer Sequence" },
2014     { 0x0070, 0x0062, "IS", "Graphic Layer Order" },
2015     { 0x0070, 0x0066, "US", "Graphic Layer Recommended Display Value" },
2016     { 0x0070, 0x0068, "LO", "Graphic Layer Description" },
2017     { 0x0070, 0x0080, "CS", "Presentation Label" },
2018     { 0x0070, 0x0081, "LO", "Presentation Description" },
2019     { 0x0070, 0x0082, "DA", "Presentation Creation Date" },
2020     { 0x0070, 0x0083, "TM", "Presentation Creation Time" },
2021     { 0x0070, 0x0084, "PN", "Presentation Creator's Name" },
2022     { 0x0087, 0x0010, "CS", "Media Type" },
2023     { 0x0087, 0x0020, "CS", "Media Location" },
2024     { 0x0087, 0x0050, "IS", "Estimated Retrieve Time" },
2025     { 0x0088, 0x0000, "UL", "Storage Group Length" },
2026     { 0x0088, 0x0130, "SH", "Storage Media FileSet ID" },
2027     { 0x0088, 0x0140, "UI", "Storage Media FileSet UID" },
2028     { 0x0088, 0x0200, "SQ", "Icon Image Sequence" },
2029     { 0x0088, 0x0904, "LO", "Topic Title" },
2030     { 0x0088, 0x0906, "ST", "Topic Subject" },
2031     { 0x0088, 0x0910, "LO", "Topic Author" },
2032     { 0x0088, 0x0912, "LO", "Topic Key Words" },
2033     { 0x0095, 0x0001, "LT", "Examination Folder ID" },
2034     { 0x0095, 0x0004, "UL", "Folder Reported Status" },
2035     { 0x0095, 0x0005, "LT", "Folder Reporting Radiologist" },
2036     { 0x0095, 0x0007, "LT", "SIENET ISA PLA" },
2037     { 0x0099, 0x0002, "UL", "Data Object Attributes" },
2038     { 0x00e1, 0x0001, "US", "Data Dictionary Version" },
2039     { 0x00e1, 0x0014, "LT", "?" },
2040     { 0x00e1, 0x0022, "DS", "?" },
2041     { 0x00e1, 0x0023, "DS", "?" },
2042     { 0x00e1, 0x0024, "LT", "?" },
2043     { 0x00e1, 0x0025, "LT", "?" },
2044     { 0x00e1, 0x0040, "SH", "Offset From CT MR Images" },
2045     { 0x0193, 0x0002, "DS", "RIS Key" },
2046     { 0x0307, 0x0001, "UN", "RIS Worklist IMGEF" },
2047     { 0x0309, 0x0001, "UN", "RIS Report IMGEF" },
2048     { 0x0601, 0x0000, "SH", "Implementation Version" },
2049     { 0x0601, 0x0020, "DS", "Relative Table Position" },
2050     { 0x0601, 0x0021, "DS", "Relative Table Height" },
2051     { 0x0601, 0x0030, "SH", "Surview Direction" },
2052     { 0x0601, 0x0031, "DS", "Surview Length" },
2053     { 0x0601, 0x0050, "SH", "Image View Type" },
2054     { 0x0601, 0x0070, "DS", "Batch Number" },
2055     { 0x0601, 0x0071, "DS", "Batch Size" },
2056     { 0x0601, 0x0072, "DS", "Batch Slice Number" },
2057     { 0x1000, 0x0000, "xs", "?" },
2058     { 0x1000, 0x0001, "US", "Run Length Triplet" },
2059     { 0x1000, 0x0002, "US", "Huffman Table Size" },
2060     { 0x1000, 0x0003, "US", "Huffman Table Triplet" },
2061     { 0x1000, 0x0004, "US", "Shift Table Size" },
2062     { 0x1000, 0x0005, "US", "Shift Table Triplet" },
2063     { 0x1010, 0x0000, "xs", "?" },
2064     { 0x1369, 0x0000, "US", "?" },
2065     { 0x2000, 0x0000, "UL", "Film Session Group Length" },
2066     { 0x2000, 0x0010, "IS", "Number of Copies" },
2067     { 0x2000, 0x0020, "CS", "Print Priority" },
2068     { 0x2000, 0x0030, "CS", "Medium Type" },
2069     { 0x2000, 0x0040, "CS", "Film Destination" },
2070     { 0x2000, 0x0050, "LO", "Film Session Label" },
2071     { 0x2000, 0x0060, "IS", "Memory Allocation" },
2072     { 0x2000, 0x0500, "SQ", "Referenced Film Box Sequence" },
2073     { 0x2010, 0x0000, "UL", "Film Box Group Length" },
2074     { 0x2010, 0x0010, "ST", "Image Display Format" },
2075     { 0x2010, 0x0030, "CS", "Annotation Display Format ID" },
2076     { 0x2010, 0x0040, "CS", "Film Orientation" },
2077     { 0x2010, 0x0050, "CS", "Film Size ID" },
2078     { 0x2010, 0x0060, "CS", "Magnification Type" },
2079     { 0x2010, 0x0080, "CS", "Smoothing Type" },
2080     { 0x2010, 0x0100, "CS", "Border Density" },
2081     { 0x2010, 0x0110, "CS", "Empty Image Density" },
2082     { 0x2010, 0x0120, "US", "Min Density" },
2083     { 0x2010, 0x0130, "US", "Max Density" },
2084     { 0x2010, 0x0140, "CS", "Trim" },
2085     { 0x2010, 0x0150, "ST", "Configuration Information" },
2086     { 0x2010, 0x0500, "SQ", "Referenced Film Session Sequence" },
2087     { 0x2010, 0x0510, "SQ", "Referenced Image Box Sequence" },
2088     { 0x2010, 0x0520, "SQ", "Referenced Basic Annotation Box Sequence" },
2089     { 0x2020, 0x0000, "UL", "Image Box Group Length" },
2090     { 0x2020, 0x0010, "US", "Image Box Position" },
2091     { 0x2020, 0x0020, "CS", "Polarity" },
2092     { 0x2020, 0x0030, "DS", "Requested Image Size" },
2093     { 0x2020, 0x0110, "SQ", "Preformatted Grayscale Image Sequence" },
2094     { 0x2020, 0x0111, "SQ", "Preformatted Color Image Sequence" },
2095     { 0x2020, 0x0130, "SQ", "Referenced Image Overlay Box Sequence" },
2096     { 0x2020, 0x0140, "SQ", "Referenced VOI LUT Box Sequence" },
2097     { 0x2030, 0x0000, "UL", "Annotation Group Length" },
2098     { 0x2030, 0x0010, "US", "Annotation Position" },
2099     { 0x2030, 0x0020, "LO", "Text String" },
2100     { 0x2040, 0x0000, "UL", "Overlay Box Group Length" },
2101     { 0x2040, 0x0010, "SQ", "Referenced Overlay Plane Sequence" },
2102     { 0x2040, 0x0011, "US", "Referenced Overlay Plane Groups" },
2103     { 0x2040, 0x0060, "CS", "Overlay Magnification Type" },
2104     { 0x2040, 0x0070, "CS", "Overlay Smoothing Type" },
2105     { 0x2040, 0x0080, "CS", "Overlay Foreground Density" },
2106     { 0x2040, 0x0090, "CS", "Overlay Mode" },
2107     { 0x2040, 0x0100, "CS", "Threshold Density" },
2108     { 0x2040, 0x0500, "SQ", "Referenced Overlay Image Box Sequence" },
2109     { 0x2050, 0x0010, "SQ", "Presentation LUT Sequence" },
2110     { 0x2050, 0x0020, "CS", "Presentation LUT Shape" },
2111     { 0x2100, 0x0000, "UL", "Print Job Group Length" },
2112     { 0x2100, 0x0020, "CS", "Execution Status" },
2113     { 0x2100, 0x0030, "CS", "Execution Status Info" },
2114     { 0x2100, 0x0040, "DA", "Creation Date" },
2115     { 0x2100, 0x0050, "TM", "Creation Time" },
2116     { 0x2100, 0x0070, "AE", "Originator" },
2117     { 0x2100, 0x0500, "SQ", "Referenced Print Job Sequence" },
2118     { 0x2110, 0x0000, "UL", "Printer Group Length" },
2119     { 0x2110, 0x0010, "CS", "Printer Status" },
2120     { 0x2110, 0x0020, "CS", "Printer Status Info" },
2121     { 0x2110, 0x0030, "LO", "Printer Name" },
2122     { 0x2110, 0x0099, "SH", "Print Queue ID" },
2123     { 0x3002, 0x0002, "SH", "RT Image Label" },
2124     { 0x3002, 0x0003, "LO", "RT Image Name" },
2125     { 0x3002, 0x0004, "ST", "RT Image Description" },
2126     { 0x3002, 0x000a, "CS", "Reported Values Origin" },
2127     { 0x3002, 0x000c, "CS", "RT Image Plane" },
2128     { 0x3002, 0x000e, "DS", "X-Ray Image Receptor Angle" },
2129     { 0x3002, 0x0010, "DS", "RTImageOrientation" },
2130     { 0x3002, 0x0011, "DS", "Image Plane Pixel Spacing" },
2131     { 0x3002, 0x0012, "DS", "RT Image Position" },
2132     { 0x3002, 0x0020, "SH", "Radiation Machine Name" },
2133     { 0x3002, 0x0022, "DS", "Radiation Machine SAD" },
2134     { 0x3002, 0x0024, "DS", "Radiation Machine SSD" },
2135     { 0x3002, 0x0026, "DS", "RT Image SID" },
2136     { 0x3002, 0x0028, "DS", "Source to Reference Object Distance" },
2137     { 0x3002, 0x0029, "IS", "Fraction Number" },
2138     { 0x3002, 0x0030, "SQ", "Exposure Sequence" },
2139     { 0x3002, 0x0032, "DS", "Meterset Exposure" },
2140     { 0x3004, 0x0001, "CS", "DVH Type" },
2141     { 0x3004, 0x0002, "CS", "Dose Units" },
2142     { 0x3004, 0x0004, "CS", "Dose Type" },
2143     { 0x3004, 0x0006, "LO", "Dose Comment" },
2144     { 0x3004, 0x0008, "DS", "Normalization Point" },
2145     { 0x3004, 0x000a, "CS", "Dose Summation Type" },
2146     { 0x3004, 0x000c, "DS", "GridFrame Offset Vector" },
2147     { 0x3004, 0x000e, "DS", "Dose Grid Scaling" },
2148     { 0x3004, 0x0010, "SQ", "RT Dose ROI Sequence" },
2149     { 0x3004, 0x0012, "DS", "Dose Value" },
2150     { 0x3004, 0x0040, "DS", "DVH Normalization Point" },
2151     { 0x3004, 0x0042, "DS", "DVH Normalization Dose Value" },
2152     { 0x3004, 0x0050, "SQ", "DVH Sequence" },
2153     { 0x3004, 0x0052, "DS", "DVH Dose Scaling" },
2154     { 0x3004, 0x0054, "CS", "DVH Volume Units" },
2155     { 0x3004, 0x0056, "IS", "DVH Number of Bins" },
2156     { 0x3004, 0x0058, "DS", "DVH Data" },
2157     { 0x3004, 0x0060, "SQ", "DVH Referenced ROI Sequence" },
2158     { 0x3004, 0x0062, "CS", "DVH ROI Contribution Type" },
2159     { 0x3004, 0x0070, "DS", "DVH Minimum Dose" },
2160     { 0x3004, 0x0072, "DS", "DVH Maximum Dose" },
2161     { 0x3004, 0x0074, "DS", "DVH Mean Dose" },
2162     { 0x3006, 0x0002, "SH", "Structure Set Label" },
2163     { 0x3006, 0x0004, "LO", "Structure Set Name" },
2164     { 0x3006, 0x0006, "ST", "Structure Set Description" },
2165     { 0x3006, 0x0008, "DA", "Structure Set Date" },
2166     { 0x3006, 0x0009, "TM", "Structure Set Time" },
2167     { 0x3006, 0x0010, "SQ", "Referenced Frame of Reference Sequence" },
2168     { 0x3006, 0x0012, "SQ", "RT Referenced Study Sequence" },
2169     { 0x3006, 0x0014, "SQ", "RT Referenced Series Sequence" },
2170     { 0x3006, 0x0016, "SQ", "Contour Image Sequence" },
2171     { 0x3006, 0x0020, "SQ", "Structure Set ROI Sequence" },
2172     { 0x3006, 0x0022, "IS", "ROI Number" },
2173     { 0x3006, 0x0024, "UI", "Referenced Frame of Reference UID" },
2174     { 0x3006, 0x0026, "LO", "ROI Name" },
2175     { 0x3006, 0x0028, "ST", "ROI Description" },
2176     { 0x3006, 0x002a, "IS", "ROI Display Color" },
2177     { 0x3006, 0x002c, "DS", "ROI Volume" },
2178     { 0x3006, 0x0030, "SQ", "RT Related ROI Sequence" },
2179     { 0x3006, 0x0033, "CS", "RT ROI Relationship" },
2180     { 0x3006, 0x0036, "CS", "ROI Generation Algorithm" },
2181     { 0x3006, 0x0038, "LO", "ROI Generation Description" },
2182     { 0x3006, 0x0039, "SQ", "ROI Contour Sequence" },
2183     { 0x3006, 0x0040, "SQ", "Contour Sequence" },
2184     { 0x3006, 0x0042, "CS", "Contour Geometric Type" },
2185     { 0x3006, 0x0044, "DS", "Contour SlabT hickness" },
2186     { 0x3006, 0x0045, "DS", "Contour Offset Vector" },
2187     { 0x3006, 0x0046, "IS", "Number of Contour Points" },
2188     { 0x3006, 0x0050, "DS", "Contour Data" },
2189     { 0x3006, 0x0080, "SQ", "RT ROI Observations Sequence" },
2190     { 0x3006, 0x0082, "IS", "Observation Number" },
2191     { 0x3006, 0x0084, "IS", "Referenced ROI Number" },
2192     { 0x3006, 0x0085, "SH", "ROI Observation Label" },
2193     { 0x3006, 0x0086, "SQ", "RT ROI Identification Code Sequence" },
2194     { 0x3006, 0x0088, "ST", "ROI Observation Description" },
2195     { 0x3006, 0x00a0, "SQ", "Related RT ROI Observations Sequence" },
2196     { 0x3006, 0x00a4, "CS", "RT ROI Interpreted Type" },
2197     { 0x3006, 0x00a6, "PN", "ROI Interpreter" },
2198     { 0x3006, 0x00b0, "SQ", "ROI Physical Properties Sequence" },
2199     { 0x3006, 0x00b2, "CS", "ROI Physical Property" },
2200     { 0x3006, 0x00b4, "DS", "ROI Physical Property Value" },
2201     { 0x3006, 0x00c0, "SQ", "Frame of Reference Relationship Sequence" },
2202     { 0x3006, 0x00c2, "UI", "Related Frame of Reference UID" },
2203     { 0x3006, 0x00c4, "CS", "Frame of Reference Transformation Type" },
2204     { 0x3006, 0x00c6, "DS", "Frame of Reference Transformation Matrix" },
2205     { 0x3006, 0x00c8, "LO", "Frame of Reference Transformation Comment" },
2206     { 0x300a, 0x0002, "SH", "RT Plan Label" },
2207     { 0x300a, 0x0003, "LO", "RT Plan Name" },
2208     { 0x300a, 0x0004, "ST", "RT Plan Description" },
2209     { 0x300a, 0x0006, "DA", "RT Plan Date" },
2210     { 0x300a, 0x0007, "TM", "RT Plan Time" },
2211     { 0x300a, 0x0009, "LO", "Treatment Protocols" },
2212     { 0x300a, 0x000a, "CS", "Treatment Intent" },
2213     { 0x300a, 0x000b, "LO", "Treatment Sites" },
2214     { 0x300a, 0x000c, "CS", "RT Plan Geometry" },
2215     { 0x300a, 0x000e, "ST", "Prescription Description" },
2216     { 0x300a, 0x0010, "SQ", "Dose ReferenceSequence" },
2217     { 0x300a, 0x0012, "IS", "Dose ReferenceNumber" },
2218     { 0x300a, 0x0014, "CS", "Dose Reference Structure Type" },
2219     { 0x300a, 0x0016, "LO", "Dose ReferenceDescription" },
2220     { 0x300a, 0x0018, "DS", "Dose Reference Point Coordinates" },
2221     { 0x300a, 0x001a, "DS", "Nominal Prior Dose" },
2222     { 0x300a, 0x0020, "CS", "Dose Reference Type" },
2223     { 0x300a, 0x0021, "DS", "Constraint Weight" },
2224     { 0x300a, 0x0022, "DS", "Delivery Warning Dose" },
2225     { 0x300a, 0x0023, "DS", "Delivery Maximum Dose" },
2226     { 0x300a, 0x0025, "DS", "Target Minimum Dose" },
2227     { 0x300a, 0x0026, "DS", "Target Prescription Dose" },
2228     { 0x300a, 0x0027, "DS", "Target Maximum Dose" },
2229     { 0x300a, 0x0028, "DS", "Target Underdose Volume Fraction" },
2230     { 0x300a, 0x002a, "DS", "Organ at Risk Full-volume Dose" },
2231     { 0x300a, 0x002b, "DS", "Organ at Risk Limit Dose" },
2232     { 0x300a, 0x002c, "DS", "Organ at Risk Maximum Dose" },
2233     { 0x300a, 0x002d, "DS", "Organ at Risk Overdose Volume Fraction" },
2234     { 0x300a, 0x0040, "SQ", "Tolerance Table Sequence" },
2235     { 0x300a, 0x0042, "IS", "Tolerance Table Number" },
2236     { 0x300a, 0x0043, "SH", "Tolerance Table Label" },
2237     { 0x300a, 0x0044, "DS", "Gantry Angle Tolerance" },
2238     { 0x300a, 0x0046, "DS", "Beam Limiting Device Angle Tolerance" },
2239     { 0x300a, 0x0048, "SQ", "Beam Limiting Device Tolerance Sequence" },
2240     { 0x300a, 0x004a, "DS", "Beam Limiting Device Position Tolerance" },
2241     { 0x300a, 0x004c, "DS", "Patient Support Angle Tolerance" },
2242     { 0x300a, 0x004e, "DS", "Table Top Eccentric Angle Tolerance" },
2243     { 0x300a, 0x0051, "DS", "Table Top Vertical Position Tolerance" },
2244     { 0x300a, 0x0052, "DS", "Table Top Longitudinal Position Tolerance" },
2245     { 0x300a, 0x0053, "DS", "Table Top Lateral Position Tolerance" },
2246     { 0x300a, 0x0055, "CS", "RT Plan Relationship" },
2247     { 0x300a, 0x0070, "SQ", "Fraction Group Sequence" },
2248     { 0x300a, 0x0071, "IS", "Fraction Group Number" },
2249     { 0x300a, 0x0078, "IS", "Number of Fractions Planned" },
2250     { 0x300a, 0x0079, "IS", "Number of Fractions Per Day" },
2251     { 0x300a, 0x007a, "IS", "Repeat Fraction Cycle Length" },
2252     { 0x300a, 0x007b, "LT", "Fraction Pattern" },
2253     { 0x300a, 0x0080, "IS", "Number of Beams" },
2254     { 0x300a, 0x0082, "DS", "Beam Dose Specification Point" },
2255     { 0x300a, 0x0084, "DS", "Beam Dose" },
2256     { 0x300a, 0x0086, "DS", "Beam Meterset" },
2257     { 0x300a, 0x00a0, "IS", "Number of Brachy Application Setups" },
2258     { 0x300a, 0x00a2, "DS", "Brachy Application Setup Dose Specification Point" },
2259     { 0x300a, 0x00a4, "DS", "Brachy Application Setup Dose" },
2260     { 0x300a, 0x00b0, "SQ", "Beam Sequence" },
2261     { 0x300a, 0x00b2, "SH", "Treatment Machine Name " },
2262     { 0x300a, 0x00b3, "CS", "Primary Dosimeter Unit" },
2263     { 0x300a, 0x00b4, "DS", "Source-Axis Distance" },
2264     { 0x300a, 0x00b6, "SQ", "Beam Limiting Device Sequence" },
2265     { 0x300a, 0x00b8, "CS", "RT Beam Limiting Device Type" },
2266     { 0x300a, 0x00ba, "DS", "Source to Beam Limiting Device Distance" },
2267     { 0x300a, 0x00bc, "IS", "Number of Leaf/Jaw Pairs" },
2268     { 0x300a, 0x00be, "DS", "Leaf Position Boundaries" },
2269     { 0x300a, 0x00c0, "IS", "Beam Number" },
2270     { 0x300a, 0x00c2, "LO", "Beam Name" },
2271     { 0x300a, 0x00c3, "ST", "Beam Description" },
2272     { 0x300a, 0x00c4, "CS", "Beam Type" },
2273     { 0x300a, 0x00c6, "CS", "Radiation Type" },
2274     { 0x300a, 0x00c8, "IS", "Reference Image Number" },
2275     { 0x300a, 0x00ca, "SQ", "Planned Verification Image Sequence" },
2276     { 0x300a, 0x00cc, "LO", "Imaging Device Specific Acquisition Parameters" },
2277     { 0x300a, 0x00ce, "CS", "Treatment Delivery Type" },
2278     { 0x300a, 0x00d0, "IS", "Number of Wedges" },
2279     { 0x300a, 0x00d1, "SQ", "Wedge Sequence" },
2280     { 0x300a, 0x00d2, "IS", "Wedge Number" },
2281     { 0x300a, 0x00d3, "CS", "Wedge Type" },
2282     { 0x300a, 0x00d4, "SH", "Wedge ID" },
2283     { 0x300a, 0x00d5, "IS", "Wedge Angle" },
2284     { 0x300a, 0x00d6, "DS", "Wedge Factor" },
2285     { 0x300a, 0x00d8, "DS", "Wedge Orientation" },
2286     { 0x300a, 0x00da, "DS", "Source to Wedge Tray Distance" },
2287     { 0x300a, 0x00e0, "IS", "Number of Compensators" },
2288     { 0x300a, 0x00e1, "SH", "Material ID" },
2289     { 0x300a, 0x00e2, "DS", "Total Compensator Tray Factor" },
2290     { 0x300a, 0x00e3, "SQ", "Compensator Sequence" },
2291     { 0x300a, 0x00e4, "IS", "Compensator Number" },
2292     { 0x300a, 0x00e5, "SH", "Compensator ID" },
2293     { 0x300a, 0x00e6, "DS", "Source to Compensator Tray Distance" },
2294     { 0x300a, 0x00e7, "IS", "Compensator Rows" },
2295     { 0x300a, 0x00e8, "IS", "Compensator Columns" },
2296     { 0x300a, 0x00e9, "DS", "Compensator Pixel Spacing" },
2297     { 0x300a, 0x00ea, "DS", "Compensator Position" },
2298     { 0x300a, 0x00eb, "DS", "Compensator Transmission Data" },
2299     { 0x300a, 0x00ec, "DS", "Compensator Thickness Data" },
2300     { 0x300a, 0x00ed, "IS", "Number of Boli" },
2301     { 0x300a, 0x00f0, "IS", "Number of Blocks" },
2302     { 0x300a, 0x00f2, "DS", "Total Block Tray Factor" },
2303     { 0x300a, 0x00f4, "SQ", "Block Sequence" },
2304     { 0x300a, 0x00f5, "SH", "Block Tray ID" },
2305     { 0x300a, 0x00f6, "DS", "Source to Block Tray Distance" },
2306     { 0x300a, 0x00f8, "CS", "Block Type" },
2307     { 0x300a, 0x00fa, "CS", "Block Divergence" },
2308     { 0x300a, 0x00fc, "IS", "Block Number" },
2309     { 0x300a, 0x00fe, "LO", "Block Name" },
2310     { 0x300a, 0x0100, "DS", "Block Thickness" },
2311     { 0x300a, 0x0102, "DS", "Block Transmission" },
2312     { 0x300a, 0x0104, "IS", "Block Number of Points" },
2313     { 0x300a, 0x0106, "DS", "Block Data" },
2314     { 0x300a, 0x0107, "SQ", "Applicator Sequence" },
2315     { 0x300a, 0x0108, "SH", "Applicator ID" },
2316     { 0x300a, 0x0109, "CS", "Applicator Type" },
2317     { 0x300a, 0x010a, "LO", "Applicator Description" },
2318     { 0x300a, 0x010c, "DS", "Cumulative Dose Reference Coefficient" },
2319     { 0x300a, 0x010e, "DS", "Final Cumulative Meterset Weight" },
2320     { 0x300a, 0x0110, "IS", "Number of Control Points" },
2321     { 0x300a, 0x0111, "SQ", "Control Point Sequence" },
2322     { 0x300a, 0x0112, "IS", "Control Point Index" },
2323     { 0x300a, 0x0114, "DS", "Nominal Beam Energy" },
2324     { 0x300a, 0x0115, "DS", "Dose Rate Set" },
2325     { 0x300a, 0x0116, "SQ", "Wedge Position Sequence" },
2326     { 0x300a, 0x0118, "CS", "Wedge Position" },
2327     { 0x300a, 0x011a, "SQ", "Beam Limiting Device Position Sequence" },
2328     { 0x300a, 0x011c, "DS", "Leaf Jaw Positions" },
2329     { 0x300a, 0x011e, "DS", "Gantry Angle" },
2330     { 0x300a, 0x011f, "CS", "Gantry Rotation Direction" },
2331     { 0x300a, 0x0120, "DS", "Beam Limiting Device Angle" },
2332     { 0x300a, 0x0121, "CS", "Beam Limiting Device Rotation Direction" },
2333     { 0x300a, 0x0122, "DS", "Patient Support Angle" },
2334     { 0x300a, 0x0123, "CS", "Patient Support Rotation Direction" },
2335     { 0x300a, 0x0124, "DS", "Table Top Eccentric Axis Distance" },
2336     { 0x300a, 0x0125, "DS", "Table Top Eccentric Angle" },
2337     { 0x300a, 0x0126, "CS", "Table Top Eccentric Rotation Direction" },
2338     { 0x300a, 0x0128, "DS", "Table Top Vertical Position" },
2339     { 0x300a, 0x0129, "DS", "Table Top Longitudinal Position" },
2340     { 0x300a, 0x012a, "DS", "Table Top Lateral Position" },
2341     { 0x300a, 0x012c, "DS", "Isocenter Position" },
2342     { 0x300a, 0x012e, "DS", "Surface Entry Point" },
2343     { 0x300a, 0x0130, "DS", "Source to Surface Distance" },
2344     { 0x300a, 0x0134, "DS", "Cumulative Meterset Weight" },
2345     { 0x300a, 0x0180, "SQ", "Patient Setup Sequence" },
2346     { 0x300a, 0x0182, "IS", "Patient Setup Number" },
2347     { 0x300a, 0x0184, "LO", "Patient Additional Position" },
2348     { 0x300a, 0x0190, "SQ", "Fixation Device Sequence" },
2349     { 0x300a, 0x0192, "CS", "Fixation Device Type" },
2350     { 0x300a, 0x0194, "SH", "Fixation Device Label" },
2351     { 0x300a, 0x0196, "ST", "Fixation Device Description" },
2352     { 0x300a, 0x0198, "SH", "Fixation Device Position" },
2353     { 0x300a, 0x01a0, "SQ", "Shielding Device Sequence" },
2354     { 0x300a, 0x01a2, "CS", "Shielding Device Type" },
2355     { 0x300a, 0x01a4, "SH", "Shielding Device Label" },
2356     { 0x300a, 0x01a6, "ST", "Shielding Device Description" },
2357     { 0x300a, 0x01a8, "SH", "Shielding Device Position" },
2358     { 0x300a, 0x01b0, "CS", "Setup Technique" },
2359     { 0x300a, 0x01b2, "ST", "Setup TechniqueDescription" },
2360     { 0x300a, 0x01b4, "SQ", "Setup Device Sequence" },
2361     { 0x300a, 0x01b6, "CS", "Setup Device Type" },
2362     { 0x300a, 0x01b8, "SH", "Setup Device Label" },
2363     { 0x300a, 0x01ba, "ST", "Setup Device Description" },
2364     { 0x300a, 0x01bc, "DS", "Setup Device Parameter" },
2365     { 0x300a, 0x01d0, "ST", "Setup ReferenceDescription" },
2366     { 0x300a, 0x01d2, "DS", "Table Top Vertical Setup Displacement" },
2367     { 0x300a, 0x01d4, "DS", "Table Top Longitudinal Setup Displacement" },
2368     { 0x300a, 0x01d6, "DS", "Table Top Lateral Setup Displacement" },
2369     { 0x300a, 0x0200, "CS", "Brachy Treatment Technique" },
2370     { 0x300a, 0x0202, "CS", "Brachy Treatment Type" },
2371     { 0x300a, 0x0206, "SQ", "Treatment Machine Sequence" },
2372     { 0x300a, 0x0210, "SQ", "Source Sequence" },
2373     { 0x300a, 0x0212, "IS", "Source Number" },
2374     { 0x300a, 0x0214, "CS", "Source Type" },
2375     { 0x300a, 0x0216, "LO", "Source Manufacturer" },
2376     { 0x300a, 0x0218, "DS", "Active Source Diameter" },
2377     { 0x300a, 0x021a, "DS", "Active Source Length" },
2378     { 0x300a, 0x0222, "DS", "Source Encapsulation Nominal Thickness" },
2379     { 0x300a, 0x0224, "DS", "Source Encapsulation Nominal Transmission" },
2380     { 0x300a, 0x0226, "LO", "Source IsotopeName" },
2381     { 0x300a, 0x0228, "DS", "Source Isotope Half Life" },
2382     { 0x300a, 0x022a, "DS", "Reference Air Kerma Rate" },
2383     { 0x300a, 0x022c, "DA", "Air Kerma Rate Reference Date" },
2384     { 0x300a, 0x022e, "TM", "Air Kerma Rate Reference Time" },
2385     { 0x300a, 0x0230, "SQ", "Application Setup Sequence" },
2386     { 0x300a, 0x0232, "CS", "Application Setup Type" },
2387     { 0x300a, 0x0234, "IS", "Application Setup Number" },
2388     { 0x300a, 0x0236, "LO", "Application Setup Name" },
2389     { 0x300a, 0x0238, "LO", "Application Setup Manufacturer" },
2390     { 0x300a, 0x0240, "IS", "Template Number" },
2391     { 0x300a, 0x0242, "SH", "Template Type" },
2392     { 0x300a, 0x0244, "LO", "Template Name" },
2393     { 0x300a, 0x0250, "DS", "Total Reference Air Kerma" },
2394     { 0x300a, 0x0260, "SQ", "Brachy Accessory Device Sequence" },
2395     { 0x300a, 0x0262, "IS", "Brachy Accessory Device Number" },
2396     { 0x300a, 0x0263, "SH", "Brachy Accessory Device ID" },
2397     { 0x300a, 0x0264, "CS", "Brachy Accessory Device Type" },
2398     { 0x300a, 0x0266, "LO", "Brachy Accessory Device Name" },
2399     { 0x300a, 0x026a, "DS", "Brachy Accessory Device Nominal Thickness" },
2400     { 0x300a, 0x026c, "DS", "Brachy Accessory Device Nominal Transmission" },
2401     { 0x300a, 0x0280, "SQ", "Channel Sequence" },
2402     { 0x300a, 0x0282, "IS", "Channel Number" },
2403     { 0x300a, 0x0284, "DS", "Channel Length" },
2404     { 0x300a, 0x0286, "DS", "Channel Total Time" },
2405     { 0x300a, 0x0288, "CS", "Source Movement Type" },
2406     { 0x300a, 0x028a, "IS", "Number of Pulses" },
2407     { 0x300a, 0x028c, "DS", "Pulse Repetition Interval" },
2408     { 0x300a, 0x0290, "IS", "Source Applicator Number" },
2409     { 0x300a, 0x0291, "SH", "Source Applicator ID" },
2410     { 0x300a, 0x0292, "CS", "Source Applicator Type" },
2411     { 0x300a, 0x0294, "LO", "Source Applicator Name" },
2412     { 0x300a, 0x0296, "DS", "Source Applicator Length" },
2413     { 0x300a, 0x0298, "LO", "Source Applicator Manufacturer" },
2414     { 0x300a, 0x029c, "DS", "Source Applicator Wall Nominal Thickness" },
2415     { 0x300a, 0x029e, "DS", "Source Applicator Wall Nominal Transmission" },
2416     { 0x300a, 0x02a0, "DS", "Source Applicator Step Size" },
2417     { 0x300a, 0x02a2, "IS", "Transfer Tube Number" },
2418     { 0x300a, 0x02a4, "DS", "Transfer Tube Length" },
2419     { 0x300a, 0x02b0, "SQ", "Channel Shield Sequence" },
2420     { 0x300a, 0x02b2, "IS", "Channel Shield Number" },
2421     { 0x300a, 0x02b3, "SH", "Channel Shield ID" },
2422     { 0x300a, 0x02b4, "LO", "Channel Shield Name" },
2423     { 0x300a, 0x02b8, "DS", "Channel Shield Nominal Thickness" },
2424     { 0x300a, 0x02ba, "DS", "Channel Shield Nominal Transmission" },
2425     { 0x300a, 0x02c8, "DS", "Final Cumulative Time Weight" },
2426     { 0x300a, 0x02d0, "SQ", "Brachy Control Point Sequence" },
2427     { 0x300a, 0x02d2, "DS", "Control Point Relative Position" },
2428     { 0x300a, 0x02d4, "DS", "Control Point 3D Position" },
2429     { 0x300a, 0x02d6, "DS", "Cumulative Time Weight" },
2430     { 0x300c, 0x0002, "SQ", "Referenced RT Plan Sequence" },
2431     { 0x300c, 0x0004, "SQ", "Referenced Beam Sequence" },
2432     { 0x300c, 0x0006, "IS", "Referenced Beam Number" },
2433     { 0x300c, 0x0007, "IS", "Referenced Reference Image Number" },
2434     { 0x300c, 0x0008, "DS", "Start Cumulative Meterset Weight" },
2435     { 0x300c, 0x0009, "DS", "End Cumulative Meterset Weight" },
2436     { 0x300c, 0x000a, "SQ", "Referenced Brachy Application Setup Sequence" },
2437     { 0x300c, 0x000c, "IS", "Referenced Brachy Application Setup Number" },
2438     { 0x300c, 0x000e, "IS", "Referenced Source Number" },
2439     { 0x300c, 0x0020, "SQ", "Referenced Fraction Group Sequence" },
2440     { 0x300c, 0x0022, "IS", "Referenced Fraction Group Number" },
2441     { 0x300c, 0x0040, "SQ", "Referenced Verification Image Sequence" },
2442     { 0x300c, 0x0042, "SQ", "Referenced Reference Image Sequence" },
2443     { 0x300c, 0x0050, "SQ", "Referenced Dose Reference Sequence" },
2444     { 0x300c, 0x0051, "IS", "Referenced Dose Reference Number" },
2445     { 0x300c, 0x0055, "SQ", "Brachy Referenced Dose Reference Sequence" },
2446     { 0x300c, 0x0060, "SQ", "Referenced Structure Set Sequence" },
2447     { 0x300c, 0x006a, "IS", "Referenced Patient Setup Number" },
2448     { 0x300c, 0x0080, "SQ", "Referenced Dose Sequence" },
2449     { 0x300c, 0x00a0, "IS", "Referenced Tolerance Table Number" },
2450     { 0x300c, 0x00b0, "SQ", "Referenced Bolus Sequence" },
2451     { 0x300c, 0x00c0, "IS", "Referenced Wedge Number" },
2452     { 0x300c, 0x00d0, "IS", "Referenced Compensato rNumber" },
2453     { 0x300c, 0x00e0, "IS", "Referenced Block Number" },
2454     { 0x300c, 0x00f0, "IS", "Referenced Control Point" },
2455     { 0x300e, 0x0002, "CS", "Approval Status" },
2456     { 0x300e, 0x0004, "DA", "Review Date" },
2457     { 0x300e, 0x0005, "TM", "Review Time" },
2458     { 0x300e, 0x0008, "PN", "Reviewer Name" },
2459     { 0x4000, 0x0000, "UL", "Text Group Length" },
2460     { 0x4000, 0x0010, "LT", "Text Arbitrary" },
2461     { 0x4000, 0x4000, "LT", "Text Comments" },
2462     { 0x4008, 0x0000, "UL", "Results Group Length" },
2463     { 0x4008, 0x0040, "SH", "Results ID" },
2464     { 0x4008, 0x0042, "LO", "Results ID Issuer" },
2465     { 0x4008, 0x0050, "SQ", "Referenced Interpretation Sequence" },
2466     { 0x4008, 0x00ff, "CS", "Report Production Status" },
2467     { 0x4008, 0x0100, "DA", "Interpretation Recorded Date" },
2468     { 0x4008, 0x0101, "TM", "Interpretation Recorded Time" },
2469     { 0x4008, 0x0102, "PN", "Interpretation Recorder" },
2470     { 0x4008, 0x0103, "LO", "Reference to Recorded Sound" },
2471     { 0x4008, 0x0108, "DA", "Interpretation Transcription Date" },
2472     { 0x4008, 0x0109, "TM", "Interpretation Transcription Time" },
2473     { 0x4008, 0x010a, "PN", "Interpretation Transcriber" },
2474     { 0x4008, 0x010b, "ST", "Interpretation Text" },
2475     { 0x4008, 0x010c, "PN", "Interpretation Author" },
2476     { 0x4008, 0x0111, "SQ", "Interpretation Approver Sequence" },
2477     { 0x4008, 0x0112, "DA", "Interpretation Approval Date" },
2478     { 0x4008, 0x0113, "TM", "Interpretation Approval Time" },
2479     { 0x4008, 0x0114, "PN", "Physician Approving Interpretation" },
2480     { 0x4008, 0x0115, "LT", "Interpretation Diagnosis Description" },
2481     { 0x4008, 0x0117, "SQ", "InterpretationDiagnosis Code Sequence" },
2482     { 0x4008, 0x0118, "SQ", "Results Distribution List Sequence" },
2483     { 0x4008, 0x0119, "PN", "Distribution Name" },
2484     { 0x4008, 0x011a, "LO", "Distribution Address" },
2485     { 0x4008, 0x0200, "SH", "Interpretation ID" },
2486     { 0x4008, 0x0202, "LO", "Interpretation ID Issuer" },
2487     { 0x4008, 0x0210, "CS", "Interpretation Type ID" },
2488     { 0x4008, 0x0212, "CS", "Interpretation Status ID" },
2489     { 0x4008, 0x0300, "ST", "Impressions" },
2490     { 0x4008, 0x4000, "ST", "Results Comments" },
2491     { 0x4009, 0x0001, "LT", "Report ID" },
2492     { 0x4009, 0x0020, "LT", "Report Status" },
2493     { 0x4009, 0x0030, "DA", "Report Creation Date" },
2494     { 0x4009, 0x0070, "LT", "Report Approving Physician" },
2495     { 0x4009, 0x00e0, "LT", "Report Text" },
2496     { 0x4009, 0x00e1, "LT", "Report Author" },
2497     { 0x4009, 0x00e3, "LT", "Reporting Radiologist" },
2498     { 0x5000, 0x0000, "UL", "Curve Group Length" },
2499     { 0x5000, 0x0005, "US", "Curve Dimensions" },
2500     { 0x5000, 0x0010, "US", "Number of Points" },
2501     { 0x5000, 0x0020, "CS", "Type of Data" },
2502     { 0x5000, 0x0022, "LO", "Curve Description" },
2503     { 0x5000, 0x0030, "SH", "Axis Units" },
2504     { 0x5000, 0x0040, "SH", "Axis Labels" },
2505     { 0x5000, 0x0103, "US", "Data Value Representation" },
2506     { 0x5000, 0x0104, "US", "Minimum Coordinate Value" },
2507     { 0x5000, 0x0105, "US", "Maximum Coordinate Value" },
2508     { 0x5000, 0x0106, "SH", "Curve Range" },
2509     { 0x5000, 0x0110, "US", "Curve Data Descriptor" },
2510     { 0x5000, 0x0112, "US", "Coordinate Start Value" },
2511     { 0x5000, 0x0114, "US", "Coordinate Step Value" },
2512     { 0x5000, 0x1001, "CS", "Curve Activation Layer" },
2513     { 0x5000, 0x2000, "US", "Audio Type" },
2514     { 0x5000, 0x2002, "US", "Audio Sample Format" },
2515     { 0x5000, 0x2004, "US", "Number of Channels" },
2516     { 0x5000, 0x2006, "UL", "Number of Samples" },
2517     { 0x5000, 0x2008, "UL", "Sample Rate" },
2518     { 0x5000, 0x200a, "UL", "Total Time" },
2519     { 0x5000, 0x200c, "xs", "Audio Sample Data" },
2520     { 0x5000, 0x200e, "LT", "Audio Comments" },
2521     { 0x5000, 0x2500, "LO", "Curve Label" },
2522     { 0x5000, 0x2600, "SQ", "CurveReferenced Overlay Sequence" },
2523     { 0x5000, 0x2610, "US", "CurveReferenced Overlay Group" },
2524     { 0x5000, 0x3000, "OW", "Curve Data" },
2525     { 0x6000, 0x0000, "UL", "Overlay Group Length" },
2526     { 0x6000, 0x0001, "US", "Gray Palette Color Lookup Table Descriptor" },
2527     { 0x6000, 0x0002, "US", "Gray Palette Color Lookup Table Data" },
2528     { 0x6000, 0x0010, "US", "Overlay Rows" },
2529     { 0x6000, 0x0011, "US", "Overlay Columns" },
2530     { 0x6000, 0x0012, "US", "Overlay Planes" },
2531     { 0x6000, 0x0015, "IS", "Number of Frames in Overlay" },
2532     { 0x6000, 0x0022, "LO", "Overlay Description" },
2533     { 0x6000, 0x0040, "CS", "Overlay Type" },
2534     { 0x6000, 0x0045, "CS", "Overlay Subtype" },
2535     { 0x6000, 0x0050, "SS", "Overlay Origin" },
2536     { 0x6000, 0x0051, "US", "Image Frame Origin" },
2537     { 0x6000, 0x0052, "US", "Plane Origin" },
2538     { 0x6000, 0x0060, "LO", "Overlay Compression Code" },
2539     { 0x6000, 0x0061, "SH", "Overlay Compression Originator" },
2540     { 0x6000, 0x0062, "SH", "Overlay Compression Label" },
2541     { 0x6000, 0x0063, "SH", "Overlay Compression Description" },
2542     { 0x6000, 0x0066, "AT", "Overlay Compression Step Pointers" },
2543     { 0x6000, 0x0068, "US", "Overlay Repeat Interval" },
2544     { 0x6000, 0x0069, "US", "Overlay Bits Grouped" },
2545     { 0x6000, 0x0100, "US", "Overlay Bits Allocated" },
2546     { 0x6000, 0x0102, "US", "Overlay Bit Position" },
2547     { 0x6000, 0x0110, "LO", "Overlay Format" },
2548     { 0x6000, 0x0200, "xs", "Overlay Location" },
2549     { 0x6000, 0x0800, "LO", "Overlay Code Label" },
2550     { 0x6000, 0x0802, "US", "Overlay Number of Tables" },
2551     { 0x6000, 0x0803, "AT", "Overlay Code Table Location" },
2552     { 0x6000, 0x0804, "US", "Overlay Bits For Code Word" },
2553     { 0x6000, 0x1001, "CS", "Overlay Activation Layer" },
2554     { 0x6000, 0x1100, "US", "Overlay Descriptor - Gray" },
2555     { 0x6000, 0x1101, "US", "Overlay Descriptor - Red" },
2556     { 0x6000, 0x1102, "US", "Overlay Descriptor - Green" },
2557     { 0x6000, 0x1103, "US", "Overlay Descriptor - Blue" },
2558     { 0x6000, 0x1200, "US", "Overlays - Gray" },
2559     { 0x6000, 0x1201, "US", "Overlays - Red" },
2560     { 0x6000, 0x1202, "US", "Overlays - Green" },
2561     { 0x6000, 0x1203, "US", "Overlays - Blue" },
2562     { 0x6000, 0x1301, "IS", "ROI Area" },
2563     { 0x6000, 0x1302, "DS", "ROI Mean" },
2564     { 0x6000, 0x1303, "DS", "ROI Standard Deviation" },
2565     { 0x6000, 0x1500, "LO", "Overlay Label" },
2566     { 0x6000, 0x3000, "OW", "Overlay Data" },
2567     { 0x6000, 0x4000, "LT", "Overlay Comments" },
2568     { 0x6001, 0x0000, "UN", "?" },
2569     { 0x6001, 0x0010, "LO", "?" },
2570     { 0x6001, 0x1010, "xs", "?" },
2571     { 0x6001, 0x1030, "xs", "?" },
2572     { 0x6021, 0x0000, "xs", "?" },
2573     { 0x6021, 0x0010, "xs", "?" },
2574     { 0x7001, 0x0010, "LT", "Dummy" },
2575     { 0x7003, 0x0010, "LT", "Info" },
2576     { 0x7005, 0x0010, "LT", "Dummy" },
2577     { 0x7000, 0x0004, "ST", "TextAnnotation" },
2578     { 0x7000, 0x0005, "IS", "Box" },
2579     { 0x7000, 0x0007, "IS", "ArrowEnd" },
2580     { 0x7fe0, 0x0000, "UL", "Pixel Data Group Length" },
2581     { 0x7fe0, 0x0010, "xs", "Pixel Data" },
2582     { 0x7fe0, 0x0020, "OW", "Coefficients SDVN" },
2583     { 0x7fe0, 0x0030, "OW", "Coefficients SDHN" },
2584     { 0x7fe0, 0x0040, "OW", "Coefficients SDDN" },
2585     { 0x7fe1, 0x0010, "xs", "Pixel Data" },
2586     { 0x7f00, 0x0000, "UL", "Variable Pixel Data Group Length" },
2587     { 0x7f00, 0x0010, "xs", "Variable Pixel Data" },
2588     { 0x7f00, 0x0011, "US", "Variable Next Data Group" },
2589     { 0x7f00, 0x0020, "OW", "Variable Coefficients SDVN" },
2590     { 0x7f00, 0x0030, "OW", "Variable Coefficients SDHN" },
2591     { 0x7f00, 0x0040, "OW", "Variable Coefficients SDDN" },
2592     { 0x7fe1, 0x0000, "OB", "Binary Data" },
2593     { 0x7fe3, 0x0000, "LT", "Image Graphics Format Code" },
2594     { 0x7fe3, 0x0010, "OB", "Image Graphics" },
2595     { 0x7fe3, 0x0020, "OB", "Image Graphics Dummy" },
2596     { 0x7ff1, 0x0001, "US", "?" },
2597     { 0x7ff1, 0x0002, "US", "?" },
2598     { 0x7ff1, 0x0003, "xs", "?" },
2599     { 0x7ff1, 0x0004, "IS", "?" },
2600     { 0x7ff1, 0x0005, "US", "?" },
2601     { 0x7ff1, 0x0007, "US", "?" },
2602     { 0x7ff1, 0x0008, "US", "?" },
2603     { 0x7ff1, 0x0009, "US", "?" },
2604     { 0x7ff1, 0x000a, "LT", "?" },
2605     { 0x7ff1, 0x000b, "US", "?" },
2606     { 0x7ff1, 0x000c, "US", "?" },
2607     { 0x7ff1, 0x000d, "US", "?" },
2608     { 0x7ff1, 0x0010, "US", "?" },
2609     { 0xfffc, 0xfffc, "OB", "Data Set Trailing Padding" },
2610     { 0xfffe, 0xe000, "!!", "Item" },
2611     { 0xfffe, 0xe00d, "!!", "Item Delimitation Item" },
2612     { 0xfffe, 0xe0dd, "!!", "Sequence Delimitation Item" },
2613     { 0xffff, 0xffff, "xs", "" }
2614   };
2615 \f
2616 /*
2617 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2618 %                                                                             %
2619 %                                                                             %
2620 %                                                                             %
2621 %   I s D C M                                                                 %
2622 %                                                                             %
2623 %                                                                             %
2624 %                                                                             %
2625 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2626 %
2627 %  IsDCM() returns MagickTrue if the image format type, identified by the
2628 %  magick string, is DCM.
2629 %
2630 %  The format of the ReadDCMImage method is:
2631 %
2632 %      MagickBooleanType IsDCM(const unsigned char *magick,const size_t length)
2633 %
2634 %  A description of each parameter follows:
2635 %
2636 %    o magick: compare image format pattern against these bytes.
2637 %
2638 %    o length: Specifies the length of the magick string.
2639 %
2640 */
2641 static MagickBooleanType IsDCM(const unsigned char *magick,const size_t length)
2642 {
2643   if (length < 132)
2644     return(MagickFalse);
2645   if (LocaleNCompare((char *) (magick+128),"DICM",4) == 0)
2646     return(MagickTrue);
2647   return(MagickFalse);
2648 }
2649 \f
2650 /*
2651 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2652 %                                                                             %
2653 %                                                                             %
2654 %                                                                             %
2655 %   R e a d D C M I m a g e                                                   %
2656 %                                                                             %
2657 %                                                                             %
2658 %                                                                             %
2659 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2660 %
2661 %  ReadDCMImage() reads a Digital Imaging and Communications in Medicine
2662 %  (DICOM) file and returns it.  It allocates the memory necessary for the
2663 %  new Image structure and returns a pointer to the new image.
2664 %
2665 %  The format of the ReadDCMImage method is:
2666 %
2667 %      Image *ReadDCMImage(const ImageInfo *image_info,ExceptionInfo *exception)
2668 %
2669 %  A description of each parameter follows:
2670 %
2671 %    o image_info: the image info.
2672 %
2673 %    o exception: return any errors or warnings in this structure.
2674 %
2675 */
2676
2677 static inline size_t MagickMax(const size_t x,const size_t y)
2678 {
2679   if (x > y)
2680     return(x);
2681   return(y);
2682 }
2683
2684 static inline size_t MagickMin(const size_t x,const size_t y)
2685 {
2686   if (x < y)
2687     return(x);
2688   return(y);
2689 }
2690
2691 typedef struct _DCMStreamInfo
2692 {
2693   size_t
2694     remaining,
2695     segment_count;
2696
2697   ssize_t
2698     segments[15];
2699
2700   size_t
2701     offset_count;
2702
2703   ssize_t
2704     *offsets;
2705
2706   ssize_t
2707     count;
2708
2709   int
2710     byte;
2711 } DCMStreamInfo;
2712
2713 static int ReadDCMByte(DCMStreamInfo *stream_info,Image *image)
2714 {
2715   if (image->compression != RLECompression)
2716     return(ReadBlobByte(image));
2717   if (stream_info->count == 0)
2718     {
2719       int
2720         byte;
2721
2722       ssize_t
2723         count;
2724
2725       if (stream_info->remaining <= 2)
2726         stream_info->remaining=0;
2727       else
2728         stream_info->remaining-=2;
2729       count=(ssize_t) ReadBlobByte(image);
2730       byte=ReadBlobByte(image);
2731       if (count == 128)
2732         return(0);
2733       else
2734         if (count < 128)
2735           {
2736             /*
2737               Literal bytes.
2738             */
2739             stream_info->count=count;
2740             stream_info->byte=(-1);
2741             return(byte);
2742           }
2743         else
2744           {
2745             /*
2746               Repeated bytes.
2747             */
2748             stream_info->count=256-count;
2749             stream_info->byte=byte;
2750             return(byte);
2751           }
2752     }
2753   stream_info->count--;
2754   if (stream_info->byte >= 0)
2755     return(stream_info->byte);
2756   if (stream_info->remaining > 0)
2757     stream_info->remaining--;
2758   return(ReadBlobByte(image));
2759 }
2760
2761 static unsigned short ReadDCMLSBShort(DCMStreamInfo *stream_info,Image *image)
2762 {
2763   int
2764     shift;
2765
2766   unsigned short
2767     value;
2768
2769   if (image->compression != RLECompression)
2770     return(ReadBlobLSBShort(image));
2771   shift=image->depth < 16 ? 4 : 8;
2772   value=ReadDCMByte(stream_info,image) | (unsigned short)
2773     (ReadDCMByte(stream_info,image) << shift);
2774   return(value);
2775 }
2776
2777 static unsigned short ReadDCMMSBShort(DCMStreamInfo *stream_info,Image *image)
2778 {
2779   int
2780     shift;
2781   unsigned short
2782     value;
2783
2784   if (image->compression != RLECompression)
2785     return(ReadBlobMSBShort(image));
2786   shift=image->depth < 16 ? 4 : 8;
2787   value=(ReadDCMByte(stream_info,image) << shift) | (unsigned short)
2788     ReadDCMByte(stream_info,image);
2789   return(value);
2790 }
2791
2792 static Image *ReadDCMImage(const ImageInfo *image_info,ExceptionInfo *exception)
2793 {
2794   char
2795     explicit_vr[MaxTextExtent],
2796     implicit_vr[MaxTextExtent],
2797     magick[MaxTextExtent],
2798     photometric[MaxTextExtent];
2799
2800   DCMStreamInfo
2801     *stream_info;
2802
2803   Image
2804     *image;
2805
2806   int
2807     *bluemap,
2808     datum,
2809     *greenmap,
2810     *graymap,
2811     index,
2812     *redmap;
2813
2814   MagickBooleanType
2815     explicit_file,
2816     use_explicit,
2817     explicit_retry,
2818     polarity;
2819
2820   MagickOffsetType
2821     offset;
2822
2823   Quantum
2824     *scale;
2825
2826   register ssize_t
2827     i,
2828     x;
2829
2830   register Quantum
2831     *q;
2832
2833   register unsigned char
2834     *p;
2835
2836   size_t
2837     bits_allocated,
2838     bytes_per_pixel,
2839     colors,
2840     depth,
2841     height,
2842     length,
2843     mask,
2844     max_value,
2845     number_scenes,
2846     quantum,
2847     samples_per_pixel,
2848     signed_data,
2849     significant_bits,
2850     status,
2851     width,
2852     window_width;
2853
2854   ssize_t
2855     count,
2856     element,
2857     group,
2858     scene,
2859     window_center,
2860     y;
2861
2862
2863   unsigned char
2864     *data;
2865
2866   /*
2867     Open image file.
2868   */
2869   assert(image_info != (const ImageInfo *) NULL);
2870   assert(image_info->signature == MagickSignature);
2871   if (image_info->debug != MagickFalse)
2872     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
2873       image_info->filename);
2874   assert(exception != (ExceptionInfo *) NULL);
2875   assert(exception->signature == MagickSignature);
2876   image=AcquireImage(image_info,exception);
2877   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
2878   if (status == MagickFalse)
2879     {
2880       image=DestroyImageList(image);
2881       return((Image *) NULL);
2882     }
2883   image->depth=8UL;
2884   /*
2885     Read DCM preamble.
2886   */
2887   stream_info=(DCMStreamInfo *) AcquireMagickMemory(sizeof(*stream_info));
2888   if (stream_info == (DCMStreamInfo *) NULL)
2889     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
2890   (void) ResetMagickMemory(stream_info,0,sizeof(*stream_info));
2891   count=ReadBlob(image,128,(unsigned char *) magick);
2892   if (count != 128)
2893     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
2894   count=ReadBlob(image,4,(unsigned char *) magick);
2895   if ((count != 4) || (LocaleNCompare(magick,"DICM",4) != 0))
2896     {
2897       offset=SeekBlob(image,0L,SEEK_SET);
2898       if (offset < 0)
2899         ThrowReaderException(CorruptImageError,"ImproperImageHeader");
2900     }
2901   /*
2902     Read DCM Medical image.
2903   */
2904   (void) CopyMagickString(photometric,"MONOCHROME1 ",MaxTextExtent);
2905   bits_allocated=8;
2906   bytes_per_pixel=1;
2907   polarity=MagickFalse;
2908   data=(unsigned char *) NULL;
2909   depth=8;
2910   element=0;
2911   explicit_vr[2]='\0';
2912   explicit_file=MagickFalse;
2913   colors=0;
2914   redmap=(int *) NULL;
2915   greenmap=(int *) NULL;
2916   bluemap=(int *) NULL;
2917   graymap=(int *) NULL;
2918   height=0;
2919   max_value=255UL;
2920   mask=0xffff;
2921   number_scenes=1;
2922   samples_per_pixel=1;
2923   scale=(Quantum *) NULL;
2924   signed_data=(~0UL);
2925   significant_bits=0;
2926   use_explicit=MagickFalse;
2927   explicit_retry = MagickFalse;
2928   width=0;
2929   window_center=0;
2930   window_width=0;
2931   for (group=0; (group != 0x7FE0) || (element != 0x0010); )
2932   {
2933     /*
2934       Read a group.
2935     */
2936     image->offset=(ssize_t) TellBlob(image);
2937     group=(ssize_t) ReadBlobLSBShort(image);
2938     element=(ssize_t) ReadBlobLSBShort(image);
2939     quantum=0;
2940     /*
2941       Find corresponding VR for this group and element.
2942     */
2943     for (i=0; dicom_info[i].group < 0xffff; i++)
2944       if ((group == (ssize_t) dicom_info[i].group) &&
2945           (element == (ssize_t) dicom_info[i].element))
2946         break;
2947     (void) CopyMagickString(implicit_vr,dicom_info[i].vr,MaxTextExtent);
2948     count=ReadBlob(image,2,(unsigned char *) explicit_vr);
2949     /*
2950       Check for "explicitness", but meta-file headers always explicit.
2951     */
2952     if ((explicit_file == MagickFalse) && (group != 0x0002))
2953       explicit_file=(isupper((int) *explicit_vr) != MagickFalse) &&
2954         (isupper((int) *(explicit_vr+1)) != MagickFalse) ? MagickTrue :
2955         MagickFalse;
2956     use_explicit=((group == 0x0002) && (explicit_retry == MagickFalse)) ||
2957       (explicit_file != MagickFalse) ? MagickTrue : MagickFalse;
2958     if ((use_explicit != MagickFalse) && (strcmp(implicit_vr,"xs") == 0))
2959       (void) CopyMagickString(implicit_vr,explicit_vr,MaxTextExtent);
2960     if ((use_explicit == MagickFalse) || (strcmp(implicit_vr,"!!") == 0))
2961       {
2962         offset=SeekBlob(image,(MagickOffsetType) -2,SEEK_CUR);
2963         if (offset < 0)
2964           ThrowReaderException(CorruptImageError,"ImproperImageHeader");
2965         quantum=4;
2966       }
2967     else
2968       {
2969         /*
2970           Assume explicit type.
2971         */
2972         quantum=2;
2973         if ((strcmp(explicit_vr,"OB") == 0) ||
2974             (strcmp(explicit_vr,"UN") == 0) ||
2975             (strcmp(explicit_vr,"OW") == 0) || (strcmp(explicit_vr,"SQ") == 0))
2976           {
2977             (void) ReadBlobLSBShort(image);
2978             quantum=4;
2979           }
2980       }
2981     datum=0;
2982     if (quantum == 4)
2983       datum=(int) ReadBlobLSBLong(image);
2984     else
2985       if (quantum == 2)
2986         datum=(int) ReadBlobLSBShort(image);
2987     quantum=0;
2988     length=1;
2989     if (datum != 0)
2990       {
2991         if ((strcmp(implicit_vr,"SS") == 0) ||
2992             (strcmp(implicit_vr,"US") == 0))
2993           quantum=2;
2994         else
2995           if ((strcmp(implicit_vr,"UL") == 0) ||
2996               (strcmp(implicit_vr,"SL") == 0) ||
2997               (strcmp(implicit_vr,"FL") == 0))
2998             quantum=4;
2999           else
3000             if (strcmp(implicit_vr,"FD") != 0)
3001               quantum=1;
3002             else
3003               quantum=8;
3004         if (datum != ~0)
3005           length=(size_t) datum/quantum;
3006         else
3007           {
3008             /*
3009               Sequence and item of undefined length.
3010             */
3011             quantum=0;
3012             length=0;
3013           }
3014       }
3015     if (image_info->verbose != MagickFalse)
3016       {
3017         /*
3018           Display Dicom info.
3019         */
3020         if (use_explicit == MagickFalse)
3021           explicit_vr[0]='\0';
3022         for (i=0; dicom_info[i].description != (char *) NULL; i++)
3023           if ((group == (ssize_t) dicom_info[i].group) &&
3024               (element == (ssize_t) dicom_info[i].element))
3025             break;
3026         (void) FormatLocaleFile(stdout,"0x%04lX %4ld %s-%s (0x%04lx,0x%04lx)",
3027           (unsigned long) image->offset,(long) length,implicit_vr,
3028           explicit_vr,(unsigned long) group,(unsigned long) element);
3029         if (dicom_info[i].description != (char *) NULL)
3030           (void) FormatLocaleFile(stdout," %s",dicom_info[i].description);
3031         (void) FormatLocaleFile(stdout,": ");
3032       }
3033     if ((group == 0x7FE0) && (element == 0x0010))
3034       {
3035         if (image_info->verbose != MagickFalse)
3036           (void) FormatLocaleFile(stdout,"\n");
3037         break;
3038       }
3039     /*
3040       Allocate space and read an array.
3041     */
3042     data=(unsigned char *) NULL;
3043     if ((length == 1) && (quantum == 1))
3044       datum=(int) ReadBlobByte(image);
3045     else
3046       if ((length == 1) && (quantum == 2))
3047         datum=(int) ReadBlobLSBShort(image);
3048       else
3049         if ((length == 1) && (quantum == 4))
3050           datum=(int) ReadBlobLSBLong(image);
3051         else
3052           if ((quantum != 0) && (length != 0))
3053             {
3054               data=(unsigned char *) NULL;
3055               if (~length >= 1)
3056                 data=(unsigned char *) AcquireQuantumMemory(length+1,quantum*
3057                   sizeof(*data));
3058               if (data == (unsigned char *) NULL)
3059                 ThrowReaderException(ResourceLimitError,
3060                   "MemoryAllocationFailed");
3061               count=ReadBlob(image,(size_t) quantum*length,data);
3062               if (count != (ssize_t) (quantum*length))
3063                 {
3064                   (void) FormatLocaleFile(stdout,"count=%d quantum=%d "
3065                     "length=%d group=%d\n",(int) count,(int) quantum,(int)
3066                     length,(int) group);
3067                    ThrowReaderException(CorruptImageError,
3068                      "InsufficientImageDataInFile");
3069                 }
3070               data[length*quantum]='\0';
3071             }
3072     switch (group)
3073     {
3074       case 0x0002:
3075       {
3076         switch (element)
3077         {
3078           case 0x0010:
3079           {
3080             char
3081               transfer_syntax[MaxTextExtent];
3082
3083             /*
3084               Transfer Syntax.
3085             */
3086             if ((datum == 0) && (explicit_retry == MagickFalse))
3087               {
3088                 explicit_retry=MagickTrue;
3089                 (void) SeekBlob(image,(MagickOffsetType) 0,SEEK_SET);
3090                 group=0;
3091                 element=0;
3092                 if (image_info->verbose != MagickFalse)
3093                   (void) FormatLocaleFile(stdout,
3094                     "Corrupted image - trying explicit format\n");
3095                 break;
3096               }
3097             *transfer_syntax='\0';
3098             if (data != (unsigned char *) NULL)
3099               (void) CopyMagickString(transfer_syntax,(char *) data,
3100                 MaxTextExtent);
3101             if (image_info->verbose != MagickFalse)
3102               (void) FormatLocaleFile(stdout,"transfer_syntax=%s\n",
3103                 (const char*) transfer_syntax);
3104             if (strncmp(transfer_syntax,"1.2.840.10008.1.2",17) == 0)
3105               {
3106                 int
3107                   subtype,
3108                   type;
3109
3110                 type=0;
3111                 subtype=0;
3112                 (void) sscanf(transfer_syntax+17,".%d.%d",&type,&subtype);
3113                 switch (type)
3114                 {
3115                   case 1:
3116                   {
3117                     image->endian=LSBEndian;
3118                     break;
3119                   }
3120                   case 2:
3121                   {
3122                     image->endian=MSBEndian;
3123                     break;
3124                   }
3125                   case 4:
3126                   {
3127                     if ((subtype >= 80) && (subtype <= 81))
3128                       image->compression=JPEGCompression;
3129                     else
3130                       if ((subtype >= 90) && (subtype <= 93))
3131                         image->compression=JPEG2000Compression;
3132                       else
3133                         image->compression=JPEGCompression;
3134                     break;
3135                   }
3136                   case 5:
3137                   {
3138                     image->compression=RLECompression;
3139                     break;
3140                   }
3141                 }
3142               }
3143             break;
3144           }
3145           default:
3146             break;
3147         }
3148         break;
3149       }
3150       case 0x0028:
3151       {
3152         switch (element)
3153         {
3154           case 0x0002:
3155           {
3156             /*
3157               Samples per pixel.
3158             */
3159             samples_per_pixel=datum;
3160             break;
3161           }
3162           case 0x0004:
3163           {
3164             /*
3165               Photometric interpretation.
3166             */
3167             for (i=0; i < (ssize_t) MagickMin(length,MaxTextExtent-1); i++)
3168               photometric[i]=(char) data[i];
3169             photometric[i]='\0';
3170             polarity=LocaleCompare(photometric,"MONOCHROME1 ") == 0 ?
3171               MagickTrue : MagickFalse;
3172             break;
3173           }
3174           case 0x0006:
3175           {
3176             /*
3177               Planar configuration.
3178             */
3179             if (datum == 1)
3180               image->interlace=PlaneInterlace;
3181             break;
3182           }
3183           case 0x0008:
3184           {
3185             /*
3186               Number of frames.
3187             */
3188             number_scenes=StringToUnsignedLong((char *) data);
3189             break;
3190           }
3191           case 0x0010:
3192           {
3193             /*
3194               Image rows.
3195             */
3196             height=datum;
3197             break;
3198           }
3199           case 0x0011:
3200           {
3201             /*
3202               Image columns.
3203             */
3204             width=datum;
3205             break;
3206           }
3207           case 0x0100:
3208           {
3209             /*
3210               Bits allocated.
3211             */
3212             bits_allocated=datum;
3213             bytes_per_pixel=1;
3214             if (datum > 8)
3215               bytes_per_pixel=2;
3216             depth=bits_allocated;
3217             if (depth > 32)
3218               ThrowReaderException(CorruptImageError,"ImproperImageHeader");
3219             max_value=(1UL << bits_allocated)-1;
3220             break;
3221           }
3222           case 0x0101:
3223           {
3224             /*
3225               Bits stored.
3226             */
3227             significant_bits=datum;
3228             bytes_per_pixel=1;
3229             if (significant_bits > 8)
3230               bytes_per_pixel=2;
3231             depth=significant_bits;
3232             if (depth > 32)
3233               ThrowReaderException(CorruptImageError,"ImproperImageHeader");
3234             max_value=(1UL << significant_bits)-1;
3235             mask=(size_t) GetQuantumRange(significant_bits);
3236             break;
3237           }
3238           case 0x0102:
3239           {
3240             /*
3241               High bit.
3242             */
3243             break;
3244           }
3245           case 0x0103:
3246           {
3247             /*
3248               Pixel representation.
3249             */
3250             signed_data=datum;
3251             break;
3252           }
3253           case 0x1050:
3254           {
3255             /*
3256               Visible pixel range: center.
3257             */
3258             if (data != (unsigned char *) NULL)
3259               window_center=StringToLong((char *) data);
3260             break;
3261           }
3262           case 0x1051:
3263           {
3264             /*
3265               Visible pixel range: width.
3266             */
3267             if (data != (unsigned char *) NULL)
3268               window_width=StringToUnsignedLong((char *) data);
3269             break;
3270           }
3271           case 0x1200:
3272           case 0x3006:
3273           {
3274             /*
3275               Populate graymap.
3276             */
3277             if (data == (unsigned char *) NULL)
3278               break;
3279             colors=(size_t) (length/bytes_per_pixel);
3280             datum=(int) colors;
3281             graymap=(int *) AcquireQuantumMemory((size_t) colors,
3282               sizeof(*graymap));
3283             if (graymap == (int *) NULL)
3284               ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
3285             for (i=0; i < (ssize_t) colors; i++)
3286               if (bytes_per_pixel == 1)
3287                 graymap[i]=(int) data[i];
3288               else
3289                 graymap[i]=(int) ((short *) data)[i];
3290             break;
3291           }
3292           case 0x1201:
3293           {
3294             unsigned short
3295               index;
3296
3297             /*
3298               Populate redmap.
3299             */
3300             if (data == (unsigned char *) NULL)
3301               break;
3302             colors=(size_t) (length/2);
3303             datum=(int) colors;
3304             redmap=(int *) AcquireQuantumMemory((size_t) colors,
3305               sizeof(*redmap));
3306             if (redmap == (int *) NULL)
3307               ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
3308             p=data;
3309             for (i=0; i < (ssize_t) colors; i++)
3310             {
3311               if (image->endian != LSBEndian)
3312                 index=(unsigned short) ((*p << 8) | *(p+1));
3313               else
3314                 index=(unsigned short) (*p | (*(p+1) << 8));
3315               redmap[i]=(int) index;
3316               p+=2;
3317             }
3318             break;
3319           }
3320           case 0x1202:
3321           {
3322             unsigned short
3323               index;
3324
3325             /*
3326               Populate greenmap.
3327             */
3328             if (data == (unsigned char *) NULL)
3329               break;
3330             colors=(size_t) (length/2);
3331             datum=(int) colors;
3332             greenmap=(int *) AcquireQuantumMemory((size_t) colors,
3333               sizeof(*greenmap));
3334             if (greenmap == (int *) NULL)
3335               ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
3336             p=data;
3337             for (i=0; i < (ssize_t) colors; i++)
3338             {
3339               if (image->endian != LSBEndian)
3340                 index=(unsigned short) ((*p << 8) | *(p+1));
3341               else
3342                 index=(unsigned short) (*p | (*(p+1) << 8));
3343               greenmap[i]=(int) index;
3344               p+=2;
3345             }
3346             break;
3347           }
3348           case 0x1203:
3349           {
3350             unsigned short
3351               index;
3352
3353             /*
3354               Populate bluemap.
3355             */
3356             if (data == (unsigned char *) NULL)
3357               break;
3358             colors=(size_t) (length/2);
3359             datum=(int) colors;
3360             bluemap=(int *) AcquireQuantumMemory((size_t) colors,
3361               sizeof(*bluemap));
3362             if (bluemap == (int *) NULL)
3363               ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
3364             p=data;
3365             for (i=0; i < (ssize_t) colors; i++)
3366             {
3367               if (image->endian != LSBEndian)
3368                 index=(unsigned short) ((*p << 8) | *(p+1));
3369               else
3370                 index=(unsigned short) (*p | (*(p+1) << 8));
3371               bluemap[i]=(int) index;
3372               p+=2;
3373             }
3374             break;
3375           }
3376         }
3377         break;
3378       }
3379       case 0x2050:
3380       {
3381         switch (element)
3382         {
3383           case 0x0020:
3384           {
3385             if ((data != (unsigned char *) NULL) &&
3386                 (strncmp((char*) data,"INVERSE", 7) == 0))
3387               polarity=MagickTrue;
3388             break;
3389           }
3390           default:
3391             break;
3392         }
3393         break;
3394       }
3395       default:
3396         break;
3397     }
3398     if (data != (unsigned char *) NULL)
3399       {
3400         char
3401           *attribute;
3402
3403         for (i=0; dicom_info[i].description != (char *) NULL; i++)
3404           if ((group == (ssize_t) dicom_info[i].group) &&
3405               (element == (ssize_t) dicom_info[i].element))
3406             break;
3407         attribute=AcquireString("dcm:");
3408         (void) ConcatenateString(&attribute,dicom_info[i].description);
3409         for (i=0; i < (ssize_t) MagickMax(length,4); i++)
3410           if (isprint((int) data[i]) == MagickFalse)
3411             break;
3412         if ((i == (ssize_t) length) || (length > 4))
3413           {
3414             (void) SubstituteString(&attribute," ","");
3415             (void) SetImageProperty(image,attribute,(char *) data,exception);
3416           }
3417         attribute=DestroyString(attribute);
3418       }
3419     if (image_info->verbose != MagickFalse)
3420       {
3421         if (data == (unsigned char *) NULL)
3422           (void) FormatLocaleFile(stdout,"%d\n",datum);
3423         else
3424           {
3425             /*
3426               Display group data.
3427             */
3428             for (i=0; i < (ssize_t) MagickMax(length,4); i++)
3429               if (isprint((int) data[i]) == MagickFalse)
3430                 break;
3431             if ((i != (ssize_t) length) && (length <= 4))
3432               {
3433                 ssize_t
3434                   j;
3435
3436                 datum=0;
3437                 for (j=(ssize_t) length-1; j >= 0; j--)
3438                   datum=(256*datum+data[j]);
3439                 (void) FormatLocaleFile(stdout,"%d",datum);
3440               }
3441             else
3442               for (i=0; i < (ssize_t) length; i++)
3443                 if (isprint((int) data[i]) != MagickFalse)
3444                   (void) FormatLocaleFile(stdout,"%c",data[i]);
3445                 else
3446                   (void) FormatLocaleFile(stdout,"%c",'.');
3447             (void) FormatLocaleFile(stdout,"\n");
3448           }
3449       }
3450     if (data != (unsigned char *) NULL)
3451       data=(unsigned char *) RelinquishMagickMemory(data);
3452     if (EOFBlob(image) != MagickFalse)
3453       {
3454         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
3455           image->filename);
3456         break;
3457       }
3458   }
3459   if ((width == 0) || (height == 0))
3460     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
3461   image->columns=(size_t) width;
3462   image->rows=(size_t) height;
3463   if (signed_data == 0xffff)
3464     signed_data=(size_t) (significant_bits == 16 ? 1 : 0);
3465   if ((image->compression == JPEGCompression) ||
3466       (image->compression == JPEG2000Compression))
3467     {
3468       Image
3469         *images;
3470
3471       ImageInfo
3472         *read_info;
3473
3474       int
3475         c;
3476
3477       size_t
3478         length;
3479
3480       unsigned int
3481         tag;
3482
3483       /*
3484         Read offset table.
3485       */
3486       for (i=0; i < (ssize_t) stream_info->remaining; i++)
3487         (void) ReadBlobByte(image);
3488       tag=(ReadBlobLSBShort(image) << 16) | ReadBlobLSBShort(image);
3489       (void) tag;
3490       length=(size_t) ReadBlobLSBLong(image);
3491       stream_info->offset_count=length >> 2;
3492       if (stream_info->offset_count != 0)
3493         {
3494           MagickOffsetType
3495             offset;
3496
3497           stream_info->offsets=(ssize_t *) AcquireQuantumMemory(
3498             stream_info->offset_count,sizeof(*stream_info->offsets));
3499           if (stream_info->offsets == (ssize_t *) NULL)
3500             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
3501           for (i=0; i < (ssize_t) stream_info->offset_count; i++)
3502             stream_info->offsets[i]=(int) ReadBlobLSBLong(image);
3503           offset=TellBlob(image);
3504           for (i=0; i < (ssize_t) stream_info->offset_count; i++)
3505             stream_info->offsets[i]+=offset;
3506         }
3507       /*
3508         Handle non-native image formats.
3509       */
3510       read_info=CloneImageInfo(image_info);
3511       SetImageInfoBlob(read_info,(void *) NULL,0);
3512       images=NewImageList();
3513       for (scene=0; scene < (ssize_t) number_scenes; scene++)
3514       {
3515         char
3516           filename[MaxTextExtent];
3517
3518         const char
3519           *property;
3520
3521         FILE
3522           *file;
3523
3524         Image
3525           *jpeg_image;
3526
3527         int
3528           unique_file;
3529
3530         unsigned int
3531           tag;
3532
3533         file=(FILE *) NULL;
3534         unique_file=AcquireUniqueFileResource(filename);
3535         if (unique_file != -1)
3536           file=fdopen(unique_file,"wb");
3537         if ((unique_file == -1) || (file == (FILE *) NULL))
3538           {
3539             ThrowFileException(exception,FileOpenError,
3540               "UnableToCreateTemporaryFile",filename);
3541             break;
3542           }
3543         tag=(ReadBlobLSBShort(image) << 16) | ReadBlobLSBShort(image);
3544         length=(size_t) ReadBlobLSBLong(image);
3545         if (tag == 0xFFFEE0DD)
3546           break; /* sequence delimiter tag */
3547         if (tag != 0xFFFEE000)
3548           ThrowReaderException(CorruptImageError,"ImproperImageHeader");
3549         for ( ; length != 0; length--)
3550         {
3551           c=ReadBlobByte(image);
3552           if (c == EOF)
3553             ThrowFileException(exception,CorruptImageError,
3554               "UnexpectedEndOfFile",image->filename);
3555           (void) fputc(c,file);
3556         }
3557         (void) fclose(file);
3558         (void) FormatLocaleString(read_info->filename,MaxTextExtent,
3559           "jpeg:%s",filename);
3560         if (image->compression == JPEG2000Compression)
3561           (void) FormatLocaleString(read_info->filename,MaxTextExtent,
3562             "jp2:%s",filename);
3563         jpeg_image=ReadImage(read_info,exception);
3564         if (jpeg_image != (Image *) NULL)
3565           {
3566             ResetImagePropertyIterator(image);
3567             property=GetNextImageProperty(image);
3568             while (property != (const char *) NULL)
3569             {
3570               (void) SetImageProperty(jpeg_image,property,
3571                 GetImageProperty(image,property,exception),exception);
3572               property=GetNextImageProperty(image);
3573             }
3574             AppendImageToList(&images,jpeg_image);
3575           }
3576         (void) RelinquishUniqueFileResource(filename);
3577       }
3578       read_info=DestroyImageInfo(read_info);
3579       image=DestroyImage(image);
3580       return(GetFirstImageInList(images));
3581     }
3582   if (depth != (1UL*MAGICKCORE_QUANTUM_DEPTH))
3583     {
3584       QuantumAny
3585         range;
3586
3587       size_t
3588         length;
3589
3590       /*
3591         Compute pixel scaling table.
3592       */
3593       length=(size_t) (GetQuantumRange(depth)+1);
3594       scale=(Quantum *) AcquireQuantumMemory(length,sizeof(*scale));
3595       if (scale == (Quantum *) NULL)
3596         ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
3597       range=GetQuantumRange(depth);
3598       for (i=0; i < (ssize_t) (GetQuantumRange(depth)+1); i++)
3599         scale[i]=ScaleAnyToQuantum((size_t) i,range);
3600     }
3601   if (image->compression == RLECompression)
3602     {
3603       size_t
3604         length;
3605
3606       unsigned int
3607         tag;
3608
3609       /*
3610         Read RLE offset table.
3611       */
3612       for (i=0; i < (ssize_t) stream_info->remaining; i++)
3613         (void) ReadBlobByte(image);
3614       tag=(ReadBlobLSBShort(image) << 16) | ReadBlobLSBShort(image);
3615       (void) tag;
3616       length=(size_t) ReadBlobLSBLong(image);
3617       stream_info->offset_count=length >> 2;
3618       if (stream_info->offset_count != 0)
3619         {
3620           MagickOffsetType
3621             offset;
3622
3623           stream_info->offsets=(ssize_t *) AcquireQuantumMemory(
3624             stream_info->offset_count,sizeof(*stream_info->offsets));
3625           if (stream_info->offsets == (ssize_t *) NULL)
3626             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
3627           for (i=0; i < (ssize_t) stream_info->offset_count; i++)
3628             stream_info->offsets[i]=(int) ReadBlobLSBLong(image);
3629           offset=TellBlob(image);
3630           for (i=0; i < (ssize_t) stream_info->offset_count; i++)
3631             stream_info->offsets[i]+=offset;
3632         }
3633     }
3634   for (scene=0; scene < (ssize_t) number_scenes; scene++)
3635   {
3636     if (image_info->ping != MagickFalse)
3637       break;
3638     image->columns=(size_t) width;
3639     image->rows=(size_t) height;
3640     image->depth=depth;
3641     if ((image->colormap == (PixelInfo *) NULL) && (samples_per_pixel == 1))
3642       {
3643         size_t
3644           one;
3645
3646         one=1;
3647         if (colors == 0)
3648           colors=one << depth;
3649         if (AcquireImageColormap(image,one << depth,exception) == MagickFalse)
3650           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
3651         if (redmap != (int *) NULL)
3652           for (i=0; i < (ssize_t) colors; i++)
3653           {
3654             index=redmap[i];
3655             if ((scale != (Quantum *) NULL) && (index <= (int) max_value))
3656               index=(int) scale[index];
3657             image->colormap[i].red=index;
3658           }
3659         if (greenmap != (int *) NULL)
3660           for (i=0; i < (ssize_t) colors; i++)
3661           {
3662             index=greenmap[i];
3663             if ((scale != (Quantum *) NULL) && (index <= (int) max_value))
3664               index=(int) scale[index];
3665             image->colormap[i].green=index;
3666           }
3667         if (bluemap != (int *) NULL)
3668           for (i=0; i < (ssize_t) colors; i++)
3669           {
3670             index=bluemap[i];
3671             if ((scale != (Quantum *) NULL) && (index <= (int) max_value))
3672               index=(int) scale[index];
3673             image->colormap[i].blue=index;
3674           }
3675         if (graymap != (int *) NULL)
3676           for (i=0; i < (ssize_t) colors; i++)
3677           {
3678             index=graymap[i];
3679             if ((scale != (Quantum *) NULL) && (index <= (int) max_value))
3680               index=(int) scale[index];
3681             image->colormap[i].red=index;
3682             image->colormap[i].green=index;
3683             image->colormap[i].blue=index;
3684           }
3685       }
3686     if (image->compression == RLECompression)
3687       {
3688         unsigned int
3689           tag;
3690
3691         /*
3692           Read RLE segment table.
3693         */
3694         for (i=0; i < (ssize_t) stream_info->remaining; i++)
3695           (void) ReadBlobByte(image);
3696         tag=(ReadBlobLSBShort(image) << 16) | ReadBlobLSBShort(image);
3697         stream_info->remaining=(size_t) ReadBlobLSBLong(image);
3698         if ((tag != 0xFFFEE000) || (stream_info->remaining <= 64) ||
3699             (EOFBlob(image) == MagickTrue))
3700           ThrowReaderException(CorruptImageError,"ImproperImageHeader");
3701         stream_info->count=0;
3702         stream_info->segment_count=ReadBlobLSBLong(image);
3703         if (stream_info->segment_count > 1)
3704           {
3705             bytes_per_pixel=1;
3706             depth=8;
3707           }
3708         for (i=0; i < 15; i++)
3709           stream_info->segments[i]=(int) ReadBlobLSBLong(image);
3710         stream_info->remaining-=64;
3711       }
3712     if ((samples_per_pixel > 1) && (image->interlace == PlaneInterlace))
3713       {
3714         /*
3715           Convert Planar RGB DCM Medical image to pixel packets.
3716         */
3717         for (i=0; i < (ssize_t) samples_per_pixel; i++)
3718         {
3719           for (y=0; y < (ssize_t) image->rows; y++)
3720           {
3721             q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
3722             if (q == (Quantum *) NULL)
3723               break;
3724             for (x=0; x < (ssize_t) image->columns; x++)
3725             {
3726               switch ((int) i)
3727               {
3728                 case 0:
3729                 {
3730                   SetPixelRed(image,ScaleCharToQuantum((unsigned char)
3731                     ReadDCMByte(stream_info,image)),q);
3732                   break;
3733                 }
3734                 case 1:
3735                 {
3736                   SetPixelGreen(image,ScaleCharToQuantum((unsigned char)
3737                     ReadDCMByte(stream_info,image)),q);
3738                   break;
3739                 }
3740                 case 2:
3741                 {
3742                   SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
3743                     ReadDCMByte(stream_info,image)),q);
3744                   break;
3745                 }
3746                 case 3:
3747                 {
3748                   SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
3749                     ReadDCMByte(stream_info,image)),q);
3750                   break;
3751                 }
3752                 default:
3753                   break;
3754               }
3755               q+=GetPixelChannels(image);
3756             }
3757             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3758               break;
3759             if (image->previous == (Image *) NULL)
3760               {
3761                 status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
3762                   image->rows);
3763                 if (status == MagickFalse)
3764                   break;
3765               }
3766           }
3767         }
3768       }
3769     else
3770       {
3771         const char
3772           *option;
3773
3774         int
3775           byte;
3776
3777         PixelPacket
3778           pixel;
3779
3780         /*
3781           Convert DCM Medical image to pixel packets.
3782         */
3783         byte=0;
3784         i=0;
3785         if ((window_center != 0) && (window_width == 0))
3786           window_width=(size_t) window_center;
3787         option=GetImageOption(image_info,"dcm:display-range");
3788         if (option != (const char *) NULL)
3789           {
3790             if (LocaleCompare(option,"reset") == 0)
3791               window_width=0;
3792           }
3793         (void) ResetMagickMemory(&pixel,0,sizeof(pixel));
3794         for (y=0; y < (ssize_t) image->rows; y++)
3795         {
3796           q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
3797           if (q == (Quantum *) NULL)
3798             break;
3799           for (x=0; x < (ssize_t) image->columns; x++)
3800           {
3801             if (samples_per_pixel == 1)
3802               {
3803                 int
3804                   pixel_value;
3805
3806                 if (bytes_per_pixel == 1)
3807                   pixel_value=polarity != MagickFalse ?
3808                     ((int) max_value-ReadDCMByte(stream_info,image)) :
3809                     ReadDCMByte(stream_info,image);
3810                 else
3811                   if ((bits_allocated != 12) || (significant_bits != 12))
3812                     {
3813                       if (image->endian == MSBEndian)
3814                         pixel_value=(int) (polarity != MagickFalse ? (max_value-
3815                           ReadDCMMSBShort(stream_info,image)) :
3816                           ReadDCMMSBShort(stream_info,image));
3817                       else
3818                         pixel_value=(int) (polarity != MagickFalse ? (max_value-
3819                           ReadDCMLSBShort(stream_info,image)) :
3820                           ReadDCMLSBShort(stream_info,image));
3821                     }
3822                   else
3823                     {
3824                       if ((i & 0x01) != 0)
3825                         pixel_value=(ReadDCMByte(stream_info,image) << 8) |
3826                           byte;
3827                       else
3828                         {
3829                           if (image->endian == MSBEndian)
3830                             pixel_value=(int) ReadDCMMSBShort(stream_info,
3831                               image);
3832                           else
3833                             pixel_value=(int) ReadDCMLSBShort(stream_info,
3834                               image);
3835                           byte=(int) (pixel_value & 0x0f);
3836                           pixel_value>>=4;
3837                         }
3838                       i++;
3839                     }
3840                 index=pixel_value;
3841                 if (window_width == 0)
3842                   {
3843                     if (signed_data == 1)
3844                       index=pixel_value-32767;
3845                   }
3846                 else
3847                   {
3848                     ssize_t
3849                       window_max,
3850                       window_min;
3851
3852                     window_min=(ssize_t) ceil(window_center-(window_width-1)/
3853                       2.0-0.5);
3854                     window_max=(ssize_t) floor(window_center+(window_width-1)/
3855                       2.0+0.5);
3856                     if ((ssize_t) pixel_value <= window_min)
3857                       index=0;
3858                     else
3859                       if ((ssize_t) pixel_value > window_max)
3860                         index=(int) max_value;
3861                       else
3862                         index=(int) (max_value*(((pixel_value-window_center-
3863                           0.5)/(window_width-1))+0.5));
3864                   }
3865                 index&=mask;
3866                 index=(int) ConstrainColormapIndex(image,(size_t) index,
3867                   exception);
3868                 SetPixelIndex(image,index,q);
3869                 pixel.red=1UL*image->colormap[index].red;
3870                 pixel.green=1UL*image->colormap[index].green;
3871                 pixel.blue=1UL*image->colormap[index].blue;
3872               }
3873             else
3874               {
3875                 if (bytes_per_pixel == 1)
3876                   {
3877                     pixel.red=(size_t) ReadDCMByte(stream_info,image);
3878                     pixel.green=(size_t) ReadDCMByte(stream_info,image);
3879                     pixel.blue=(size_t) ReadDCMByte(stream_info,image);
3880                   }
3881                 else
3882                   {
3883                     if (image->endian == MSBEndian)
3884                       {
3885                         pixel.red=ReadDCMMSBShort(stream_info,image);
3886                         pixel.green=ReadDCMMSBShort(stream_info,image);
3887                         pixel.blue=ReadDCMMSBShort(stream_info,image);
3888                       }
3889                     else
3890                       {
3891                         pixel.red=ReadDCMLSBShort(stream_info,image);
3892                         pixel.green=ReadDCMLSBShort(stream_info,image);
3893                         pixel.blue=ReadDCMLSBShort(stream_info,image);
3894                       }
3895                   }
3896                 pixel.red&=mask;
3897                 pixel.green&=mask;
3898                 pixel.blue&=mask;
3899                 if (scale != (Quantum *) NULL)
3900                   {
3901                     pixel.red=scale[pixel.red];
3902                     pixel.green=scale[pixel.green];
3903                     pixel.blue=scale[pixel.blue];
3904                   }
3905               }
3906             SetPixelRed(image,pixel.red,q);
3907             SetPixelGreen(image,pixel.green,q);
3908             SetPixelBlue(image,pixel.blue,q);
3909             q+=GetPixelChannels(image);
3910           }
3911           if (SyncAuthenticPixels(image,exception) == MagickFalse)
3912             break;
3913           if (image->previous == (Image *) NULL)
3914             {
3915               status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
3916                 image->rows);
3917               if (status == MagickFalse)
3918                 break;
3919             }
3920         }
3921         if (stream_info->segment_count > 1)
3922           for (y=0; y < (ssize_t) image->rows; y++)
3923           {
3924             q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
3925             if (q == (Quantum *) NULL)
3926               break;
3927             for (x=0; x < (ssize_t) image->columns; x++)
3928             {
3929               if (samples_per_pixel == 1)
3930                 {
3931                   int
3932                     pixel_value;
3933
3934                   if (bytes_per_pixel == 1)
3935                     pixel_value=polarity != MagickFalse ?
3936                       ((int) max_value-ReadDCMByte(stream_info,image)) :
3937                       ReadDCMByte(stream_info,image);
3938                   else
3939                     if ((bits_allocated != 12) || (significant_bits != 12))
3940                       {
3941                         if (image->endian == MSBEndian)
3942                           pixel_value=(int) (polarity != MagickFalse ?
3943                             (max_value-ReadDCMMSBShort(stream_info,image)) :
3944                             ReadDCMMSBShort(stream_info,image));
3945                         else
3946                           pixel_value=(int) (polarity != MagickFalse ?
3947                             (max_value-ReadDCMLSBShort(stream_info,image)) :
3948                             ReadDCMLSBShort(stream_info,image));
3949                         if (signed_data == 1)
3950                           pixel_value=((signed short) pixel_value);
3951                       }
3952                     else
3953                       {
3954                         if ((i & 0x01) != 0)
3955                           pixel_value=(ReadDCMByte(stream_info,image) << 8) |
3956                             byte;
3957                         else
3958                           {
3959                             if (image->endian == MSBEndian)
3960                               pixel_value=(int) ReadDCMMSBShort(stream_info,
3961                                 image);
3962                             else
3963                               pixel_value=(int) ReadDCMLSBShort(stream_info,
3964                                 image);
3965                             byte=(int) (pixel_value & 0x0f);
3966                             pixel_value>>=4;
3967                           }
3968                         i++;
3969                       }
3970                   index=pixel_value;
3971                   if (window_width == 0)
3972                     {
3973                       if (signed_data == 1)
3974                         index=pixel_value-32767;
3975                     }
3976                   else
3977                     {
3978                       ssize_t
3979                         window_max,
3980                         window_min;
3981
3982                       window_min=(ssize_t) ceil(window_center-(window_width-1)/
3983                         2.0-0.5);
3984                       window_max=(ssize_t) floor(window_center+(window_width-1)/
3985                         2.0+0.5);
3986                       if ((ssize_t) pixel_value <= window_min)
3987                         index=0;
3988                       else
3989                         if ((ssize_t) pixel_value > window_max)
3990                           index=(int) max_value;
3991                         else
3992                           index=(int) (max_value*(((pixel_value-window_center-
3993                             0.5)/(window_width-1))+0.5));
3994                     }
3995                   index&=mask;
3996                   index=(int) ConstrainColormapIndex(image,(size_t) index,
3997                     exception);
3998                   SetPixelIndex(image,(((size_t) GetPixelIndex(image,q)) |
3999                     (((size_t) index) << 8)),q);
4000                   pixel.red=1UL*image->colormap[index].red;
4001                   pixel.green=1UL*image->colormap[index].green;
4002                   pixel.blue=1UL*image->colormap[index].blue;
4003                 }
4004               else
4005                 {
4006                   if (bytes_per_pixel == 1)
4007                     {
4008                       pixel.red=(size_t) ReadDCMByte(stream_info,image);
4009                       pixel.green=(size_t) ReadDCMByte(stream_info,image);
4010                       pixel.blue=(size_t) ReadDCMByte(stream_info,image);
4011                     }
4012                   else
4013                     {
4014                       if (image->endian == MSBEndian)
4015                         {
4016                           pixel.red=ReadDCMMSBShort(stream_info,image);
4017                           pixel.green=ReadDCMMSBShort(stream_info,image);
4018                           pixel.blue=ReadDCMMSBShort(stream_info,image);
4019                         }
4020                       else
4021                         {
4022                           pixel.red=ReadDCMLSBShort(stream_info,image);
4023                           pixel.green=ReadDCMLSBShort(stream_info,image);
4024                           pixel.blue=ReadDCMLSBShort(stream_info,image);
4025                         }
4026                     }
4027                   pixel.red&=mask;
4028                   pixel.green&=mask;
4029                   pixel.blue&=mask;
4030                   if (scale != (Quantum *) NULL)
4031                     {
4032                       pixel.red=scale[pixel.red];
4033                       pixel.green=scale[pixel.green];
4034                       pixel.blue=scale[pixel.blue];
4035                     }
4036                 }
4037               SetPixelRed(image,(((size_t) GetPixelRed(image,q)) |
4038                 (((size_t) pixel.red) << 8)),q);
4039               SetPixelGreen(image,(((size_t) GetPixelGreen(image,q)) |
4040                 (((size_t) pixel.green) << 8)),q);
4041               SetPixelBlue(image,(((size_t) GetPixelBlue(image,q)) |
4042                 (((size_t) pixel.blue) << 8)),q);
4043               q+=GetPixelChannels(image);
4044             }
4045             if (SyncAuthenticPixels(image,exception) == MagickFalse)
4046               break;
4047             if (image->previous == (Image *) NULL)
4048               {
4049                 status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
4050                   image->rows);
4051                 if (status == MagickFalse)
4052                   break;
4053               }
4054           }
4055       }
4056     if (EOFBlob(image) != MagickFalse)
4057       {
4058         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
4059           image->filename);
4060         break;
4061       }
4062     /*
4063       Proceed to next image.
4064     */
4065     if (image_info->number_scenes != 0)
4066       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
4067         break;
4068     if (scene < (ssize_t) (number_scenes-1))
4069       {
4070         /*
4071           Allocate next image structure.
4072         */
4073         AcquireNextImage(image_info,image,exception);
4074         if (GetNextImageInList(image) == (Image *) NULL)
4075           {
4076             image=DestroyImageList(image);
4077             return((Image *) NULL);
4078           }
4079         image=SyncNextImageInList(image);
4080         status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
4081           GetBlobSize(image));
4082         if (status == MagickFalse)
4083           break;
4084       }
4085   }
4086   /*
4087     Free resources.
4088   */
4089   if (stream_info->offsets != (ssize_t *) NULL)
4090     stream_info->offsets=(ssize_t *)
4091       RelinquishMagickMemory(stream_info->offsets);
4092   stream_info=(DCMStreamInfo *) RelinquishMagickMemory(stream_info);
4093   if (scale != (Quantum *) NULL)
4094     scale=(Quantum *) RelinquishMagickMemory(scale);
4095   if (graymap != (int *) NULL)
4096     graymap=(int *) RelinquishMagickMemory(graymap);
4097   if (bluemap != (int *) NULL)
4098     bluemap=(int *) RelinquishMagickMemory(bluemap);
4099   if (greenmap != (int *) NULL)
4100     greenmap=(int *) RelinquishMagickMemory(greenmap);
4101   if (redmap != (int *) NULL)
4102     redmap=(int *) RelinquishMagickMemory(redmap);
4103   (void) CloseBlob(image);
4104   return(GetFirstImageInList(image));
4105 }
4106 \f
4107 /*
4108 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4109 %                                                                             %
4110 %                                                                             %
4111 %                                                                             %
4112 %   R e g i s t e r D C M I m a g e                                           %
4113 %                                                                             %
4114 %                                                                             %
4115 %                                                                             %
4116 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4117 %
4118 %  RegisterDCMImage() adds attributes for the DCM image format to
4119 %  the list of supported formats.  The attributes include the image format
4120 %  tag, a method to read and/or write the format, whether the format
4121 %  supports the saving of more than one frame to the same file or blob,
4122 %  whether the format supports native in-memory I/O, and a brief
4123 %  description of the format.
4124 %
4125 %  The format of the RegisterDCMImage method is:
4126 %
4127 %      size_t RegisterDCMImage(void)
4128 %
4129 */
4130 ModuleExport size_t RegisterDCMImage(void)
4131 {
4132   MagickInfo
4133     *entry;
4134
4135   static const char
4136     *DCMNote=
4137     {
4138       "DICOM is used by the medical community for images like X-rays.  The\n"
4139       "specification, \"Digital Imaging and Communications in Medicine\n"
4140       "(DICOM)\", is available at http://medical.nema.org/.  In particular,\n"
4141       "see part 5 which describes the image encoding (RLE, JPEG, JPEG-LS),\n"
4142       "and supplement 61 which adds JPEG-2000 encoding."
4143     };
4144
4145   entry=SetMagickInfo("DCM");
4146   entry->decoder=(DecodeImageHandler *) ReadDCMImage;
4147   entry->magick=(IsImageFormatHandler *) IsDCM;
4148   entry->adjoin=MagickFalse;
4149   entry->seekable_stream=MagickTrue;
4150   entry->description=ConstantString(
4151     "Digital Imaging and Communications in Medicine image");
4152   entry->note=ConstantString(DCMNote);
4153   entry->module=ConstantString("DCM");
4154   (void) RegisterMagickInfo(entry);
4155   return(MagickImageCoderSignature);
4156 }
4157 \f
4158 /*
4159 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4160 %                                                                             %
4161 %                                                                             %
4162 %                                                                             %
4163 %   U n r e g i s t e r D C M I m a g e                                       %
4164 %                                                                             %
4165 %                                                                             %
4166 %                                                                             %
4167 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4168 %
4169 %  UnregisterDCMImage() removes format registrations made by the
4170 %  DCM module from the list of supported formats.
4171 %
4172 %  The format of the UnregisterDCMImage method is:
4173 %
4174 %      UnregisterDCMImage(void)
4175 %
4176 */
4177 ModuleExport void UnregisterDCMImage(void)
4178 {
4179   (void) UnregisterMagickInfo("DCM");
4180 }