inv2dcm 1.0.0__tar.gz

inv2dcm-1.0.0/LICENSE

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

inv2dcm-1.0.0/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: inv2dcm
+Version: 1.0.0
+Summary: Convert InVivo .inv dental CBCT volumes to Enhanced CT DICOM
+Author: mrexodia
+License-Expression: BSL-1.0
+Project-URL: Homepage, https://github.com/mrexodia/inv2dcm
+Project-URL: Repository, https://github.com/mrexodia/inv2dcm
+Project-URL: Issues, https://github.com/mrexodia/inv2dcm/issues
+Keywords: inv,dicom,cbct,cone beam ct,dental imaging,pydicom,enhanced ct,jpeg 2000
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: imagecodecs>=2024.12.30
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: pydicom>=3.0.0
+Dynamic: license-file
+
+# inv2dcm
+
+**inv2dcm** is a Python package and CLI for converting **InVivo `.inv` files** into **Enhanced CT DICOM (`.dcm`)**.
+
+It is built for **dental CBCT / cone beam CT** data associated with **InVivoDentalViewer**, **CliniView**, and **Anatomage** workflows, including scans from systems such as **Instrumentarium Dental ORTHOPANTOMOGRAPH OP 3D Pro**.
+
+The `.inv` files handled here use the **`INVFile`** XML container format, with an `AppendedData` payload containing JPEG 2000-compressed voxel data.
+
+If you are searching for an **INV to DICOM converter**, **InVivo INV file reader**, **dental CBCT to DICOM tool**, **cone beam CT to pydicom**, or a way to convert **`.inv` to 3D Slicer / VolView compatible DICOM**, this package is intended for that use case.
+
+## Features
+
+- Converts proprietary **`.inv`** volume files to **Enhanced CT DICOM**
+- Outputs a **single multi-frame DICOM file**
+- Reads scan metadata from the INV XML header
+- Decodes embedded **JPEG 2000 codestreams** in pure Python via `imagecodecs`
+- Produces output readable by:
+  - `pydicom`
+  - **3D Slicer**
+  - **VolView**
+  - other DICOM-capable medical imaging tools
+- Includes both a Python library API and a CLI command: `inv2dcm`
+
+## Installation
+
+### From source
+
+```bash
+pip install .
+```
+
+### Development install
+
+```bash
+pip install -e .
+```
+
+## CLI usage
+
+After installation, the console script is available as:
+
+```bash
+inv2dcm
+```
+
+### Convert a file
+
+```bash
+inv2dcm scan.inv
+```
+
+This writes `<input-stem>.dcm` next to the source file.
+
+### Convert to a specific output path
+
+```bash
+inv2dcm scan.inv output/scan.dcm
+```
+
+### Control DICOM window metadata
+
+```bash
+inv2dcm scan.inv output/scan.dcm --window auto
+```
+
+Available modes:
+
+- `auto` — derive a sane window center/width from the volume data
+- `source` — preserve the source INV window metadata
+- `none` — omit DICOM window center/width metadata
+
+## Python library usage
+
+`inv2dcm` is importable as a normal Python library, so it is suitable for publishing on **PyPI** and embedding in larger imaging workflows.
+
+### Simple conversion
+
+```python
+from pathlib import Path
+from inv2dcm import convert_inv_to_dicom
+
+convert_inv_to_dicom(Path("scan.inv"), Path("scan.dcm"), window_mode="auto")
+```
+
+### Inspect decoded metadata and volume data
+
+```python
+from pathlib import Path
+from inv2dcm import load_inv
+
+inv = load_inv(Path("scan.inv"))
+print(inv.metadata)
+print(inv.volume.shape)
+```
+
+### Build the `pydicom` dataset yourself
+
+```python
+from pathlib import Path
+from inv2dcm import build_enhanced_ct, load_inv
+
+inv = load_inv(Path("scan.inv"))
+ds = build_enhanced_ct(inv, Path("scan.dcm"))
+print(ds.SOPClassUID)
+print(ds.NumberOfFrames)
+```
+
+### Public API
+
+- `load_inv(path)`
+- `build_enhanced_ct(inv, output_path, window_mode="auto")`
+- `convert_inv_to_dicom(input_path, output_path, window_mode="auto")`
+
+## Verify with pydicom
+
+```python
+import pydicom
+
+ds = pydicom.dcmread("scan.dcm")
+print(ds.NumberOfFrames)
+print(ds.Rows, ds.Columns)
+print(ds.pixel_array.shape)
+```
+
+## View the converted DICOM in the browser
+
+You can drag the generated `.dcm` file directly into **VolView**:
+
+- https://volview.kitware.app/
+
+This is a convenient way to inspect the converted dental CBCT volume in the browser without installing a desktop viewer.
+
+## What kind of INV files are supported?
+
+This project targets **InVivo dental CBCT `.inv` files** using the **`INVFile`** container format.
+
+In practice, that means files with:
+
+- an XML document rooted at `INVFile`
+- bytes that begin with `<INVFile`
+- an `AppendedData` block
+- JPEG 2000 codestream containers storing the voxel data
+
+That matches the structure documented by reverse-engineering work on InVivo / CliniView / Anatomage-related CBCT archives.
+
+## Reverse-engineering references
+
+This package was informed by prior work on the InVivo / CliniView `.inv` format and related dental CBCT tooling:
+
+- holland.sh — **Digital CBCT scans**: https://holland.sh/post/digital-cbct-scans/
+- InvivoConvert: https://github.com/AstrisCantCode/InvivoConvert
+- InvivoExtractor: https://github.com/Bostwickenator/InvivoExtractor
+- Reverse engineering my head: https://dev-with-alex.blogspot.com/2018/03/reverse-engineering-my-head.html
+
+## Output format
+
+The generated DICOM file uses:
+
+- **SOP Class**: Enhanced CT Image Storage
+- **Transfer Syntax**: Explicit VR Little Endian
+- **Photometric Interpretation**: `MONOCHROME2`
+- **Multi-frame volume storage** for easy loading in Python and modern viewers
+
+## Why this package exists
+
+The **`.inv`** format is awkward to use in standard Python medical imaging workflows. `inv2dcm` converts proprietary **InVivo CBCT** data into standard **DICOM** so it can be opened with **pydicom**, reviewed in **3D Slicer**, or inspected in **VolView**.
+
+## Development
+
+The CLI entry point is:
+
+- `inv2dcm` → `inv2dcm.py`
+
+You can also run it directly during development:
+
+```bash
+python inv2dcm.py scan.inv scan.dcm
+```
+
+## Keywords
+
+INV to DICOM, InVivo INV converter, INVFile parser, dental CBCT DICOM converter, cone beam CT DICOM, JPEG 2000 medical imaging, pydicom INV import, InVivoDentalViewer export, CliniView INV parser, Anatomage InVivo, VolView DICOM viewer.

inv2dcm-1.0.0/README.md

@@ -0,0 +1,182 @@
+# inv2dcm
+
+**inv2dcm** is a Python package and CLI for converting **InVivo `.inv` files** into **Enhanced CT DICOM (`.dcm`)**.
+
+It is built for **dental CBCT / cone beam CT** data associated with **InVivoDentalViewer**, **CliniView**, and **Anatomage** workflows, including scans from systems such as **Instrumentarium Dental ORTHOPANTOMOGRAPH OP 3D Pro**.
+
+The `.inv` files handled here use the **`INVFile`** XML container format, with an `AppendedData` payload containing JPEG 2000-compressed voxel data.
+
+If you are searching for an **INV to DICOM converter**, **InVivo INV file reader**, **dental CBCT to DICOM tool**, **cone beam CT to pydicom**, or a way to convert **`.inv` to 3D Slicer / VolView compatible DICOM**, this package is intended for that use case.
+
+## Features
+
+- Converts proprietary **`.inv`** volume files to **Enhanced CT DICOM**
+- Outputs a **single multi-frame DICOM file**
+- Reads scan metadata from the INV XML header
+- Decodes embedded **JPEG 2000 codestreams** in pure Python via `imagecodecs`
+- Produces output readable by:
+  - `pydicom`
+  - **3D Slicer**
+  - **VolView**
+  - other DICOM-capable medical imaging tools
+- Includes both a Python library API and a CLI command: `inv2dcm`
+
+## Installation
+
+### From source
+
+```bash
+pip install .
+```
+
+### Development install
+
+```bash
+pip install -e .
+```
+
+## CLI usage
+
+After installation, the console script is available as:
+
+```bash
+inv2dcm
+```
+
+### Convert a file
+
+```bash
+inv2dcm scan.inv
+```
+
+This writes `<input-stem>.dcm` next to the source file.
+
+### Convert to a specific output path
+
+```bash
+inv2dcm scan.inv output/scan.dcm
+```
+
+### Control DICOM window metadata
+
+```bash
+inv2dcm scan.inv output/scan.dcm --window auto
+```
+
+Available modes:
+
+- `auto` — derive a sane window center/width from the volume data
+- `source` — preserve the source INV window metadata
+- `none` — omit DICOM window center/width metadata
+
+## Python library usage
+
+`inv2dcm` is importable as a normal Python library, so it is suitable for publishing on **PyPI** and embedding in larger imaging workflows.
+
+### Simple conversion
+
+```python
+from pathlib import Path
+from inv2dcm import convert_inv_to_dicom
+
+convert_inv_to_dicom(Path("scan.inv"), Path("scan.dcm"), window_mode="auto")
+```
+
+### Inspect decoded metadata and volume data
+
+```python
+from pathlib import Path
+from inv2dcm import load_inv
+
+inv = load_inv(Path("scan.inv"))
+print(inv.metadata)
+print(inv.volume.shape)
+```
+
+### Build the `pydicom` dataset yourself
+
+```python
+from pathlib import Path
+from inv2dcm import build_enhanced_ct, load_inv
+
+inv = load_inv(Path("scan.inv"))
+ds = build_enhanced_ct(inv, Path("scan.dcm"))
+print(ds.SOPClassUID)
+print(ds.NumberOfFrames)
+```
+
+### Public API
+
+- `load_inv(path)`
+- `build_enhanced_ct(inv, output_path, window_mode="auto")`
+- `convert_inv_to_dicom(input_path, output_path, window_mode="auto")`
+
+## Verify with pydicom
+
+```python
+import pydicom
+
+ds = pydicom.dcmread("scan.dcm")
+print(ds.NumberOfFrames)
+print(ds.Rows, ds.Columns)
+print(ds.pixel_array.shape)
+```
+
+## View the converted DICOM in the browser
+
+You can drag the generated `.dcm` file directly into **VolView**:
+
+- https://volview.kitware.app/
+
+This is a convenient way to inspect the converted dental CBCT volume in the browser without installing a desktop viewer.
+
+## What kind of INV files are supported?
+
+This project targets **InVivo dental CBCT `.inv` files** using the **`INVFile`** container format.
+
+In practice, that means files with:
+
+- an XML document rooted at `INVFile`
+- bytes that begin with `<INVFile`
+- an `AppendedData` block
+- JPEG 2000 codestream containers storing the voxel data
+
+That matches the structure documented by reverse-engineering work on InVivo / CliniView / Anatomage-related CBCT archives.
+
+## Reverse-engineering references
+
+This package was informed by prior work on the InVivo / CliniView `.inv` format and related dental CBCT tooling:
+
+- holland.sh — **Digital CBCT scans**: https://holland.sh/post/digital-cbct-scans/
+- InvivoConvert: https://github.com/AstrisCantCode/InvivoConvert
+- InvivoExtractor: https://github.com/Bostwickenator/InvivoExtractor
+- Reverse engineering my head: https://dev-with-alex.blogspot.com/2018/03/reverse-engineering-my-head.html
+
+## Output format
+
+The generated DICOM file uses:
+
+- **SOP Class**: Enhanced CT Image Storage
+- **Transfer Syntax**: Explicit VR Little Endian
+- **Photometric Interpretation**: `MONOCHROME2`
+- **Multi-frame volume storage** for easy loading in Python and modern viewers
+
+## Why this package exists
+
+The **`.inv`** format is awkward to use in standard Python medical imaging workflows. `inv2dcm` converts proprietary **InVivo CBCT** data into standard **DICOM** so it can be opened with **pydicom**, reviewed in **3D Slicer**, or inspected in **VolView**.
+
+## Development
+
+The CLI entry point is:
+
+- `inv2dcm` → `inv2dcm.py`
+
+You can also run it directly during development:
+
+```bash
+python inv2dcm.py scan.inv scan.dcm
+```
+
+## Keywords
+
+INV to DICOM, InVivo INV converter, INVFile parser, dental CBCT DICOM converter, cone beam CT DICOM, JPEG 2000 medical imaging, pydicom INV import, InVivoDentalViewer export, CliniView INV parser, Anatomage InVivo, VolView DICOM viewer.

inv2dcm-1.0.0/inv2dcm.egg-info/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: inv2dcm
+Version: 1.0.0
+Summary: Convert InVivo .inv dental CBCT volumes to Enhanced CT DICOM
+Author: mrexodia
+License-Expression: BSL-1.0
+Project-URL: Homepage, https://github.com/mrexodia/inv2dcm
+Project-URL: Repository, https://github.com/mrexodia/inv2dcm
+Project-URL: Issues, https://github.com/mrexodia/inv2dcm/issues
+Keywords: inv,dicom,cbct,cone beam ct,dental imaging,pydicom,enhanced ct,jpeg 2000
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: imagecodecs>=2024.12.30
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: pydicom>=3.0.0
+Dynamic: license-file
+
+# inv2dcm
+
+**inv2dcm** is a Python package and CLI for converting **InVivo `.inv` files** into **Enhanced CT DICOM (`.dcm`)**.
+
+It is built for **dental CBCT / cone beam CT** data associated with **InVivoDentalViewer**, **CliniView**, and **Anatomage** workflows, including scans from systems such as **Instrumentarium Dental ORTHOPANTOMOGRAPH OP 3D Pro**.
+
+The `.inv` files handled here use the **`INVFile`** XML container format, with an `AppendedData` payload containing JPEG 2000-compressed voxel data.
+
+If you are searching for an **INV to DICOM converter**, **InVivo INV file reader**, **dental CBCT to DICOM tool**, **cone beam CT to pydicom**, or a way to convert **`.inv` to 3D Slicer / VolView compatible DICOM**, this package is intended for that use case.
+
+## Features
+
+- Converts proprietary **`.inv`** volume files to **Enhanced CT DICOM**
+- Outputs a **single multi-frame DICOM file**
+- Reads scan metadata from the INV XML header
+- Decodes embedded **JPEG 2000 codestreams** in pure Python via `imagecodecs`
+- Produces output readable by:
+  - `pydicom`
+  - **3D Slicer**
+  - **VolView**
+  - other DICOM-capable medical imaging tools
+- Includes both a Python library API and a CLI command: `inv2dcm`
+
+## Installation
+
+### From source
+
+```bash
+pip install .
+```
+
+### Development install
+
+```bash
+pip install -e .
+```
+
+## CLI usage
+
+After installation, the console script is available as:
+
+```bash
+inv2dcm
+```
+
+### Convert a file
+
+```bash
+inv2dcm scan.inv
+```
+
+This writes `<input-stem>.dcm` next to the source file.
+
+### Convert to a specific output path
+
+```bash
+inv2dcm scan.inv output/scan.dcm
+```
+
+### Control DICOM window metadata
+
+```bash
+inv2dcm scan.inv output/scan.dcm --window auto
+```
+
+Available modes:
+
+- `auto` — derive a sane window center/width from the volume data
+- `source` — preserve the source INV window metadata
+- `none` — omit DICOM window center/width metadata
+
+## Python library usage
+
+`inv2dcm` is importable as a normal Python library, so it is suitable for publishing on **PyPI** and embedding in larger imaging workflows.
+
+### Simple conversion
+
+```python
+from pathlib import Path
+from inv2dcm import convert_inv_to_dicom
+
+convert_inv_to_dicom(Path("scan.inv"), Path("scan.dcm"), window_mode="auto")
+```
+
+### Inspect decoded metadata and volume data
+
+```python
+from pathlib import Path
+from inv2dcm import load_inv
+
+inv = load_inv(Path("scan.inv"))
+print(inv.metadata)
+print(inv.volume.shape)
+```
+
+### Build the `pydicom` dataset yourself
+
+```python
+from pathlib import Path
+from inv2dcm import build_enhanced_ct, load_inv
+
+inv = load_inv(Path("scan.inv"))
+ds = build_enhanced_ct(inv, Path("scan.dcm"))
+print(ds.SOPClassUID)
+print(ds.NumberOfFrames)
+```
+
+### Public API
+
+- `load_inv(path)`
+- `build_enhanced_ct(inv, output_path, window_mode="auto")`
+- `convert_inv_to_dicom(input_path, output_path, window_mode="auto")`
+
+## Verify with pydicom
+
+```python
+import pydicom
+
+ds = pydicom.dcmread("scan.dcm")
+print(ds.NumberOfFrames)
+print(ds.Rows, ds.Columns)
+print(ds.pixel_array.shape)
+```
+
+## View the converted DICOM in the browser
+
+You can drag the generated `.dcm` file directly into **VolView**:
+
+- https://volview.kitware.app/
+
+This is a convenient way to inspect the converted dental CBCT volume in the browser without installing a desktop viewer.
+
+## What kind of INV files are supported?
+
+This project targets **InVivo dental CBCT `.inv` files** using the **`INVFile`** container format.
+
+In practice, that means files with:
+
+- an XML document rooted at `INVFile`
+- bytes that begin with `<INVFile`
+- an `AppendedData` block
+- JPEG 2000 codestream containers storing the voxel data
+
+That matches the structure documented by reverse-engineering work on InVivo / CliniView / Anatomage-related CBCT archives.
+
+## Reverse-engineering references
+
+This package was informed by prior work on the InVivo / CliniView `.inv` format and related dental CBCT tooling:
+
+- holland.sh — **Digital CBCT scans**: https://holland.sh/post/digital-cbct-scans/
+- InvivoConvert: https://github.com/AstrisCantCode/InvivoConvert
+- InvivoExtractor: https://github.com/Bostwickenator/InvivoExtractor
+- Reverse engineering my head: https://dev-with-alex.blogspot.com/2018/03/reverse-engineering-my-head.html
+
+## Output format
+
+The generated DICOM file uses:
+
+- **SOP Class**: Enhanced CT Image Storage
+- **Transfer Syntax**: Explicit VR Little Endian
+- **Photometric Interpretation**: `MONOCHROME2`
+- **Multi-frame volume storage** for easy loading in Python and modern viewers
+
+## Why this package exists
+
+The **`.inv`** format is awkward to use in standard Python medical imaging workflows. `inv2dcm` converts proprietary **InVivo CBCT** data into standard **DICOM** so it can be opened with **pydicom**, reviewed in **3D Slicer**, or inspected in **VolView**.
+
+## Development
+
+The CLI entry point is:
+
+- `inv2dcm` → `inv2dcm.py`
+
+You can also run it directly during development:
+
+```bash
+python inv2dcm.py scan.inv scan.dcm
+```
+
+## Keywords
+
+INV to DICOM, InVivo INV converter, INVFile parser, dental CBCT DICOM converter, cone beam CT DICOM, JPEG 2000 medical imaging, pydicom INV import, InVivoDentalViewer export, CliniView INV parser, Anatomage InVivo, VolView DICOM viewer.

inv2dcm-1.0.0/inv2dcm.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+inv2dcm.py
+pyproject.toml
+inv2dcm.egg-info/PKG-INFO
+inv2dcm.egg-info/SOURCES.txt
+inv2dcm.egg-info/dependency_links.txt
+inv2dcm.egg-info/entry_points.txt
+inv2dcm.egg-info/requires.txt
+inv2dcm.egg-info/top_level.txt

inv2dcm-1.0.0/inv2dcm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

inv2dcm-1.0.0/inv2dcm.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+inv2dcm = inv2dcm:main

inv2dcm-1.0.0/inv2dcm.egg-info/requires.txt

@@ -0,0 +1,3 @@
+imagecodecs>=2024.12.30
+numpy>=2.0.0
+pydicom>=3.0.0

inv2dcm-1.0.0/inv2dcm.egg-info/top_level.txt

@@ -0,0 +1 @@
+inv2dcm

inv2dcm-1.0.0/inv2dcm.py

@@ -0,0 +1,563 @@
+from __future__ import annotations
+
+import argparse
+import base64
+import re
+import struct
+import sys
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+import imagecodecs
+import numpy as np
+from pydicom.dataset import Dataset, FileDataset, FileMetaDataset
+from pydicom.sequence import Sequence
+from pydicom.tag import Tag
+from pydicom.uid import ExplicitVRLittleEndian, generate_uid
+
+
+__version__ = "1.0.0"
+__all__ = [
+    "InvMetadata",
+    "InvData",
+    "load_inv",
+    "build_enhanced_ct",
+    "convert_inv_to_dicom",
+    "parse_args",
+    "main",
+]
+
+
+APPENDED_DATA_OPEN_RE = re.compile(br"<AppendedData\b[^>]*>", re.IGNORECASE)
+APPENDED_DATA_CLOSE = b"</AppendedData>"
+IMPLEMENTATION_CLASS_UID = "1.2.826.0.1.3680043.8.498.20260314.1"
+IMPLEMENTATION_VERSION_NAME = "INV2DCM_1"
+ENHANCED_CT_SOP_CLASS_UID = "1.2.840.10008.5.1.4.1.1.2.1"
+
+
+def format_ds(value: float | int | str) -> str:
+    if isinstance(value, str):
+        return value
+    return format(value, ".12g")
+
+
+@dataclass(slots=True)
+class InvMetadata:
+    patient_name: str
+    patient_id: str
+    patient_birth_date: str
+    study_date: str
+    study_time: str
+    modality: str
+    manufacturer: str
+    model_name: str
+    device_serial_number: str
+    patient_position: str
+    kvp: str
+    image_type: list[str]
+    study_instance_uid: str
+    series_instance_uid: str
+    frame_of_reference_uid: str
+    sop_instance_uid: str
+    sop_class_uid: str
+    scalar_type: str
+    dimensions: tuple[int, int, int]
+    pixel_spacing: tuple[float, float]
+    slice_spacing: float
+    origin: tuple[float, float, float]
+    image_orientation_patient: tuple[float, float, float, float, float, float]
+    samples_per_pixel: int
+    photometric_interpretation: str
+    bits_allocated: int
+    bits_stored: int
+    high_bit: int
+    pixel_representation: int
+    rescale_intercept: float
+    rescale_slope: float
+    rescale_type: str
+    window_width: float | None
+    window_center: float | None
+
+
+@dataclass(slots=True)
+class InvData:
+    metadata: InvMetadata
+    volume: np.ndarray
+
+
+def decode_length_prefixed_text(binary_value: str | None) -> str:
+    if not binary_value:
+        return ""
+
+    raw = base64.b64decode(binary_value)
+    if len(raw) >= 4:
+        declared_size = struct.unpack_from("<I", raw, 0)[0]
+        raw = raw[4 : 4 + declared_size]
+
+    for encoding in ("utf-8", "cp1250", "cp1252", "latin1"):
+        try:
+            return raw.decode(encoding).strip("\x00 ")
+        except UnicodeDecodeError:
+            continue
+
+    return raw.decode("latin1", errors="replace").strip("\x00 ")
+
+
+def clean_text(value: str | None) -> str:
+    if not value:
+        return ""
+    return value.replace("\x00", "").strip()
+
+
+def split_numbers(value: str | None) -> list[str]:
+    cleaned = clean_text(value)
+    if not cleaned:
+        return []
+    return [part for part in re.split(r"[\\\s,]+", cleaned) if part]
+
+
+def parse_ints(value: str | None) -> tuple[int, ...]:
+    return tuple(int(part) for part in split_numbers(value))
+
+
+def parse_floats(value: str | None) -> tuple[float, ...]:
+    return tuple(float(part) for part in split_numbers(value))
+
+
+def get_element(root: ET.Element, tag: str) -> ET.Element | None:
+    return root.find(f".//{tag}")
+
+
+def get_value(root: ET.Element, tag: str, *, binary_first: bool = False) -> str:
+    element = get_element(root, tag)
+    if element is None:
+        return ""
+
+    value_attr = clean_text(element.attrib.get("Value"))
+    binary_attr = clean_text(element.attrib.get("BinaryValue"))
+
+    if binary_first:
+        decoded = decode_length_prefixed_text(binary_attr)
+        return clean_text(decoded or value_attr)
+
+    return value_attr or clean_text(decode_length_prefixed_text(binary_attr))
+
+
+def parse_patient_name(raw_name: str) -> str:
+    raw_name = clean_text(raw_name)
+    if not raw_name:
+        return "Anonymous"
+    if "^" in raw_name:
+        return raw_name
+    if "," in raw_name:
+        family_name, given_name = raw_name.split(",", 1)
+        return f"{family_name}^{given_name}"
+    return raw_name
+
+
+def parse_inv_file(path: Path) -> tuple[ET.Element, bytes]:
+    data = path.read_bytes()
+
+    stripped = data.lstrip(b"\xef\xbb\xbf\r\n\t ")
+    if not stripped.startswith(b"<INVFile"):
+        raise ValueError(f"{path} does not start with <INVFile")
+
+    match = APPENDED_DATA_OPEN_RE.search(data)
+    if match is None:
+        raise ValueError(f"Could not find <AppendedData> in {path}")
+
+    raw_start = match.end()
+    raw_end = data.index(APPENDED_DATA_CLOSE, raw_start)
+    appended = data[raw_start:raw_end]
+
+    xml_bytes = data[:raw_start] + APPENDED_DATA_CLOSE + data[raw_end + len(APPENDED_DATA_CLOSE) :]
+    root = ET.fromstring(xml_bytes)
+    return root, appended
+
+
+def parse_metadata(root: ET.Element) -> InvMetadata:
+    volume_element = get_element(root, "Volume")
+    if volume_element is None:
+        raise ValueError("INV XML is missing the <Volume> element")
+
+    dimensions = parse_ints(volume_element.attrib.get("Dimensions"))
+    if len(dimensions) != 3:
+        raise ValueError(f"Unexpected volume dimensions: {volume_element.attrib.get('Dimensions')!r}")
+
+    spacing = parse_floats(volume_element.attrib.get("Spacing"))
+    if len(spacing) != 3:
+        raise ValueError(f"Unexpected volume spacing: {volume_element.attrib.get('Spacing')!r}")
+
+    origin = parse_floats(volume_element.attrib.get("Origin"))
+    if len(origin) != 3:
+        origin = (0.0, 0.0, 0.0)
+
+    scalar_type = clean_text(volume_element.attrib.get("ScalarType")) or "UInt16"
+
+    window_level = parse_floats(volume_element.attrib.get("WindowLevel"))
+    window_width = window_level[0] if len(window_level) >= 1 else None
+    window_center = window_level[1] if len(window_level) >= 2 else None
+
+    image_type = split_numbers(get_value(root, "ImageType"))
+    if not image_type:
+        image_type = ["ORIGINAL", "PRIMARY", "VOLUME", "NONE"]
+
+    orientation = parse_floats(get_value(root, "ImageOrientationPatient"))
+    if len(orientation) != 6:
+        orientation = (1.0, 0.0, 0.0, 0.0, 1.0, 0.0)
+
+    pixel_spacing = parse_floats(get_value(root, "PixelSpacing"))
+    if len(pixel_spacing) != 2:
+        pixel_spacing = spacing[:2]
+
+    patient_birth_date = clean_text(get_value(root, "PatientBirthDay", binary_first=True))
+    if not patient_birth_date:
+        patient_birth_date = clean_text(get_value(root, "PatientBirthDate", binary_first=True))
+
+    bits_allocated = int(clean_text(get_value(root, "BitsAllocated")) or 16)
+    bits_stored = int(clean_text(get_value(root, "BitsStore")) or 16)
+    high_bit = int(clean_text(get_value(root, "HighBit")) or (bits_stored - 1))
+    pixel_representation = 1 if scalar_type.lower() == "int16" else 0
+
+    rescale_intercept_text = clean_text(get_value(root, "RescaleIntercept"))
+    rescale_slope_text = clean_text(get_value(root, "RescaleSlope"))
+    rescale_type = clean_text(get_value(root, "RescaleType"))
+
+    return InvMetadata(
+        patient_name=parse_patient_name(get_value(root, "PatientName", binary_first=True)),
+        patient_id=clean_text(get_value(root, "PatientID", binary_first=True)),
+        patient_birth_date=patient_birth_date,
+        study_date=clean_text(get_value(root, "StudyDate")),
+        study_time=clean_text(get_value(root, "StudyTime")),
+        modality=clean_text(get_value(root, "Modality")) or "CT",
+        manufacturer=clean_text(get_value(root, "Manufacture")) or "Unknown",
+        model_name=clean_text(get_value(root, "MaufacturModelName")) or clean_text(get_value(root, "ManufacturerModelName")),
+        device_serial_number=clean_text(get_value(root, "DeviceSerialNumber")),
+        patient_position=clean_text(get_value(root, "PatientPostion")) or clean_text(get_value(root, "PatientPosition")) or "HFS",
+        kvp=clean_text(get_value(root, "KV")),
+        image_type=image_type,
+        study_instance_uid=clean_text(get_value(root, "StudyInstanceUID")) or generate_uid(),
+        series_instance_uid=clean_text(get_value(root, "SeriesInstanceUID")) or generate_uid(),
+        frame_of_reference_uid=clean_text(get_value(root, "FrameOfReferenceUID")) or generate_uid(),
+        sop_instance_uid=clean_text(get_value(root, "SOPInstanceUID")) or generate_uid(),
+        sop_class_uid=clean_text(get_value(root, "SOPClassUID")) or ENHANCED_CT_SOP_CLASS_UID,
+        scalar_type=scalar_type,
+        dimensions=(dimensions[0], dimensions[1], dimensions[2]),
+        pixel_spacing=(pixel_spacing[0], pixel_spacing[1]),
+        slice_spacing=float(spacing[2]),
+        origin=(float(origin[0]), float(origin[1]), float(origin[2])),
+        image_orientation_patient=(
+            float(orientation[0]),
+            float(orientation[1]),
+            float(orientation[2]),
+            float(orientation[3]),
+            float(orientation[4]),
+            float(orientation[5]),
+        ),
+        samples_per_pixel=int(clean_text(get_value(root, "SamplePerPixel")) or 1),
+        photometric_interpretation=clean_text(get_value(root, "PhotometricInterpretation")) or "MONOCHROME2",
+        bits_allocated=bits_allocated,
+        bits_stored=bits_stored,
+        high_bit=high_bit,
+        pixel_representation=pixel_representation,
+        rescale_intercept=float(rescale_intercept_text or 0),
+        rescale_slope=float(rescale_slope_text or 1),
+        rescale_type=rescale_type,
+        window_width=window_width,
+        window_center=window_center,
+    )
+
+
+def parse_appended_volume(appended: bytes, expected_frames: int, scalar_type: str = "UInt16") -> np.ndarray:
+    if len(appended) < 16:
+        raise ValueError("AppendedData is too small to contain a valid header")
+
+    magic, container_count, components_per_container, components_in_last = struct.unpack_from("<IIII", appended, 0)
+    if magic != 0x5F202020:
+        raise ValueError(f"Unexpected AppendedData magic: 0x{magic:08x}")
+    if container_count == 0:
+        raise ValueError("No JPEG 2000 containers found in AppendedData")
+
+    header_size = 16 + 4 * container_count
+    if len(appended) < header_size:
+        raise ValueError("AppendedData ends inside the JPEG 2000 size table")
+
+    codestream_sizes = struct.unpack_from(f"<{container_count}I", appended, 16)
+    offset = header_size
+    frames: list[np.ndarray] = []
+
+    for index, codestream_size in enumerate(codestream_sizes, start=1):
+        codestream = appended[offset : offset + codestream_size]
+        if len(codestream) != codestream_size:
+            raise ValueError(f"JPEG 2000 container {index} is truncated")
+
+        decoded = imagecodecs.jpeg2k_decode(codestream)
+        decoded = np.asarray(decoded)
+
+        if decoded.ndim == 2:
+            decoded = decoded[np.newaxis, :, :]
+        elif decoded.ndim == 3:
+            decoded = np.moveaxis(decoded, -1, 0)
+        else:
+            raise ValueError(f"Unexpected decoded shape for container {index}: {decoded.shape}")
+
+        frames.append(np.asarray(decoded, dtype=np.uint16))
+        offset += codestream_size
+
+    volume = np.concatenate(frames, axis=0)
+
+    expected_from_header = (container_count - (1 if components_in_last else 0)) * components_per_container + components_in_last
+    if volume.shape[0] != expected_from_header:
+        raise ValueError(
+            "Decoded frame count does not match AppendedData header: "
+            f"decoded={volume.shape[0]}, header={expected_from_header}"
+        )
+    if volume.shape[0] != expected_frames:
+        raise ValueError(
+            f"Decoded frame count does not match XML dimensions: decoded={volume.shape[0]}, xml={expected_frames}"
+        )
+
+    if scalar_type.lower() == "int16":
+        volume = volume.view(np.int16)
+    elif scalar_type.lower() == "uint16":
+        volume = volume.view(np.uint16)
+
+    return np.ascontiguousarray(volume)
+
+
+def load_inv(path: Path) -> InvData:
+    root, appended = parse_inv_file(path)
+    metadata = parse_metadata(root)
+    volume = parse_appended_volume(appended, metadata.dimensions[2], metadata.scalar_type)
+
+    expected_rows = metadata.dimensions[1]
+    expected_cols = metadata.dimensions[0]
+    if volume.shape != (metadata.dimensions[2], expected_rows, expected_cols):
+        raise ValueError(
+            "Decoded volume shape does not match XML dimensions: "
+            f"decoded={volume.shape}, xml={(metadata.dimensions[2], expected_rows, expected_cols)}"
+        )
+
+    return InvData(metadata=metadata, volume=volume)
+
+
+def choose_window(inv: InvData, mode: str) -> tuple[float | None, float | None]:
+    meta = inv.metadata
+
+    if mode == "none":
+        return None, None
+    if mode == "source":
+        return meta.window_center, meta.window_width
+    if mode != "auto":
+        raise ValueError(f"Unsupported window mode: {mode}")
+
+    values = inv.volume.astype(np.float32) * float(meta.rescale_slope) + float(meta.rescale_intercept)
+    low = float(np.percentile(values, 1.0))
+    high = float(np.percentile(values, 99.5))
+    if not np.isfinite(low) or not np.isfinite(high) or high <= low:
+        return meta.window_center, meta.window_width
+
+    center = (low + high) / 2.0
+    width = max(high - low, 1.0)
+    return center, width
+
+
+def build_enhanced_ct(inv: InvData, output_path: Path, *, window_mode: str = "auto") -> FileDataset:
+    meta = inv.metadata
+    volume = inv.volume
+    frame_count, rows, cols = volume.shape
+    window_center, window_width = choose_window(inv, window_mode)
+
+    file_meta = FileMetaDataset()
+    file_meta.FileMetaInformationVersion = b"\x00\x01"
+    file_meta.MediaStorageSOPClassUID = ENHANCED_CT_SOP_CLASS_UID
+    file_meta.MediaStorageSOPInstanceUID = meta.sop_instance_uid or generate_uid()
+    file_meta.TransferSyntaxUID = ExplicitVRLittleEndian
+    file_meta.ImplementationClassUID = IMPLEMENTATION_CLASS_UID
+    file_meta.ImplementationVersionName = IMPLEMENTATION_VERSION_NAME
+
+    ds = FileDataset(str(output_path), {}, file_meta=file_meta, preamble=b"\x00" * 128)
+    ds.is_implicit_VR = False
+    ds.is_little_endian = True
+
+    ds.SpecificCharacterSet = "ISO_IR 192"
+
+    ds.PatientName = meta.patient_name or "Anonymous"
+    ds.PatientID = meta.patient_id or "UNKNOWN"
+    if meta.patient_birth_date:
+        ds.PatientBirthDate = meta.patient_birth_date
+
+    ds.StudyDate = meta.study_date
+    ds.StudyTime = meta.study_time
+    ds.SeriesDate = meta.study_date
+    ds.ContentDate = meta.study_date
+    ds.SeriesTime = meta.study_time
+    ds.ContentTime = meta.study_time
+    ds.AccessionNumber = ""
+    ds.ReferringPhysicianName = ""
+    ds.StudyInstanceUID = meta.study_instance_uid
+    ds.StudyID = "1"
+
+    ds.Modality = meta.modality or "CT"
+    ds.SeriesInstanceUID = meta.series_instance_uid
+    ds.SeriesNumber = 1
+    ds.InstanceNumber = 1
+
+    ds.ImageType = meta.image_type
+    ds.FrameOfReferenceUID = meta.frame_of_reference_uid
+    ds.PositionReferenceIndicator = ""
+
+    ds.Manufacturer = meta.manufacturer or "Unknown"
+    if meta.model_name:
+        ds.ManufacturerModelName = meta.model_name
+    if meta.device_serial_number:
+        ds.DeviceSerialNumber = meta.device_serial_number
+    ds.SoftwareVersions = ["inv2dcm"]
+
+    ds.PatientPosition = meta.patient_position or "HFS"
+    ds.BurnedInAnnotation = "NO"
+    ds.LossyImageCompression = "00"
+
+    ds.SamplesPerPixel = meta.samples_per_pixel
+    ds.PhotometricInterpretation = meta.photometric_interpretation
+    ds.Rows = rows
+    ds.Columns = cols
+    ds.BitsAllocated = meta.bits_allocated
+    ds.BitsStored = meta.bits_stored
+    ds.HighBit = meta.high_bit
+    ds.PixelRepresentation = meta.pixel_representation
+    ds.NumberOfFrames = str(frame_count)
+
+    ds.ImageOrientationPatient = [format_ds(value) for value in meta.image_orientation_patient]
+    ds.PixelSpacing = [format_ds(meta.pixel_spacing[0]), format_ds(meta.pixel_spacing[1])]
+    ds.SliceThickness = format_ds(meta.slice_spacing)
+    ds.SpacingBetweenSlices = format_ds(meta.slice_spacing)
+
+    ds.RescaleIntercept = format_ds(meta.rescale_intercept)
+    ds.RescaleSlope = format_ds(meta.rescale_slope)
+    if meta.rescale_type:
+        ds.RescaleType = meta.rescale_type
+    if meta.kvp:
+        ds.KVP = meta.kvp
+    if window_center is not None:
+        ds.WindowCenter = format_ds(window_center)
+    if window_width is not None:
+        ds.WindowWidth = format_ds(window_width)
+
+    ds.SOPClassUID = ENHANCED_CT_SOP_CLASS_UID
+    ds.SOPInstanceUID = file_meta.MediaStorageSOPInstanceUID
+
+    dimension_organization_uid = generate_uid()
+    dim_org = Dataset()
+    dim_org.DimensionOrganizationUID = dimension_organization_uid
+    ds.DimensionOrganizationSequence = Sequence([dim_org])
+
+    dim_index = Dataset()
+    dim_index.DimensionOrganizationUID = dimension_organization_uid
+    dim_index.DimensionIndexPointer = Tag(0x0020, 0x0032)
+    dim_index.FunctionalGroupPointer = Tag(0x0020, 0x9113)
+    dim_index.DimensionDescriptionLabel = "Image Position Patient Z"
+    ds.DimensionIndexSequence = Sequence([dim_index])
+
+    shared = Dataset()
+
+    pixel_measures = Dataset()
+    pixel_measures.PixelSpacing = [format_ds(meta.pixel_spacing[0]), format_ds(meta.pixel_spacing[1])]
+    pixel_measures.SliceThickness = format_ds(meta.slice_spacing)
+    pixel_measures.SpacingBetweenSlices = format_ds(meta.slice_spacing)
+    shared.PixelMeasuresSequence = Sequence([pixel_measures])
+
+    plane_orientation = Dataset()
+    plane_orientation.ImageOrientationPatient = [format_ds(value) for value in meta.image_orientation_patient]
+    shared.PlaneOrientationSequence = Sequence([plane_orientation])
+
+    ct_frame_type = Dataset()
+    ct_frame_type.FrameType = meta.image_type
+    ct_frame_type.PixelPresentation = "MONOCHROME"
+    ct_frame_type.VolumetricProperties = "VOLUME"
+    ct_frame_type.VolumeBasedCalculationTechnique = "NONE"
+    shared.CTImageFrameTypeSequence = Sequence([ct_frame_type])
+
+    pixel_value_transform = Dataset()
+    pixel_value_transform.RescaleIntercept = format_ds(meta.rescale_intercept)
+    pixel_value_transform.RescaleSlope = format_ds(meta.rescale_slope)
+    if meta.rescale_type:
+        pixel_value_transform.RescaleType = meta.rescale_type
+    shared.PixelValueTransformationSequence = Sequence([pixel_value_transform])
+
+    if window_center is not None and window_width is not None:
+        frame_voi_lut = Dataset()
+        frame_voi_lut.WindowCenter = format_ds(window_center)
+        frame_voi_lut.WindowWidth = format_ds(window_width)
+        shared.FrameVOILUTSequence = Sequence([frame_voi_lut])
+
+    ds.SharedFunctionalGroupsSequence = Sequence([shared])
+
+    per_frame_items: list[Dataset] = []
+    origin_x, origin_y, origin_z = meta.origin
+    for frame_index in range(frame_count):
+        frame_group = Dataset()
+
+        plane_position = Dataset()
+        plane_position.ImagePositionPatient = [
+            format_ds(origin_x),
+            format_ds(origin_y),
+            format_ds(origin_z + frame_index * meta.slice_spacing),
+        ]
+        frame_group.PlanePositionSequence = Sequence([plane_position])
+
+        frame_content = Dataset()
+        frame_content.FrameAcquisitionNumber = frame_index + 1
+        frame_content.DimensionIndexValues = [frame_index + 1]
+        frame_group.FrameContentSequence = Sequence([frame_content])
+
+        per_frame_items.append(frame_group)
+
+    ds.PerFrameFunctionalGroupsSequence = Sequence(per_frame_items)
+    ds.PixelData = np.asarray(volume, dtype="<u2", order="C").tobytes()
+    return ds
+
+
+def convert_inv_to_dicom(input_path: Path, output_path: Path, *, window_mode: str = "auto") -> Path:
+    inv = load_inv(input_path)
+    ds = build_enhanced_ct(inv, output_path, window_mode=window_mode)
+    ds.save_as(output_path, enforce_file_format=True)
+    return output_path
+
+
+def parse_args(argv: Iterable[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Convert an InVivo .inv CBCT file to an Enhanced CT DICOM file.")
+    parser.add_argument("input", help="Path to the .inv file.")
+    parser.add_argument("output", nargs="?", help="Output .dcm path. Defaults to <input-stem>.dcm")
+    parser.add_argument(
+        "--window",
+        choices=("auto", "source", "none"),
+        default="auto",
+        help="How to write DICOM window center/width metadata. Default: auto.",
+    )
+    return parser.parse_args(list(argv) if argv is not None else None)
+
+
+def main(argv: Iterable[str] | None = None) -> int:
+    try:
+        args = parse_args(argv)
+        input_path = Path(args.input)
+        output_path = Path(args.output) if args.output else input_path.with_suffix(".dcm")
+
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        convert_inv_to_dicom(input_path, output_path, window_mode=args.window)
+    except KeyboardInterrupt:
+        print("Cancelled.", file=sys.stderr)
+        return 130
+    except Exception as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+
+    print(f"Converted {input_path} -> {output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

inv2dcm-1.0.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "inv2dcm"
+version = "1.0.0"
+description = "Convert InVivo .inv dental CBCT volumes to Enhanced CT DICOM"
+readme = "README.md"
+license = "BSL-1.0"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [
+    { name = "mrexodia" },
+]
+keywords = [
+    "inv",
+    "dicom",
+    "cbct",
+    "cone beam ct",
+    "dental imaging",
+    "pydicom",
+    "enhanced ct",
+    "jpeg 2000",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Medical Science Apps.",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "imagecodecs>=2024.12.30",
+    "numpy>=2.0.0",
+    "pydicom>=3.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/mrexodia/inv2dcm"
+Repository = "https://github.com/mrexodia/inv2dcm"
+Issues = "https://github.com/mrexodia/inv2dcm/issues"
+
+[project.scripts]
+inv2dcm = "inv2dcm:main"
+
+[tool.setuptools]
+py-modules = ["inv2dcm"]

inv2dcm-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+