PyTomography

https://pytomography.readthedocs.io/en/latest/
Admin
PyTomography is a Python library for tomographic reconstruction of medical imaging data with...
Tokens:724,202
Snippets:6,925
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### StarGuide Configuration Example

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_starguide.ipynb.txt

Provides an example of how to configure StarGuide with specific parameters. This is useful for customizing data loading and processing behavior.

```python
from pytomography.io. thị trường import StarGuide

# Configure StarGuide with custom parameters
config = {
    "parameter1": "value1",
    "parameter2": 123
}
data = StarGuide(path="/path/to/your/data", config=config)

# Process data with the applied configuration
processed_data = data.process()
print("StarGuide configured and data processed.")
```

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

### T-Star Pathfinding Example

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_starguide.ipynb.txt

This snippet demonstrates a basic implementation of the T-Star pathfinding algorithm. It requires the 'tstar' library to be installed.

```python
from tstar.tstar import TStar

# Example usage (assuming a grid and start/goal points are defined)
# grid = ...
# start = (x, y)
# goal = (x, y)
# tstar = TStar(grid)
# path = tstar.search(start, goal)
# print(path)
```

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

### Example of Data Loading and Processing

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_spect_mc2.ipynb.txt

A concrete example demonstrating how to load spectrogram data from a file and then process it using the library's functions.

```python
spectrogram_data = load_spectrogram("/path/to/your/spectrogram.dat")
processed_data = process_spectrogram(spectrogram_data)
```

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

### Basic Plotting Example

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_plotting.ipynb.txt

Demonstrates a fundamental plotting operation. Ensure necessary libraries are imported before execution.

```python
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.figure(figsize=(8, 6))
plt.plot(x, y, label='sin(x)')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Simple Sine Wave Plot')
plt.legend()
plt.grid(True)
plt.show()
```

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

### Get TomoPy Version

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_siminddata.ipynb.txt

Retrieves the installed version of the TomoPy library.

```python
import tomopy

print(tomopy.__version__)
```

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

### StarGuideProjMeta Initialization

Source: https://pytomography.readthedocs.io/en/latest/_modules/pytomography/metadata/SPECT/starguide_metadata.html

Initializes the StarGuideProjMeta object with projection shape, angles, and optional acquisition parameters.

```APIDOC
## StarGuideProjMeta

### Description
Metadtata for the StarGuide SPECT imaging system.

### Parameters
#### Args
- **projection_shape** (Sequence) - Shape of the projection data (number of angles, width, height).
- **angles** (Sequence) - Angle of each projection.
- **times** (Sequence, optional) - Acquisition time for each projection.
- **offsets** (Sequence, optional) - Offset of each projection (in axial direction).
- **radii** (Sequence | None, optional) - Radial distance from center of each projection; needed for PSF modeling. Defaults to None.

### Attributes
- **angles** (Sequence)
- **radii** (Sequence | None)
- **offsets** (Sequence | None)
- **times** (Sequence | None)
- **num_projections** (int)
- **shape** (Sequence)
```

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

### Example Uncertainty Output

Source: https://pytomography.readthedocs.io/en/latest/notebooks/t_uncertainty_spect.html

Example output showing the estimated uncertainty for the 'kidney_left' mask.

```text
Estimated uncertainty in kidney_left: 0.94%
```

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

### Forward Projection Example

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_examplesystemmatrix.ipynb.txt

Demonstrates the initial step of a forward projection by summing a sample 3D object along its x-axis to obtain a 2D projection. Assumes `object_meta` is defined.

```python
sample_object = torch.rand(object_meta.shape) 
# Sum object along x to get projection at 0 degrees

```

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

### Instantiate and Use System Matrix

Source: https://pytomography.readthedocs.io/en/latest/notebooks/t_examplesystemmatrix.html

Demonstrates the instantiation of EXSListmodeSystemMatrix and its usage by performing a forward projection on a randomly generated sample object.

```python
system_matrix = EXSListmodeSystemMatrix(object_meta=object_meta, proj_meta=proj_meta_listmode)
sample_object = torch.rand(object_meta.shape) # object has batch dimension
sample_projections = system_matrix.forward(sample_object)
sample_projections
```

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

### Example Uncertainty Output

Source: https://pytomography.readthedocs.io/en/latest/notebooks/t_uncertainty_pet.html

Example output showing the estimated uncertainty percentage for a large sphere.

```text
Estimated uncertainty in large sphere: 1.63%
```

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

### Initialize StarGuide

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_starguide.ipynb.txt

Initializes the StarGuide object. Ensure all necessary libraries are imported before use.

```python
from pytomography.algorithms.sparse_tomography import StarGuide
from pytomography.utils.math import get_random_sparse_matrix
import numpy as np
```

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

### Install PyTomography via Pip

Source: https://pytomography.readthedocs.io/en/latest/_sources/install.rst.txt

Install the PyTomography package using pip after activating the environment.

```bash
pip install pytomography
```

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

### Instantiate and Use Listmode System Matrix

Source: https://pytomography.readthedocs.io/en/latest/notebooks/t_examplesystemmatrix.html

Demonstrates how to instantiate the EXSListmodeSystemMatrix with object and projection metadata, generate a random sample object, and perform forward and backward projections.

```python
system_matrix = EXSListmodeSystemMatrix(object_meta=object_meta, proj_meta=proj_meta_listmode)
sample_object = torch.rand(object_meta.shape) # object has batch dimension
FP = system_matrix.forward(sample_object)
BP = system_matrix.backward(FP)

```

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

### Install Parallelproj and Dependencies

Source: https://pytomography.readthedocs.io/en/latest/_sources/install.rst.txt

Install parallelproj and its GPU-enabled dependencies for PET/CT reconstruction. Ensure the pytomography_env is activated.

```bash
conda activate pytomography_env
conda install -c conda-forge libparallelproj parallelproj cupy
```

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

### Install Parallelproj and Dependencies for PET/CT

Source: https://pytomography.readthedocs.io/en/latest/install.html

For PET/CT reconstruction, install parallelproj, cupy, and libparallelproj from conda-forge. Ensure the pytomography_env is activated.

```bash
conda activate pytomography_env
conda install -c conda-forge libparallelproj parallelproj cupy

```

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

### Initialize StarGuide Project Metadata

Source: https://pytomography.readthedocs.io/en/latest/_modules/pytomography/metadata/SPECT/starguide_metadata.html

Use this class to initialize metadata for the StarGuide SPECT imaging system. It requires projection shape and angles, with optional parameters for acquisition times, offsets, and radii.

```python
from __future__ import annotations
from pytomography.metadata import ProjMeta
from typing import Sequence


[docs]
class StarGuideProjMeta(ProjMeta):
    def __init__(
        self,
        projection_shape: Sequence,
        angles: Sequence,
        times=None,
        offsets=None,
        radii: Sequence | None = None
    ) -> None:
        """Metadtata for the StarGuide SPECT imaging system.

        Args:
            projection_shape (Sequence): Shape of the projection data (number of angles, width, height).
            angles (Sequence): Angle of each projection.
            times (Sequence, optional): Acquisition time for each projection. 
            offsets (Sequence, optional): Offset of each projection (in axial direction).
            radii (Sequence, optional): Radial distance from center of each projection; needed for PSF modeling. Defaults to None.
        """ 
        self.angles = angles
        self.radii = radii
        self.offsets = offsets
        self.times = times
        self.num_projections = len(angles)
        self.shape = projection_shape

```

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

### Load and Process Data with StarGuide

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_starguide.ipynb.txt

Demonstrates loading and processing data using StarGuide's core functionalities. Ensure necessary libraries are imported.

```python
from pytomography.io. thị trường import StarGuide

# Load data from a specified path
data = StarGuide(path="/path/to/your/data")

# Process the loaded data
processed_data = data.process()
print(processed_data)
```

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

### Get Weighting Subset

Source: https://pytomography.readthedocs.io/en/latest/_modules/pytomography/projectors/system_matrix.html

Retrieves the weighting for a specific subset of projections. It uses the first system matrix to get the weighting subset.

```python
def get_weighting_subset(
        self,
        subset_idx: int
    ) -> torch.tensor:
        return self.system_matrices[0].get_weighting_subset(subset_idx)
```

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

### Get Projection Subset

Source: https://pytomography.readthedocs.io/en/latest/_modules/pytomography/projectors/system_matrix.html

Retrieves a specific subset of projections from the system. It uses the first system matrix to get the projection subset.

```python
def get_projection_subset(
        self,
        projections: torch.tensor,
        subset_idx: int
    ) -> torch.tensor:
        return self.system_matrices[0].get_projection_subset(projections, subset_idx)
```

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

### Initialize System Matrix, Likelihood, and OSEM Algorithm

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_examplesystemmatrix.ipynb.txt

Initializes the EXSSystemMatrix, NegativeMSELikelihood, and OSEM reconstruction algorithm. Requires object_meta, proj_meta, and sample_projections to be defined.

```python
system_matrix = EXSSystemMatrix(object_meta=object_meta, proj_meta=proj_meta)
likelihood = NegativeMSELikelihood(system_matrix, projections=sample_projections, scaling_constant=0.01)
reconstruction_algorithm = OSEM(likelihood)
```

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

### StarGuide Data Export Example

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_starguide.ipynb.txt

Demonstrates exporting processed data from StarGuide to a file. This is useful for saving results or sharing data.

```python
from pytomography.io. thị trường import StarGuide

# Assuming 'processed_data' is already loaded and processed
# Example: data = StarGuide(path="/path/to/your/data").process()

# Export the processed data to a file
StarGuide.export(processed_data, "/path/to/output/file.csv")
print("Data exported successfully.")
```

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

### TimeInterval Class Definition

Source: https://pytomography.readthedocs.io/en/latest/_modules/pytomography/io/PET/prd/types.html

Defines a time interval with start and stop times in milliseconds since acquisition start. Used to represent time frames.

```python
class TimeInterval:
    """Time interval in milliseconds since start of acquisition"""

    start: yardl.UInt32
    stop: yardl.UInt32

    def __init__(self, *,
        start: yardl.UInt32 = 0,
        stop: yardl.UInt32 = 0,
    ):
        self.start = start
        self.stop = stop


[docs]    def __eq__(self, other: object) -> bool:
        return (
            isinstance(other, TimeInterval)
            and self.start == other.start
            and self.stop == other.stop
        )



[docs]    def __str__(self) -> str:
        return f"TimeInterval(start={self.start}, stop={self.stop})"



[docs]    def __repr__(self) -> str:
        return f"TimeInterval(start={repr(self.start)}, stop={repr(self.stop)})"
```

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

### Initialize StarGuide with Sparse Matrix

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_starguide.ipynb.txt

Initializes the StarGuide object with a pre-generated sparse matrix `A`. This is useful when you have specific matrix structures to work with.

```python
starguide = StarGuide(A)
```

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

### Get PET PRD Data Type Function

Source: https://pytomography.readthedocs.io/en/latest/_modules/pytomography/io/PET/prd/types.html

Retrieves the configured function for getting NumPy dtypes, which is used internally for defining the structure of PET PRD data.

```python
get_dtype = _mk_get_dtype()
```

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

### Set Save Path for Tutorial Data

Source: https://pytomography.readthedocs.io/en/latest/notebooks/t_plotting.html

Specifies the directory where tutorial data is stored. Ensure this path is correctly set to your download location.

```python
save_path = '/disk1/pytomography_tutorial_data'
```

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

### Implement Subset Handling Methods in EXSSystemMatrix

Source: https://pytomography.readthedocs.io/en/latest/notebooks/t_examplesystemmatrix.html

Extends EXSSystemMatrix to include methods for setting the number of subsets, getting projection subsets, computing subset-specific normalization factors, and getting subset weightings.

```python
class EXSSystemMatrix(SystemMatrix):
    # ----
    # NEW METHODS
    # ----
    def set_n_subsets(self, n_subsets):
        self.n_subsets = n_subsets
    def get_projection_subset(self, projections, subset_idx):
        # Called when n_subsets>1 in internal pytomography code, in this case, assumes 2 subsets since thats the only possible number of subsets we have. In general, this should split data evenly (see SPECTSystemMatrix source code)
        return projections[subset_idx].unsqueeze(0)
    def compute_normalization_factor(self, subset_idx = None):
        # This function generally looks the same for all system matrices
        norm_projections = torch.ones((2,self.proj_meta.M, self.proj_meta.M))
        if subset_idx is not None:
            norm_projections = self.get_projection_subset(norm_projections, subset_idx)
        return self.backward(norm_projections, subset_idx)
    def get_weighting_subset(self, subset_idx):
        if subset_idx is None:
            return 1
        elif self.n_subsets==2:
            return 0.5 # equal weighting in this case, in general need to be careful with this
    # ----
    # SAME AS PREVIOUS
    # ----
    def forward(self, object, subset_idx = None):
        projection_0degrees = object.sum(dim=0)
        projection_90degrees = object.sum(dim=0)
        if subset_idx==0:
            projections = projection_0degrees
        elif subset_idx==1:

```

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

### Instantiate and Use System Matrix

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_examplesystemmatrix.ipynb.txt

Create an instance of the custom System Matrix and use its forward and backward projection methods with sample data.

```python
system_matrix = EXSSystemMatrix(object_meta=object_meta, proj_meta=proj_meta)
FP = system_matrix.forward(sample_object)
BP = system_matrix.forward(sample_object)
```

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

### get_projections

Source: https://pytomography.readthedocs.io/en/latest/_sources/autoapi/pytomography/io/SPECT/index.rst.txt

Gets projections from a .dcm file.

```APIDOC
## get_projections

### Description
Gets projections from a .dcm file.

### Parameters
#### Path Parameters
- **file** (str) - Required - Path to the .dcm file of SPECT projection data.
#### Query Parameters
- **index_peak** (int, optional) - If not none, then the returned projections correspond to the index of this energy window. Otherwise returns all energy windows. Defaults to None.
- **index_time** (int, optional) - If not none, then the returned projections correspond to the index of the time slot in gated SPECT. Otherwise returns all time slots. Defaults to None
- **use_FOV_mask** (bool, optional) - If true, then use ta field of view mask obtained from DICOM file. Defaults to False.

### Returns
- **tuple** - (SPECTObjectMeta, SPECTProjMeta, torch.Tensor[..., Ltheta, Lr, Lz]) where ... depends on if time slots are considered.
```

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

### Initialize StarGuideSystemMatrix

Source: https://pytomography.readthedocs.io/en/latest/_modules/pytomography/projectors/SPECT/starguide_system_matrix.html

Initializes the StarGuideSystemMatrix with object and projection metadata, and optional transformation sequences. It also sets up time scaling based on projection metadata.

```python
from __future__ import annotations
import torch
import pytomography
from pytomography.utils import rotate_detector_z
from torch.nn.functional import pad
from pytomography.projectors.system_matrix import SystemMatrix
from pytomography.transforms.SPECT import SPECTPSFTransform
from pytomography.metadata import ObjectMeta
from pytomography.metadata.SPECT import StarGuideProjMeta
from kornia.geometry.transform import Translate


class StarGuideSystemMatrix(SystemMatrix):
    r"""System matrix for the StarGuide SPECT imaging system form General Electric Healthcare.
    
    Args:
        obj2obj_transforms (Sequence[Transform]): Sequence of object mappings that occur before forward projection.
        proj2proj_transforms (Sequence[Transform]): Sequence of proj mappings that occur after forward projection.
        object_meta (SPECTObjectMeta): SPECT Object metadata.
        proj_meta (StarGuideProjMeta): Projection metadata pertaining to the StarGuide system.
        object_initial_based_on_camera_path (bool): Whether or not to initialize the object estimate based on the camera path; this sets voxels to zero that are outside the SPECT camera path. Defaults to False.
    """
    def __init__(
        self,
        object_meta: ObjectMeta,
        proj_meta: StarGuideProjMeta,
        obj2obj_transforms = [],
        proj2proj_transforms = [],    
    ):
        super().__init__(object_meta, proj_meta, obj2obj_transforms, proj2proj_transforms)
        self.times = self.proj_meta.times.reshape(-1,1,1) / 1e3
```

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

### get_angle

Source: https://pytomography.readthedocs.io/en/latest/_sources/autoapi/pytomography/io/PET/gate/index.rst.txt

Gets the angular position of all LORs.

```APIDOC
## get_angle(detector_ids, scanner_LUT)

### Description
Gets the angular position of all LORs.

### Parameters
#### Path Parameters
- **detector_ids** (torch.tensor) - Detector ID pairs corresponding to LORs
- **scanner_LUT** (torch.tensor) - scanner look up table

### Returns
- **angle of all detector ID pairs provided** (torch.tensor)
```

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

### StarGuideSystemMatrix Initialization

Source: https://pytomography.readthedocs.io/en/latest/autoapi/pytomography/projectors/SPECT/starguide_system_matrix/index.html

Initializes the StarGuideSystemMatrix with transformation sequences and metadata for SPECT imaging.

```APIDOC
## StarGuideSystemMatrix

### Description
System matrix for the StarGuide SPECT imaging system from General Electric Healthcare.

### Parameters
* **obj2obj_transforms** (Sequence[Transform]) – Sequence of object mappings that occur before forward projection.
* **proj2proj_transforms** (Sequence[Transform]) – Sequence of proj mappings that occur after forward projection.
* **object_meta** (SPECTObjectMeta) – SPECT Object metadata.
* **proj_meta** (StarGuideProjMeta) – Projection metadata pertaining to the StarGuide system.
* **object_initial_based_on_camera_path** (bool) – Whether or not to initialize the object estimate based on the camera path; this sets voxels to zero that are outside the SPECT camera path. Defaults to False.
```

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

### get_radius

Source: https://pytomography.readthedocs.io/en/latest/_sources/autoapi/pytomography/io/PET/gate/index.rst.txt

Gets the radial position of all LORs.

```APIDOC
## get_radius(detector_ids, scanner_LUT)

### Description
Gets the radial position of all LORs.

### Parameters
#### Path Parameters
- **detector_ids** (torch.tensor) - Detector ID pairs corresponding to LORs
- **scanner_LUT** (torch.tensor) - scanner look up table

### Returns
- **radii of all detector ID pairs provided** (torch.tensor)
```

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

### get_metadata

Source: https://pytomography.readthedocs.io/en/latest/autoapi/pytomography/io/SPECT/dicom/index.html

Gets PyTomography metadata from a .dcm file.

```APIDOC
## get_metadata

### Description
Gets PyTomography metadata from a .dcm file.

### Parameters
* **file** (str) - Path to the DICOM file.
* **index_peak** (int, optional) - Index of the energy peak to retrieve metadata for. Defaults to None.
```

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

### Set up MLEM Reconstruction Algorithm

Source: https://pytomography.readthedocs.io/en/latest/notebooks/t_examplesystemmatrix.html

Initialize the `EXSSystemMatrix`, define a `NegativeMSELikelihood` (as a substitute for PoissonLog for SPECT/PET), and set up the `MLEM` reconstruction algorithm with the likelihood.

```python
# Define system matrix
system_matrix = EXSSystemMatrix(object_meta=object_meta, proj_meta=proj_meta)
# Define likelihood that characterizes measured data (for SPECT/PET, this is PoissonLog, but here we'll use NegativeMSE)
likelihood = NegativeMSELikelihood(system_matrix, projections=sample_projections, scaling_constant=0.01)
# Define
reconstruction_algorithm = MLEM(likelihood)
```

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

### get_projections

Source: https://pytomography.readthedocs.io/en/latest/autoapi/pytomography/io/SPECT/simind/index.html

Gets projection data from a SIMIND header file.

```APIDOC
## get_projections

### Description
Gets projection data from a SIMIND header file.

### Parameters
* **headerfiles** (str | Sequence[str]) - 
* **weights** (float) - 
* **distance** (str, optional) - The units of measurements in the SIMIND file (this is required as input, since SIMIND uses mm/cm but doesn’t specify). Defaults to ‘cm’.

### Returns
Simulated SPECT projection data.

### Return type
(torch.Tensor[1, Ltheta, Lr, Lz])
```

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

### Initialize FilteredBackProjection Class

Source: https://pytomography.readthedocs.io/en/latest/_modules/pytomography/algorithms/fbp.html

Initializes the FBP algorithm with projection data, a system matrix, and an optional Fourier space filter. The system matrix should not include attenuation or PSF effects for FBP.

```python
from pytomography.projectors import SystemMatrix
from pytomography.utils import RampFilter

# Assuming projections and system_matrix are already defined
system_matrix = SystemMatrix(...)
projections = torch.Tensor(...)

filtered_back_projection = FilteredBackProjection(projections, system_matrix)
```

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

### PET Listmode Reconstruction Setup (Python)

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_PETGATE_scat_lmTOF.ipynb.txt

Sets up the necessary components for PET listmode reconstruction. This includes defining the object and projection space metadata, loading the attenuation map and PSF transform, creating the system matrix, and initializing the PoissonLogLikelihood and OSEM reconstruction algorithm.

```python
# Specify object space for reconstruction
object_meta = ObjectMeta(
    dr=(2,2,2), #mm
    shape=(128,128,96) #voxels
)
# Get projection space metadata from PET geometry information dictionary
proj_meta = PETLMProjMeta(
    detector_ids,
    info,
    tof_meta=tof_meta,
    weights_sensitivity=normalization_weights
    )
# Get attenuation map and PSF transform from the associated phantom
atten_map = gate.get_aligned_attenuation_map(os.path.join(path, 'gate_simulation/simple_phantom/umap_mMR_brainSimplePhantom.hv'), object_meta).to(pytomography.device)
psf_transform = GaussianFilter(3.) # 4mm gaussian blurring
# Create system matrix.
system_matrix = PETLMSystemMatrix(
    object_meta,
    proj_meta,
    obj2obj_transforms = [psf_transform],
    attenuation_map = atten_map,
    N_splits=8,
)
# Create likelihood. For listmode reconstruction, projections don't need to be provided, since all detection events are stored in proj_meta
likelihood = PoissonLogLikelihood(
    system_matrix,
)
# Initialize reconstruction algorithm
recon_algorithm = OSEM(likelihood)
# Reconstruct
recon_primaryonly = recon_algorithm(n_iters=4, n_subsets=14)
```

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

### get_projections

Source: https://pytomography.readthedocs.io/en/latest/autoapi/pytomography/io/SPECT/simind/index.html

Gets projection data from a SIMIND header file.

```APIDOC
## get_projections

### Description
Gets projection data from a SIMIND header file.

### Parameters
* **headerfiles** (list of str) - A list of paths to SIMIND header files.
* **weights** (list of float, optional) - A list of weights for combining projection data. Defaults to None.
```

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

### get_sinogram_from_root_data

Source: https://pytomography.readthedocs.io/en/latest/_sources/autoapi/pytomography/io/PET/gate/index.rst.txt

Get PET sinogram directly from ROOT data.

```APIDOC
## get_sinogram_from_root_data(paths, info, include_randoms = True, include_scatters = True, randoms_only = False, scatters_only = False)

### Description
Get PET sinogram directly from ROOT data.

### Parameters
#### Path Parameters
- **paths** (Sequence[str]) - GATE generated ROOT files
- **info** (dict) - PET geometry information dictionary
- **include_randoms** (bool, optional) - Whether or not to include random events in the sinogram. Defaults to True.
- **include_scatters** (bool, optional) - Whether or not to include scatter events in the sinogram. Defaults to True.
- **randoms_only** (bool, optional) - Flag for only binning randoms. Defaults to False.
- **scatters_only** (bool, optional) - Flag for only binning scatters. Defaults to False.

### Returns
- **PET sinogram** (torch.Tensor)
```

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

### Set data save path

Source: https://pytomography.readthedocs.io/en/latest/notebooks/t_dicommultibed.html

Specify the directory where the tutorial data is stored. This path needs to be updated to reflect your local data location.

```python
# change this to where you downloaded the data
save_path = '/mnt/mydisk2/pytomo_tutorial_data/SPECT'
```

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

### Initialize and Use EXSListmodeSystemMatrix

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_examplesystemmatrix.ipynb.txt

Initializes the EXSListmodeSystemMatrix with object and projection metadata, then performs a forward and backward projection. This demonstrates the basic workflow for listmode reconstruction.

```python
system_matrix = EXSListmodeSystemMatrix(object_meta=object_meta, proj_meta=proj_meta_listmode)
sample_object = torch.rand(object_meta.shape) # object has batch dimension
FP = system_matrix.forward(sample_object)
BP = system_matrix.backward(FP)
```

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

### get_angle

Source: https://pytomography.readthedocs.io/en/latest/autoapi/pytomography/utils/cardiac_spect/index.html

Gets the angle of the best line passing through the center of the image.

```APIDOC
## get_angle

### Description
Get the angle of the best line passing through the center of the image.

### Parameters
* **slice** (_torch.Tensor_) – torch.Tensor[Lx, Ly] representing the slice.
* **angle_range_degrees** (_torch.Tensor_) – torch.Tensor[N] with angles in degrees.

### Returns
The best angle in degrees.
```

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

### get_normalization_weights_cylinder_calibration

Source: https://pytomography.readthedocs.io/en/latest/_sources/autoapi/pytomography/io/PET/gate/index.rst.txt

Function to get sensitivity factor from a cylindrical calibration phantom.

```APIDOC
## get_normalization_weights_cylinder_calibration(paths, info, cylinder_radius, include_randoms = True)

### Description
Function to get sensitivity factor from a cylindrical calibration phantom.

### Parameters
#### Path Parameters
- **paths** (Sequence[str]) - List of paths corresponding to calibration scan
- **info** (dict) - PET geometry information dictionary
- **cylinder_radius** (float) - Radius of cylindrical phantom used in scan
- **include_randoms** (bool, optional) - Whether or not to include random events from the cylinder calibration. Defaults to True.

### Returns
- **Sensitivty factor for all possible detector combinations** (torch.tensor)
```

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

### StarGuideSystemMatrix Initialization

Source: https://pytomography.readthedocs.io/en/latest/_modules/pytomography/projectors/SPECT/starguide_system_matrix.html

Initializes the StarGuideSystemMatrix with object and projection metadata, along with optional object-to-object and projection-to-projection transforms.

```APIDOC
## StarGuideSystemMatrix

### Description
System matrix for the StarGuide SPECT imaging system form General Electric Healthcare.

### Parameters
- **object_meta** (ObjectMeta) - SPECT Object metadata.
- **proj_meta** (StarGuideProjMeta) - Projection metadata pertaining to the StarGuide system.
- **obj2obj_transforms** (Sequence[Transform], optional) - Sequence of object mappings that occur before forward projection. Defaults to [].
- **proj2proj_transforms** (Sequence[Transform], optional) - Sequence of proj mappings that occur after forward projection. Defaults to [].
- **object_initial_based_on_camera_path** (bool, optional) - Whether or not to initialize the object estimate based on the camera path; this sets voxels to zero that are outside the SPECT camera path. Defaults to False.
```

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

### Define tutorial data path

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_ac225_dicom_recon.ipynb.txt

Sets the base path for the tutorial data, specifically for SPECT.

```python
path  = '/mnt/mydisk2/pytomo_tutorial_data/SPECT'
```

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

### TimeInterval

Source: https://pytomography.readthedocs.io/en/latest/_sources/autoapi/pytomography/io/PET/prd/index.rst.txt

Represents a time interval in milliseconds since the start of acquisition.

```APIDOC
## class TimeInterval(*, start = 0, stop = 0)

Time interval in milliseconds since start of acquisition

### Methods

* `__eq__(other)` - Return self==value.
* `__str__()` - Return str(self).
* `__repr__()` - Return repr(self).
```

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

### Initialize PET System Matrix

Source: https://pytomography.readthedocs.io/en/latest/notebooks/t_PETGATE_scat_sino.html

Sets up the PET system matrix, including attenuation maps, normalization sinograms, PSF transforms, and other necessary parameters for reconstruction.

```python
atten_map = gate.get_aligned_attenuation_map(os.path.join(path, 'gate_simulation/simple_phantom/umap_mMR_brainSimplePhantom.hv'), object_meta).to(pytomography.device)
normalization_sinogram = torch.load(os.path.join(path, 'normalization_sinogram.pt')) # assumes this has been saved from the intro tutorial
proj_meta = PETSinogramPolygonProjMeta(info)
psf_transform = GaussianFilter(3)
system_matrix = PETSinogramSystemMatrix(
       object_meta,
       proj_meta,
       obj2obj_transforms = [psf_transform],
       sinogram_sensitivity = normalization_sinogram,
       N_splits=10,
       attenuation_map=atten_map,
       device='cpu' # projections output on cpu, rest is GPU
)
```

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

### PETLMSystemMatrix.compute_normalization_factor

Source: https://pytomography.readthedocs.io/en/latest/autoapi/pytomography/projectors/PET/petlm_system_matrix/index.html

Function called by reconstruction algorithms to get the sensitivty image H~mTw.

```APIDOC
## PETLMSystemMatrix.compute_normalization_factor(subset_idx=None)

### Description
Function called by reconstruction algorithms to get the sensitivty image H~mTw.

### Parameters
#### Optional Parameters
- **subset_idx** (int | None) - Subset index m. If none, then considers backprojection over all subsets. Defaults to None.

### Returns
Normalization factor.

### Return Type
torch.tensor
```

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

### get_xyz_sinogram_coordinates

Source: https://pytomography.readthedocs.io/en/latest/autoapi/pytomography/projectors/PET/pet_sinogram_system_matrix/index.html

Get the XYZ coordinates corresponding to the pair of crystals of the projection angle.

```APIDOC
## Method get_xyz_sinogram_coordinates

### Description
Get the XYZ coordinates corresponding to the pair of crystals of the projection angle.

### Parameters
* **subset_idx** (int, optional) - Subset index for the sinogram. If None, considers all elements. Defaults to None.

### Returns
XYZ coordinates of crystal 1 and XYZ coordinates of crystal 2 corresponding to all elements in the sinogram.

### Return Type
Sequence[torch.Tensor, torch.Tensor]
```

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

### Create and Write to HDF5 File

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_GE_HDF5.ipynb.txt

Demonstrates creating a new HDF5 file and writing a simple dataset to it. Ensure the 'h5py' library is installed.

```python
import h5py

# Create a new HDF5 file in write mode
with h5py.File('my_data.hdf5', 'w') as f:
    # Create a dataset named 'my_dataset' and write data to it
    f.create_dataset('my_dataset', data=[1, 2, 3, 4, 5])

print("HDF5 file 'my_data.hdf5' created successfully.")
```

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

### Load SIMIND Projections with Multiple Energy Windows and Regions

Source: https://pytomography.readthedocs.io/en/latest/usage/usage_spect.html

Demonstrates how to load SIMIND projection data. Use a list of paths for multiple energy windows for one region. Use a list of lists of paths for multiple regions with a single energy window, scaling by activities. Use a list of lists of paths for multiple energy windows and multiple regions.

```python
import os
from pytomography.io.SPECT import simind

path = '/disk1/pytomography_tutorial_data/simind_tutorial/'

# SIMIND simulation files for simulation of only a liver region
photopeak_path_liver = os.path.join(path, 'multi_projections', 'liver', 'photopeak.h00')
upperscatter_path_liver = os.path.join(path, 'multi_projections', 'liver', 'lowerscatter.h00')
lowerscatter_path_liver = os.path.join(path, 'multi_projections', 'liver', 'upperscatter.h00')

# SIMIND simulation files for simulation of all anatomical regions
organs = ['bkg', 'liver', 'l_lung', 'r_lung', 'l_kidney', 'r_kidney','salivary', 'bladder']
headerfiles = [os.path.join(path, 'multi_projections', organ, 'photopeak.h00') for organ in organs]
headerfiles_lower = [os.path.join(path, 'multi_projections', organ, 'lowerscatter.h00') for organ in organs]
headerfiles_upper = [os.path.join(path, 'multi_projections', organ, 'upperscatter.h00') for organ in organs]

# 1. To load multiple energy windows for one region, we provide the paths as a list
photopeak_liver = simind.get_projections([photopeak_path_liver, upperscatter_path_liver, lowerscatter_path_liver])
print(photopeak_liver.shape)

# 2. To load a single energy window and combine multiple regions, we provide the list as [[<list>]]. This will scale each SIMIND set of projections by the corresponding activities (combining projections together):
activities = [2500, 450, 7, 7, 100, 100, 20, 90] # MBq
photopeak_allregions = simind.get_projections([headerfiles], weights=activities)
print(photopeak_allregions.shape)

# 3. To load multiple energy windows for multiple regions, we provide the list as [[<list>], [<list>], [<list>]]:
activities = [2500, 450, 7, 7, 100, 100, 20, 90] # MBq
projections_allregions = simind.get_projections([headerfiles, headerfiles_lower, headerfiles_upper], weights=activities)
print(projections_allregions.shape)
```

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

### get_mu_from_spectrum_interp

Source: https://pytomography.readthedocs.io/en/latest/_sources/autoapi/pytomography/utils/nist_data/index.rst.txt

Gets linear attenuation corresponding to a given energy in the data from 'file'.

```APIDOC
## get_mu_from_spectrum_interp(file, energy)

### Description
Gets linear attenuation corresponding to a given energy in the data from 'file'.

### Parameters
#### Path Parameters
- **file** (str) - Required - Filepath of the mu-energy data
- **energy** (float) - Required - Energy at which mu is computed

### Returns
- **np.array** - Linear attenuation coefficient (in 1/cm) at the desired energies.
```

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

### get_dtype Data

Source: https://pytomography.readthedocs.io/en/latest/_sources/autoapi/pytomography/io/PET/prd/types/index.rst.txt

A data object that provides a way to get data types.

```APIDOC
## Data: get_dtype

### Description
A data object that provides a way to get data types.
```

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

### SystemMatrix Transform Initialization

Source: https://pytomography.readthedocs.io/en/latest/_modules/pytomography/projectors/system_matrix.html

Initializes all configured transforms by calling their `configure` method with the system's object and projection metadata. This prepares the transforms for use in forward and backward projections.

```python
def initialize_transforms(self):
    """Initializes all transforms used to build the system matrix
    """
    for transform in self.obj2obj_transforms:
        transform.configure(self.object_meta, self.proj_meta)
    for transform in self.proj2proj_transforms:
        transform.configure(self.object_meta, self.proj_meta)
```

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

### TimeInterval Class

Source: https://pytomography.readthedocs.io/en/latest/autoapi/pytomography/io/PET/prd/types/index.html

Defines a time interval in milliseconds since the start of acquisition.

```APIDOC
class pytomography.io.PET.prd.types.TimeInterval(_*, start=0, stop=0)

    Time interval in milliseconds since start of acquisition 

    Parameters:
        start (pytomography.io.PET.prd.yardl_types.UInt32) – 
        stop (pytomography.io.PET.prd.yardl_types.UInt32) – 

    __eq__(other)
        Return self==value.

        Parameters:
            other (object) –  

        Return type:
            bool 

    __str__()
        Return str(self).

        Return type:
            str 

    __repr__()
        Return repr(self).

        Return type:
            str 
```

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

### Initialize EXSSystemMatrix and Compute Normalization Factor

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_examplesystemmatrix.ipynb.txt

Instantiate the EXSSystemMatrix and calculate the normalization factor. This is typically done after defining object and projection metadata.

```python
system_matrix = EXSSystemMatrix(object_meta=object_meta, proj_meta=proj_meta)
norm_factor = system_matrix.compute_normalization_factor()
```

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

### Set the path to SIMIND tutorial data

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_spect_mc.ipynb.txt

Specifies the directory where the SIMIND tutorial data is located. This path needs to be adjusted based on your system's configuration.

```python
# change this to where the tutorial data is saved
PATH = '/ac225listmode/pytomography_tutorial_data/SPECT/SIMIND-Jaszak'
```

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

### TimeInterval Class

Source: https://pytomography.readthedocs.io/en/latest/_sources/autoapi/pytomography/io/PET/prd/types/index.rst.txt

Represents a time interval defined by a start and stop time.

```APIDOC
## Class: TimeInterval

### Description
Time interval in milliseconds since start of acquisition.

### Methods
- `__eq__(other)`: Return self==value.
- `__str__()`: Return str(self).
- `__repr__()`: Return repr(self).

### Parameters
- `start` (int): The start time of the interval in milliseconds.
- `stop` (int): The stop time of the interval in milliseconds.
```

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

### get_mu_from_spectrum_interp

Source: https://pytomography.readthedocs.io/en/latest/autoapi/pytomography/utils/index.html

Gets linear attenuation corresponding to a given energy by interpolating from provided data.

```APIDOC
## get_mu_from_spectrum_interp

### Description
Gets linear attenuation corresponding to a given energy in in the data from `file`.

### Parameters
* **file** (_str_) – Filepath of the mu-energy data
* **energy** (_float_) – Energy at which mu is computed

### Returns
Linear attenuation coefficient (in 1/cm) at the desired energies.

### Return type
np.array
```

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

### Configure data path for tutorial data

Source: https://pytomography.readthedocs.io/en/latest/_sources/notebooks/t_algorithms.ipynb.txt

Set the PATH variable to the directory where the tutorial data is stored. This is crucial for loading SPECT/CT data correctly.

```python
# CHANGE THIS TO WHERE YOU DOWNLOADED THE TUTORIAL DATA
PATH = '/mnt/mydisk2/pytomo_tutorial_data/SPECT'
```
Tokens:
Raw