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