### Parse DICOM P10 Byte Arrays with dicomParser

Source: https://context7.com/cornerstonejs/dicomparser/llms.txt

Demonstrates the core functionality of parsing a DICOM file into a DataSet object using dicomParser. It shows how to access string and numeric DICOM elements by their tags and includes basic error handling. The example also illustrates advanced parsing options such as specifying transfer syntax, stopping at a particular tag, and providing custom callbacks for VR and inflation.

```javascript
const dicomParser = require('dicom-parser');
const fs = require('fs');

// Read DICOM file into buffer
const dicomFileAsBuffer = fs.readFileSync('CT_image.dcm');

// Basic parsing
try {
  const dataSet = dicomParser.parseDicom(dicomFileAsBuffer);

  // Access string elements using DICOM tags (format: xGGGGEEEE)
  const patientName = dataSet.string('x00100010');      // Patient Name
  const patientId = dataSet.string('x00100020');        // Patient ID
  const studyDate = dataSet.string('x00080020');        // Study Date
  const studyDescription = dataSet.string('x00081030'); // Study Description
  const modality = dataSet.string('x00080060');         // Modality

  console.log('Patient:', patientName);
  console.log('Patient ID:', patientId);
  console.log('Study Date:', studyDate);
  console.log('Modality:', modality);

  // Access numeric elements
  const rows = dataSet.uint16('x00280010');             // Rows
  const columns = dataSet.uint16('x00280011');          // Columns
  const bitsAllocated = dataSet.uint16('x00280100');    // Bits Allocated

  console.log(`Image dimensions: ${columns} x ${rows}`);
  console.log('Bits Allocated:', bitsAllocated);
} catch (ex) {
  console.log('Error parsing DICOM:', ex);
}

// Parsing with options
const options = {
  // For raw DICOM files without Part 10 header, specify transfer syntax
  TransferSyntaxUID: '1.2.840.10008.1.2',  // Implicit VR Little Endian

  // Stop parsing at a specific tag (useful for reading only headers)
  untilTag: 'x7fe00010',  // Stop before Pixel Data

  // Custom VR callback for implicit transfer syntax
  vrCallback: (tag) => {
    // Return VR for known tags
    if (tag === 'x00100010') return 'PN';
    return undefined;
  },

  // Custom inflater for deflated transfer syntax
  inflater: (byteArray, position) => {
    // Return inflated byte array
    return inflatedByteArray;
  }
};

const dataSetWithOptions = dicomParser.parseDicom(dicomFileAsBuffer, options);
```

--------------------------------

### DICOM Parsing with untilTag Option

Source: https://github.com/cornerstonejs/dicomparser/blob/master/README.md

This example demonstrates how to parse a DICOM byte stream up to a specific tag. This is useful for handling incomplete or partial byte streams, allowing the parser to stop at a designated element.

```javascript
import { parseDicom } from 'dicom-parser';

const byteArray = new Uint8Array(...);
const options = { untilTag: 'x7fe00010' };
try {
  const dataSet = parseDicom(byteArray, options);
  // Process the parsed dataSet
} catch (e) {
  // Handle parsing errors, potentially accessing partially parsed data
  console.error('Parsing error:', e);
}
```

--------------------------------

### Running the Build

Source: https://github.com/cornerstonejs/dicomparser/blob/master/README.md

Command to execute the project's build process using Webpack. This compiles the source code into distributable files.

```bash
npm run build
```

--------------------------------

### Watch Mode Build and Tests

Source: https://github.com/cornerstonejs/dicomparser/blob/master/README.md

Command to run the build and unit tests automatically, with changes to source files triggering recompilation and re-testing. This is useful for development.

```bash
npm run watch
```

--------------------------------

### Implement Drag and Drop File Handling

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dragAndDropParse/index.html

Configures event listeners for a drop zone to capture dropped files and initiate the parsing process. It prevents default browser behavior and extracts the first file from the FileList.

```javascript
function handleFileSelect(evt) {
  evt.stopPropagation();
  evt.preventDefault();
  var files = evt.dataTransfer.files;
  dumpFile(files[0]);
}

function handleDragOver(evt) {
  evt.stopPropagation();
  evt.preventDefault();
  evt.dataTransfer.dropEffect = 'copy';
}

var dropZone = document.getElementById('dropZone');
dropZone.addEventListener('dragover', handleDragOver, false);
dropZone.addEventListener('drop', handleFileSelect, false);
```

--------------------------------

### Compress DICOM to JPEG-LS using dcmcjpls

Source: https://github.com/cornerstonejs/dicomparser/blob/master/testImages/encapsulated/single-frame/README.md

Demonstrates various command-line invocations for dcmcjpls. These commands show how to handle file fragmentation and Basic Offset Table (BOT) options during the JPEG-LS compression process.

```bash
# Not Fragmented with basic offset table
dcmcjpls CT1_UNC.explicit_little_endian.dcm CT1_UNC.not_fragmented_bot_jpeg_ls.80.dcm

# Not Fragmented with empty basic offset table
dcmcjpls -ot CT1_UNC.explicit_little_endian.dcm CT1_UNC.not_fragmented_no_bot_jpeg_ls.80.dcm

# Fragments with basic offset table
dcmcjpls +fs 8 CT1_UNC.explicit_little_endian.dcm CT1_UNC.fragmented_bot_jpeg_ls.80.dcm

# Fragments with empty basic offset table
dcmcjpls -ot CT1_UNC.explicit_little_endian.dcm CT1_UNC.fragmented_no_bot_jpeg_ls.80.dcm
```

--------------------------------

### DICOM Parser Initialization and Helper Functions (JavaScript)

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dragAndDropDump/index.html

This snippet shows how to include the dicom-parser library and defines helper functions for checking ASCII characters and recursively dumping DICOM dataset elements. It handles sequences, fragments, and displays element data with length, VR, and values where appropriate.

```javascript
window.dicomParser || document.write('<script src="https://unpkg.com/dicom-parser">\x3C/script>') // helper function to see if a string only has ascii characters in it function isASCII(str) { return /^[ -]*$/.test(str); } // This function iterates through dataSet recursively and adds new HTML strings // to the output array passed into it function dumpDataSet(dataSet, output) { // the dataSet.elements object contains properties for each element parsed. The name of the property // is based on the elements tag and looks like 'xGGGGEEEE' where GGGG is the group number and EEEE is the // element number both with lowercase hexadecimal letters. For example, the Series Description DICOM element 0008,103E would // be named 'x0008103e'. Here we iterate over each property (element) so we can build a string describing its // contents to add to the output array try { for (var propertyName in dataSet.elements) { var element = dataSet.elements[propertyName]; // The output string begins with the element tag, length and VR (if present). VR is undefined for // implicit transfer syntaxes var text = element.tag; text += " length=" + element.length; if (element.hadUndefinedLength) { text += " <strong>(-1)</strong>"; } text += "; "; if (element.vr) { text += " VR=" + element.vr + "; "; } var color = 'black'; // Here we check for Sequence items and iterate over them if present. items will not be set in the // element object for elements that don't have SQ VR type. Note that implicit little endian // sequences will are currently not parsed. if (element.items) { output.push('<li>' + text + '</li>'); output.push('<ul>'); // each item contains its own data set so we iterate over the items // and recursively call this function var itemNumber = 0; element.items.forEach(function (item) { output.push('<li>Item #' + itemNumber++ + ' ' + item.tag + '</li>') output.push('<ul>'); dumpDataSet(item.dataSet, output); output.push('</ul>'); }); output.push('</ul>'); } else if (element.fragments) { output.push('<li>' + text + '</li>'); output.push('<ul>'); // each item contains its own data set so we iterate over the items // and recursively call this function var itemNumber = 0; element.fragments.forEach(function (fragment) { var basicOffset; if(element.basicOffsetTable) { basicOffset = element.basicOffsetTable[itemNumber]; } var str = '<li>Fragment #' + itemNumber++ + ' offset = ' + fragment.offset; str += '(' + basicOffset + ')'; str += '; length = ' + fragment.length + '</li>'; output.push(str); }); output.push('</ul>'); } else { // if the length of the element is less than 128 we try to show it. We put this check in // to avoid displaying large strings which makes it harder to use. if (element.length < 128) { // Since the dataset might be encoded using implicit transfer syntax and we aren't using // a data dictionary, we need some simple logic to figure out what data types these // elements might be. Since the dataset might also be explicit we could be switch on the // VR and do a better job on this, perhaps we can do that in another example // First we check to see if the element's length is appropriate for a UI or US VR. // US is an important type because it is used for the // image Rows and Columns so that is why those are assumed over other VR types. if (element.length === 2) { text += " (" + dataSet.uint16(propertyName) + ")"; } else if (element.length === 4) { text += " (" + dataSet.uint32(propertyName) + ")"; } // Next we ask the dataset to give us the element's data in string form. Most elements are // strings but some aren't so we do a quick check to make sure it actually has all ascii // characters so we know it is reasonable to display it. var str = dataSet.string(propertyName); var stringIsAscii = isASCII(str); if (stringIsAscii) { // the string will be undefined if the element is present but has no data // (i.e. attribute is of type 2 or 3 ) so we only display the string if it has // data. Note that the length of the element will be 0 to indicate "no data" // so we don't put anything here for the value in that case. if (str !== undefined) { text += '"' + str + '"'; } } else { if (element.length !== 2 && element.length !== 4) { color = '#C8C8C8'; // If it is some other length and we have no string text += "<i>binary data</i>"; } } if (element.length === 0) { color = '#C8C8C8'; } } else { color = '#C8C8C8'; // Add text saying the data is too long to show... text += "<i>data too long to show</i>"; } // finally we add the string to our output array surrounded by li elements so it shows up in the // DOM as a list output.push('<li style="color:' + color + ';">' + text + '</li>'); } } } catch(err) { var ex = { exception: err, output: output } throw ex; } }
```

--------------------------------

### File Drop and Drag Handling

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dumpWithDataDictionary/index.html

Sets up event listeners for drag-and-drop functionality on a specified drop zone. Handles file selection and processing when a file is dropped onto the designated area.

```javascript
function handleFileSelect(evt) {
  evt.stopPropagation();
  evt.preventDefault();
  var files = evt.dataTransfer.files;
  file = files[0];
  dumpFile();
}
function handleDragOver(evt) {
  evt.stopPropagation();
  evt.preventDefault();
  evt.dataTransfer.dropEffect = 'copy';
}
var dropZone = document.getElementById('dropZone');
dropZone.addEventListener('dragover', handleDragOver, false);
dropZone.addEventListener('drop', handleFileSelect, false);
```

--------------------------------

### DICOM Parser Initialization and Configuration

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dumpWithDataDictionary/index.html

Initializes the dicom-parser library and sets up various configuration flags to control the display of parsed DICOM data. These flags determine whether to show private elements, P10 headers, empty values, lengths, VRs, group/element tags, fragments, frames, and SHA1 hashes.

```javascript
window.dicomParser || document.write('<script src="https://unpkg.com/dicom-parser">\x3C/script>')
var dataSet;
var maxLength = 128;
var untilTag = "";
var showPrivateElements = false;
var showP10Header = false;
var showEmptyValues = false;
var showLength = false;
var showVR = false;
var showGroupElement = false;
var showFragments = false;
var showFrames = false;
var showSHA1 = false;
var file = undefined;
var sha1Hash = "";
var rusha = new Rusha();
```

--------------------------------

### Node.js Deflate/Inflate with zlib

Source: https://github.com/cornerstonejs/dicomparser/blob/master/README.md

This snippet demonstrates how to use the zlib library for inflating deflated DICOM data when running in a Node.js environment. It's a key component for handling the 'Deflated Explicit VR Little Endian' transfer syntax.

```javascript
const zlib = require('zlib');

function inflateData(compressedBuffer) {
  return zlib.inflateSync(compressedBuffer);
}
```

--------------------------------

### createJPEGBasicOffsetTable

Source: https://context7.com/cornerstonejs/dicomparser/llms.txt

Generates a basic offset table for JPEG images by scanning fragments for End-of-Image markers (0xFFD9). This is useful for multi-frame JPEG data lacking an initial offset table.

```APIDOC
## createJPEGBasicOffsetTable

### Description
Scans JPEG fragments to create a basic offset table by detecting JPEG end-of-image markers (0xFFD9). Useful when the DICOM file lacks a basic offset table but contains JPEG-compressed multi-frame data.

### Method
`createJPEGBasicOffsetTable(dataSet, pixelDataElement)`

### Parameters
- **dataSet** (object) - The parsed DICOM dataset.
- **pixelDataElement** (object) - The pixel data element (e.g., `dataSet.elements.x7fe00010`).

### Request Example
```javascript
const dicomParser = require('dicom-parser');
const fs = require('fs');

const dicomFileAsBuffer = fs.readFileSync('multiframe_jpeg_no_bot.dcm');
const dataSet = dicomParser.parseDicom(dicomFileAsBuffer);

const pixelDataElement = dataSet.elements.x7fe00010;

if (pixelDataElement.encapsulatedPixelData &&
    pixelDataElement.basicOffsetTable.length === 0) {

  const basicOffsetTable = dicomParser.createJPEGBasicOffsetTable(
    dataSet,
    pixelDataElement
  );

  console.log('Generated offset table with', basicOffsetTable.length, 'frames');

  for (let frameIndex = 0; frameIndex < basicOffsetTable.length; frameIndex++) {
    const frameData = dicomParser.readEncapsulatedImageFrame(
      dataSet,
      pixelDataElement,
      frameIndex,
      basicOffsetTable,
      pixelDataElement.fragments
    );
    console.log(`Frame ${frameIndex}: ${frameData.length} bytes`);
  }
}
```

### Response
- Returns an array representing the basic offset table, where each entry typically contains the offset and size of a frame.
```

--------------------------------

### Create memory-efficient byte array views

Source: https://context7.com/cornerstonejs/dicomparser/llms.txt

Demonstrates the sharedCopy method to create a view into an existing byte array without duplicating the underlying memory. This is highly efficient for accessing large pixel data segments in DICOM files.

```javascript
const dicomParser = require('dicom-parser');
const fs = require('fs');

const dicomFileAsBuffer = fs.readFileSync('large_image.dcm');
const dataSet = dicomParser.parseDicom(dicomFileAsBuffer);

// Get pixel data element info
const pixelData = dataSet.elements.x7fe00010;

// Create a view into the pixel data (no memory copy)
const pixelDataView = dicomParser.sharedCopy(
  dicomFileAsBuffer,
  pixelData.dataOffset,
  pixelData.length
);

// pixelDataView shares memory with original buffer
console.log('View length:', pixelDataView.length);
```

--------------------------------

### Updating Dependencies

Source: https://github.com/cornerstonejs/dicomparser/blob/master/README.md

Command to update project dependencies. This should be run after pulling changes to ensure all necessary packages are up-to-date.

```bash
npm install
```

--------------------------------

### Read binary data with ByteStream

Source: https://context7.com/cornerstonejs/dicomparser/llms.txt

Shows how to instantiate and use the ByteStream class for reading binary data from byte arrays. It supports seeking, reading integers, and fixed-length strings, providing a controlled interface for custom parsing.

```javascript
const dicomParser = require('dicom-parser');

// Create a ByteStream for custom parsing
const byteArray = new Uint8Array([0x44, 0x49, 0x43, 0x4D, 0x02, 0x00, 0x10, 0x00]);
const byteStream = new dicomParser.ByteStream(
  dicomParser.littleEndianByteArrayParser,
  byteArray,
  0  // starting position
);

// Read data
const magic = byteStream.readFixedString(4);  // "DICM"
console.log('Magic:', magic);
const value = byteStream.readUint16();  // Read 16-bit unsigned

// Seek to position
byteStream.seek(2);  // Move forward 2 bytes

// Create sub-stream
byteStream.position = 0;
const subStream = byteStream.readByteStream(4);  // Read 4 bytes into new stream
```

--------------------------------

### Web Browser Deflate/Inflate with pako

Source: https://github.com/cornerstonejs/dicomparser/blob/master/README.md

This snippet shows how to use the pako library for inflating deflated DICOM data in a web browser environment. This is required for handling the 'Deflated Explicit VR Little Endian' transfer syntax in browser-based applications.

```javascript
import pako from 'pako';

function inflateData(compressedBuffer) {
  return pako.inflate(compressedBuffer);
}
```

--------------------------------

### Initialize File Parsing

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dumpWithDataDictionary/index.html

Reads a file using the FileReader API, converts it to a Uint8Array, and initiates the DICOM parsing process with a timeout to allow for UI updates.

```javascript
var reader = new FileReader(); reader.onload = function(file) { var arrayBuffer = reader.result; var byteArray = new Uint8Array(arrayBuffer); setTimeout(function() { var sha1Hash = sha1(byteArray, 0, byteArray.length); try { var start = new Date().getTime(); } catch(err) { throw err; } }, 0); };
```

--------------------------------

### Load DICOM via WADO Request

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/wado/index.html

This snippet demonstrates how to fetch a DICOM file from a WADO URL using an XMLHttpRequest with an arraybuffer response type. It includes error handling for the request process and triggers a byte array dump upon successful retrieval.

```javascript
$('#downloadAndDump').click(function(e) {
  document.getElementById('dropZone').innerHTML = '';
  $('#status').removeClass('alert-warning alert-success alert-danger').addClass('alert-info');
  $('#warnings').empty();
  document.getElementById('statusText').innerHTML = 'Status: Loading file, please wait..';
  var url = $('#wadoURL').val();
  var oReq = new XMLHttpRequest();
  try {
    oReq.open("get", url, true);
  } catch(err) {
    $('#status').removeClass('alert-success alert-info alert-warning').addClass('alert-danger');
    document.getElementById('statusText').innerHTML = 'Status: Error - ' + err;
    return false;
  }
  oReq.responseType = "arraybuffer";
  oReq.onreadystatechange = function(oEvent) {
    if(oReq.readyState == 4) {
      if(oReq.status == 200) {
        var byteArray = new Uint8Array(oReq.response);
        dumpByteArray(byteArray);
      } else {
        $('#status').removeClass('alert-success alert-info alert-warning').addClass('alert-danger');
        document.getElementById('statusText').innerHTML = 'Status: HTTP Error - status code ' + oReq.status;
      }
    }
  };
  oReq.send();
  return false;
});
```

--------------------------------

### DataSet Methods - Access Element Values

Source: https://context7.com/cornerstonejs/dicomparser/llms.txt

Demonstrates how to use typed accessor methods on the DataSet object to read DICOM element values, including strings, integers, floats, and multi-valued elements.

```APIDOC
## DataSet Methods - Access Element Values

### Description
The DataSet object provides typed accessor methods for reading DICOM element values. Each method takes a tag in the format 'xGGGGEEEE' and optionally an index for multi-valued elements.

### Method
Various typed accessor methods (e.g., `string`, `uint16`, `float`, `floatString`)

### Endpoint
N/A (This is a library method, not an API endpoint)

### Parameters
- **tag** (string) - Required - The DICOM tag of the element (e.g., 'x00100010').
- **index** (number) - Optional - The index for multi-valued elements.

### Request Example
```javascript
const dicomParser = require('dicom-parser');
const fs = require('fs');

const dicomFileAsBuffer = fs.readFileSync('CT_image.dcm');
const dataSet = dicomParser.parseDicom(dicomFileAsBuffer);

// String values (VR: AE, CS, SH, LO, PN, UI)
const patientName = dataSet.string('x00100010');

// Text values with preserved leading spaces (VR: UT, ST, LT)
const comments = dataSet.text('x00324000');

// Unsigned integers
const rows = dataSet.uint16('x00280010');

// Signed integers
const rescaleIntercept = dataSet.int16('x00281052');

// Floating point
const pixelSpacingX = dataSet.float('x00280030');

// String-encoded numbers (VR: DS, IS)
const windowCenter = dataSet.floatString('x00281050');

// Multi-valued elements - access specific index
const spacing1 = dataSet.floatString('x00280030', 0);

// Count values in multi-valued element
const numValues = dataSet.numStringValues('x00280030');

// Attribute Tag (VR: AT)
const referencedTag = dataSet.attributeTag('x00081140');

// Direct element access
const element = dataSet.elements.x7fe00010;

// Access sequence elements
const referencedStudySeq = dataSet.elements.x00081110;
if (referencedStudySeq && referencedStudySeq.items) {
  referencedStudySeq.items.forEach((item, index) => {
    const referencedSopUid = item.dataSet.string('x00081155');
  });
}

// Check for parsing warnings
if (dataSet.warnings && dataSet.warnings.length > 0) {
  console.log('Parsing warnings:', dataSet.warnings);
}
```

### Response
- **Value** (various types) - The retrieved DICOM element value, typed according to the accessor method used.

### Response Example
```javascript
// Example for patientName
// "Doe^John"

// Example for rows
// 512

// Example for spacing1
// 0.5
```
```

--------------------------------

### Accessing DICOM Element Values with DataSet

Source: https://context7.com/cornerstonejs/dicomparser/llms.txt

Demonstrates how to parse a DICOM file and use typed accessor methods to retrieve various data types including strings, integers, floats, and sequence elements.

```javascript
const dicomParser = require('dicom-parser');
const fs = require('fs');

const dicomFileAsBuffer = fs.readFileSync('CT_image.dcm');
const dataSet = dicomParser.parseDicom(dicomFileAsBuffer);

const patientName = dataSet.string('x00100010');
const rows = dataSet.uint16('x00280010');
const pixelSpacing = dataSet.floatString('x00280030', 0);

const referencedStudySeq = dataSet.elements.x00081110;
if (referencedStudySeq && referencedStudySeq.items) {
  referencedStudySeq.items.forEach((item, index) => {
    const referencedSopUid = item.dataSet.string('x00081155');
    console.log(`Referenced SOP Instance ${index}:`, referencedSopUid);
  });
}
```

--------------------------------

### Handle endianness with Byte Array Parsers

Source: https://context7.com/cornerstonejs/dicomparser/llms.txt

Explains how to use built-in little-endian and big-endian parsers to read binary data correctly. This is critical for interpreting DICOM data correctly across different transfer syntaxes.

```javascript
const dicomParser = require('dicom-parser');

const byteArray = new Uint8Array([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);

// Little Endian Parser (most common in DICOM)
const leParser = dicomParser.littleEndianByteArrayParser;
console.log('LE uint16:', leParser.readUint16(byteArray, 0));

// Big Endian Parser (deprecated transfer syntax)
const beParser = dicomParser.bigEndianByteArrayParser;
console.log('BE uint16:', beParser.readUint16(byteArray, 0));

// Reading fixed strings
const textArray = new Uint8Array([0x48, 0x65, 0x6C, 0x6C, 0x6F]);
const text = dicomParser.readFixedString(textArray, 0, 5);  // "Hello"
```

--------------------------------

### Parse DICOM File via Drag and Drop

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dragAndDropDump/index.html

This snippet demonstrates how to handle file drop events, read a file as an ArrayBuffer, and parse the DICOM data using dicomParser. It includes UI status updates and error handling for the parsing process.

```javascript
function handleFileSelect(evt) {
  evt.stopPropagation();
  evt.preventDefault();
  var files = evt.dataTransfer.files;
  dumpFile(files[0]);
}

function dumpFile(file) {
  var reader = new FileReader();
  reader.onload = function(file) {
    var arrayBuffer = reader.result;
    var byteArray = new Uint8Array(arrayBuffer);
    setTimeout(function() {
      try {
        var dataSet = dicomParser.parseDicom(byteArray);
        var output = [];
        dumpDataSet(dataSet, output);
        document.getElementById('dropZone').innerHTML = '<ul>' + output.join('') + '</ul>';
      } catch(err) {
        console.error(err);
      }
    }, 10);
  };
  reader.readAsArrayBuffer(file);
}

var dropZone = document.getElementById('dropZone');
dropZone.addEventListener('dragover', function(evt) {
  evt.stopPropagation();
  evt.preventDefault();
  evt.dataTransfer.dropEffect = 'copy';
}, false);
dropZone.addEventListener('drop', handleFileSelect, false);
```

--------------------------------

### Display DICOM Parser Version

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dumpWithDataDictionary/index.html

Retrieves and displays the version of the dicomParser library on the webpage.

```javascript
 $('#version').text(dicomParser.version);
```

--------------------------------

### Generate JPEG Basic Offset Table

Source: https://context7.com/cornerstonejs/dicomparser/llms.txt

Scans JPEG-compressed DICOM fragments to generate a basic offset table by identifying end-of-image markers. This enables frame-by-frame extraction for files missing the standard offset table.

```javascript
const dicomParser = require('dicom-parser');
const fs = require('fs');

const dicomFileAsBuffer = fs.readFileSync('multiframe_jpeg_no_bot.dcm');
const dataSet = dicomParser.parseDicom(dicomFileAsBuffer);
const pixelDataElement = dataSet.elements.x7fe00010;

if (pixelDataElement.encapsulatedPixelData && pixelDataElement.basicOffsetTable.length === 0) {
  const basicOffsetTable = dicomParser.createJPEGBasicOffsetTable(dataSet, pixelDataElement);
  
  for (let frameIndex = 0; frameIndex < basicOffsetTable.length; frameIndex++) {
    const frameData = dicomParser.readEncapsulatedImageFrame(
      dataSet,
      pixelDataElement,
      frameIndex,
      basicOffsetTable,
      pixelDataElement.fragments
    );
  }
}
```

--------------------------------

### Download DICOM Data

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dumpWithDataDictionary/index.html

Creates a Blob from provided data and initiates a download for the user. This function is used to download specific DICOM elements or image frames.

```javascript
function downloadData(data, fileName) {
  var blob = new Blob([data], {type: 'application/octet-stream'});
  var objectURL = URL.createObjectURL(blob);
  var a = document.createElement("a");
  document.body.appendChild(a);
  a.style = "display: none";
  a.href = objectURL;
  a.download = fileName;
  a.click();
  window.URL.revokeObjectURL(objectURL);
  $(a).remove();
}
```

--------------------------------

### Event Handlers for Data Download

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dumpWithDataDictionary/index.html

Attaches click event listeners to elements for downloading either specific DICOM data elements or encapsulated image frames. It retrieves necessary attributes from the clicked element to perform the download.

```javascript
$('.imageFrameDownload').click(function(ev) {
  var frameIndex = parseInt($(ev.currentTarget).attr('data-frameIndex'));
  var imageFrame = extractEncapsulatedImageFrame(frameIndex);
  var sopInstanceUid = dataSet.string('x00080018');
  var fileName = sopInstanceUid + "-imageFrame-" + frameIndex + ".dat";
  downloadData(imageFrame,fileName);
  ev.preventDefault();
  ev.stopPropagation();
});
$('.dataDownload').click(function(ev) {
  var tag = $(ev.currentTarget).attr('data-tag');
  var dataOffset = parseInt($(ev.currentTarget).attr('data-dataOffset'));
  var length = parseInt($(ev.currentTarget).attr('data-length'));
  var data = dicomParser.sharedCopy(dataSet.byteArray, dataOffset, length);
  var sopInstanceUid = dataSet.string('x00080018');
  var fileName = sopInstanceUid + "-" + tag + "-" + dataOffset + ":" + length + ".dat";
  downloadData(data,fileName);
  ev.preventDefault();
  ev.stopPropagation();
});
```

--------------------------------

### Handle DICOM File Drop for Parsing

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/gettingStarted/index.html

This JavaScript code sets up event listeners for drag-and-drop functionality on a designated 'dropZone' element. It prevents default browser behaviors, handles file selection, and initiates the loading and parsing of the dropped DICOM file.

```javascript
function handleFileSelect(evt) {
  evt.stopPropagation();
  evt.preventDefault();
  var files = evt.dataTransfer.files;
  loadFile(files[0]);
}

function handleDragOver(evt) {
  evt.stopPropagation();
  evt.preventDefault();
  evt.dataTransfer.dropEffect = 'copy';
}

var dropZone = document.getElementById('dropZone');
dropZone.addEventListener('dragover', handleDragOver, false);
dropZone.addEventListener('drop', handleFileSelect, false);
```

--------------------------------

### DICOM File Parsing and Display with dicom-parser

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/explicitDataSetToJson/index.html

This snippet demonstrates how to parse a DICOM file using the dicom-parser library. It handles file loading via FileReader, converts the file to a Uint8Array, and then uses dicomParser.parseDicom to extract the data. The parsed data is then converted to a JavaScript object and displayed in a preformatted HTML element. Error handling and status updates are included.

```javascript
window.dicomParser || document.write('<script src="https://unpkg.com/dicom-parser">\x3C/script>')

function dumpDataSet(instance) {
  var json = JSON.stringify(instance, undefined, 2);
  return '<pre><code id="code" class="prettyprint">' + json + '</code></pre>';
}

function dumpFile(file) {
  document.getElementById('dropZone').innerHTML = '';
  $('#status').removeClass('alert-warning alert-success alert-danger').addClass('alert-info');
  $('#warnings').empty();
  document.getElementById('statusText').innerHTML = 'Status: Loading file, please wait..';
  var reader = new FileReader();
  reader.onload = function(file) {
    var arrayBuffer = reader.result;
    var byteArray = new Uint8Array(arrayBuffer);
    var kb = byteArray.length / 1024;
    var mb = kb / 1024;
    var byteStr = mb > 1 ? mb.toFixed(3) + " MB" : kb.toFixed(0) + " KB";
    document.getElementById('statusText').innerHTML = 'Status: Parsing ' + byteStr + ' bytes, please wait..';
    setTimeout(function() {
      var dataSet;
      try {
        var start = new Date().getTime();
        dataSet = dicomParser.parseDicom(byteArray, {
          vrCallback(tag) {
            const formatted = `(${tag.substr(1, 4).toUpperCase()},${tag.substr(5, 9).toUpperCase()})`;
            return !!TAG_DICT[formatted] ? TAG_DICT[formatted].vr : undefined;
          }
        });
        var options = {
          omitPrivateAttibutes: false,
          maxElementLength: 128
        };
        var instance = dicomParser.explicitDataSetToJS(dataSet, options);
        var output = dumpDataSet(instance);
        document.getElementById('dropZone').innerHTML = output;
        var end = new Date().getTime();
        var time = end - start;
        if (dataSet.warnings.length > 0) {
          $('#status').removeClass('alert-success alert-info alert-danger').addClass('alert-warning');
          $('#statusText').html('Status: Warnings encountered while parsing file (file of size ' + byteStr + ' parsed in ' + time + 'ms)');
          dataSet.warnings.forEach(function(warning) {
            $("#warnings").append('<li>' + warning + '</li>');
          });
        } else {
          var pixelData = dataSet.elements.x7fe00010;
          if (pixelData) {
            $('#status').removeClass('alert-warning alert-info alert-danger').addClass('alert-success');
            $('#statusText').html('Status: Ready (file of size ' + byteStr + ' parsed in ' + time + 'ms)');
          } else {
            $('#status').removeClass('alert-warning alert-info alert-danger').addClass('alert-success');
            $('#statusText').html('Status: Ready - no pixel data found (file of size ' + byteStr + ' parsed in ' + time + 'ms)');
          }
        }
      } catch (err) {
        $('#status').removeClass('alert-success alert-info alert-warning').addClass('alert-danger');
        document.getElementById('statusText').innerHTML = 'Status: Error - ' + err + ' (file of size ' + byteStr + ' )';
      }
    }, 10);
  };
  reader.readAsArrayBuffer(file);
}
```

--------------------------------

### readPart10Header

Source: https://context7.com/cornerstonejs/dicomparser/llms.txt

Parses only the DICOM Part 10 file meta information (group 0002 elements) without parsing the full dataset. This is efficient for quickly accessing metadata like transfer syntax.

```APIDOC
## readPart10Header

### Description
Parses just the DICOM Part 10 file meta information (group 0002 elements) without parsing the full dataset. Useful for quickly reading transfer syntax and other metadata.

### Method
`readPart10Header(buffer, options)`

### Parameters
- **buffer** (Buffer) - The DICOM file content as a Buffer.
- **options** (object, optional) - Options object. Can include `TransferSyntaxUID` for raw DICOM files without a Part 10 header.
  - **TransferSyntaxUID** (string) - The Transfer Syntax UID to use when the Part 10 header is missing.

### Request Example
```javascript
const dicomParser = require('dicom-parser');
const fs = require('fs');

const dicomFileAsBuffer = fs.readFileSync('image.dcm');

const metaHeader = dicomParser.readPart10Header(dicomFileAsBuffer);

const transferSyntaxUid = metaHeader.string('x00020010');
const mediaStorageSopClass = metaHeader.string('x00020002');
const mediaStorageSopInstance = metaHeader.string('x00020003');
const implementationClassUid = metaHeader.string('x00020012');

console.log('Transfer Syntax:', transferSyntaxUid);
console.log('SOP Class:', mediaStorageSopClass);
console.log('Implementation:', implementationClassUid);
console.log('Dataset starts at byte:', metaHeader.position);

// Handling raw DICOM files without Part 10 header
const rawDicomBuffer = fs.readFileSync('raw_image.dcm');
const options = {
  TransferSyntaxUID: '1.2.840.10008.1.2' // Implicit VR Little Endian
};
const rawHeader = dicomParser.readPart10Header(rawDicomBuffer, options);
```

### Response
- Returns a `DataSet` object containing only the Part 10 header elements.
- The `position` property of the returned object indicates the byte offset where the main DICOM dataset begins.
```

--------------------------------

### Core API - parseDicom

Source: https://context7.com/cornerstonejs/dicomparser/llms.txt

The main entry point for parsing DICOM files. It takes a Uint8Array or Node.js Buffer containing DICOM data and returns a DataSet object with all parsed elements. Supports options for partial parsing, custom transfer syntax, and deflated data handling.

```APIDOC
## POST /api/users

### Description
This endpoint allows for the creation of new user accounts.

### Method
POST

### Endpoint
/api/users

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **username** (string) - Required - The desired username for the new account.
- **email** (string) - Required - The email address for the new account.
- **password** (string) - Required - The password for the new account.

### Request Example
```json
{
  "username": "johndoe",
  "email": "john.doe@example.com",
  "password": "securepassword123"
}
```

### Response
#### Success Response (201)
- **userId** (string) - The unique identifier for the newly created user.
- **message** (string) - A confirmation message.

#### Response Example
```json
{
  "userId": "usr_12345abcde",
  "message": "User account created successfully."
}
```
```

--------------------------------

### DICOM Parsing and Data Display

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dumpWithDataDictionary/index.html

Parses a DICOM file from a byte array, logs the dataset to the console, and recursively iterates through the dataset to create an HTML list for display. Includes error handling and status updates.

```javascript
var dataSet = dicomParser.parseDicom(byteArray, options);
if(console) {
  console.log(dataSet);
}
var output = [];
dumpDataSet(dataSet, output);
document.getElementById('dropZone').innerHTML = '<ul>' + output.join('') + '</ul>';
var end = new Date().getTime();
var time = end - start;
var statusText = 'Status:';
if(dataSet.warnings.length > 0) {
  $('#status').removeClass('alert-success alert-info alert-danger').addClass('alert-warning');
  statusText += 'Warnings encountered while parsing file';
  dataSet.warnings.forEach(function(warning) {
    $("#warnings").append('<li>' + warning +'</li>');
  });
} else {
  var pixelData = dataSet.elements.x7fe00010;
  if(pixelData) {
    $('#status').removeClass('alert-warning alert-info alert-danger').addClass('alert-success');
    statusText += 'Ready';
  } else {
    $('#status').removeClass('alert-warning alert-info alert-danger').addClass('alert-success');
    statusText += 'Ready - no pixel data found';
  }
}
statusText += '; file size ' + byteStr;
statusText += '; parse time ' + time + 'ms';
statusText += '; SHA1 = ' + sha1Hash;
statusText += '<br>';
statusText += uids[ (dataSet.string('x00020002')) ];
statusText += '; ' + uids[ (dataSet.string('x00020010')) ];
$('#statusText').html(statusText);
} catch(err) {
  var message = err;
  if(err.exception) {
    message = err.exception;
  }
  $('#status').removeClass('alert-success alert-info alert-warning').addClass('alert-danger');
  document.getElementById('statusText').innerHTML = 'Status: Error - ' + message + ' (file of size ' + byteStr + ' )';
  if(err.output) {
    document.getElementById('dropZone').innerHTML = '<ul>' + output.join('') + '</ul>';
  } else if(err.dataSet) {
    var output = [];
    dumpDataSet(err.dataSet, output);
    document.getElementById('dropZone').innerHTML = '<ul>' + output.join('') + '</ul>';
  }
}
```

--------------------------------

### DICOM Parsing and Data Extraction

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/gettingStarted/index.html

This snippet demonstrates how to parse a DICOM byte array using the dicomParser library and extract key information such as SOP Instance UID, Patient ID, and image dimensions. It also shows how to access nested elements within sequences and handle multi-valued elements.

```APIDOC
## DICOM Parsing and Data Extraction

### Description
This section details how to use the `dicomParser` library to parse a DICOM byte array and extract specific DICOM tags. It covers accessing various data types, including strings, unsigned integers, and elements within sequences. Error handling for corrupted or non-DICOM files is also addressed.

### Method
`parseByteArray(byteArray)`

### Endpoint
N/A (This is a client-side JavaScript library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **byteArray** (Uint8Array) - Required - The byte array containing the DICOM data.

### Request Example
```javascript
// Assuming 'byteArray' is a Uint8Array containing DICOM data
var dataSet = dicomParser.parseDicom(byteArray);
```

### Response
#### Success Response (200)
- **dataSet** (Object) - A DataSet object containing the parsed DICOM elements.

#### Response Example
```json
{
  "elements": {
    "x0020000d": {
      "tag": "x0020000d",
      "vr": "UI",
      "length": 20,
      "dataOffset": 132
    },
    "x00100020": {
      "tag": "x00100020",
      "vr": "LO",
      "length": 5,
      "dataOffset": 160
    }
    // ... other elements
  },
  "string": function(tag) { /* ... */ },
  "uint16": function(tag) { /* ... */ },
  "numStringValues": function(tag) { /* ... */ }
  // ... other methods
}
```

### Error Handling
- The `parseDicom` function will throw an exception if the provided `byteArray` is not a valid Part 10 DICOM file or is corrupted. A try-catch block should be used to handle these errors.

### Example Usage (Extracting specific tags)

**SOP Instance UID (0020,000D):**
```javascript
var sopInstanceUid = dataSet.string('x0020000d');
console.log('SOP Instance UID:', sopInstanceUid);
```

**Patient ID (0010,0020):**
```javascript
var patientId = dataSet.string('x00100020');
if(patientId !== undefined) {
  console.log('Patient ID:', patientId);
} else {
  console.log('Patient ID element has no data');
}
```

**Other Patient IDs Sequence (0010,1002):**
```javascript
var otherPatientIds = dataSet.string('x00101002');
if(otherPatientIds !== undefined) {
  console.log('Other Patient IDs:', otherPatientIds);
} else {
  console.log('Other Patient IDs element not present');
}
```

**Rows (0028,0010) - Unsigned Short:**
```javascript
var rows = dataSet.uint16('x00280010');
if(rows !== undefined) {
  console.log('Rows:', rows);
} else {
  console.log('Rows element not present or has no data');
}
```

**Referenced SOP Class UID (within ReferencedImageSequence 0008,1140):**
```javascript
var referencedImageSequence = dataSet.elements.x00081140;
if(referencedImageSequence !== undefined && referencedImageSequence.items.length > 0) {
  var firstItemDataSet = referencedImageSequence.items[0].dataSet;
  var referencedSOPClassUID = firstItemDataSet.string('x00081150');
  console.log('Referenced SOP Class UID:', referencedSOPClassUID);
}
```

**Image Position Patient (0020,0032) - Multi-valued Float String:**
```javascript
if(dataSet.elements.x00200032 !== undefined) {
  var imagePositionPatientX = dataSet.floatString('x00200032', 0);
  var imagePositionPatientY = dataSet.floatString('x00200032', 1);
  var imagePositionPatientZ = dataSet.floatString('x00200032', 2);
  console.log('Image Position Patient (X, Y, Z):', imagePositionPatientX, imagePositionPatientY, imagePositionPatientZ);

  // Getting the number of values for a multi-valued element
  var numValues = dataSet.numStringValues('x00200032');
  console.log('Number of values for Image Position Patient:', numValues);
  for(var i=0; i < numValues; i++) {
    console.log('Value ' + i + ':', dataSet.floatString('x00200032', i));
  }
}
```

**SOP Instance UID Data Offset and Length:**
```javascript
var sopInstanceUidElement = dataSet.elements.x0020000d;
if (sopInstanceUidElement) {
  console.log('SOP Instance UID Data Offset:', sopInstanceUidElement.dataOffset);
  console.log('SOP Instance UID Length:', sopInstanceUidElement.length);
}
```

**SOP Instance UID VR:**
```javascript
var sopInstanceUidElement = dataSet.elements.x0020000d;
if (sopInstanceUidElement) {
  console.log('SOP Instance UID VR:', sopInstanceUidElement.vr);
}
```
```

--------------------------------

### DICOM Helper Functions (JavaScript)

Source: https://github.com/cornerstonejs/dicomparser/blob/master/examples/dumpWithDataDictionary/index.html

Provides utility functions for the DICOM parser. This includes checking if a string contains only ASCII characters, calculating the SHA1 hash of a byte array, mapping UIDs to human-readable names, and escaping special HTML characters for safe display.

```javascript
function isASCII(str) {
    return /^[ -]*$/.test(str);
}

function sha1(byteArray, position, length) {
    position = position || 0;
    length = length || byteArray.length;
    var subArray = dicomParser.sharedCopy(byteArray, position, length);
    return rusha.digest(subArray);
}

function sha1Text(byteArray, position, length) {
    if (showSHA1 === false) {
        return "";
    }
    var text = "; SHA1 " + sha1(byteArray, position, length);
    return text;
}

function mapUid(str) {
    var uid = uids[str];
    if (uid) {
        return ' [ ' + uid + ' ]';
    }
    return '';
}

function escapeSpecialCharacters(str) {
    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
}

function dataDownloadLink(element, text) {
    var linkText = "<a class='dataDownload' href='#' data-tag='" + element.tag + "'";
    linkText += " data-dataOffset='" + element.dataOffset + "'";
    linkText += " data-length='" + element.length + "'";
    linkText += ">" + text + "</a>";
    return linkText;
}
```