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