brkraw-sordino 0.1.3__py3-none-any.whl

brkraw_sordino/spoketiming.py

@@ -0,0 +1,168 @@
+import os
+import logging
+from .helper import progressbar
+import numpy as np
+from typing import Dict, Any
+from scipy.interpolate import interp1d
+from .recon import get_num_frames, parse_fid_info
+from .typing import Options
+
+logger = logging.getLogger("brkraw.sordino")
+
+
+
+def get_fid_filesize_in_gb(fid_fobj, 
+                           recon_info: Dict[str, Any], 
+                           options: Options) -> int:
+    fid_fobj.seek(0, os.SEEK_END)
+    file_size = fid_fobj.tell()
+    fid_fobj.seek(0)
+
+    if options.num_frames is not None:
+        file_size *= get_num_frames(recon_info, options) / options.num_frames
+    file_size_gb = file_size / (1024 ** 3)
+    return file_size_gb
+
+
+def get_num_segment(file_size_gb, recon_info: Dict[str, Any], options: Options):
+    npro = recon_info['NPro']
+    num_segs = int(np.ceil(file_size_gb / options.mem_limit)) if options.mem_limit > 0 else 1
+    npro_per_seg = int(npro / num_segs)
+
+    if residual_pro := npro % npro_per_seg:
+        segs = [npro_per_seg for _ in range(num_segs - 1)] + [residual_pro]
+    else:
+        segs = [npro_per_seg for _ in range(num_segs)]
+    segs = np.asarray(segs, dtype=int)
+    return segs
+
+
+def prep_fid_segmentation(fid_fobj, 
+                          recon_info: Dict[str, Any], 
+                          options: Options):
+    file_size = get_fid_filesize_in_gb(fid_fobj, recon_info, options)
+    segs = get_num_segment(file_size, recon_info, options)
+    return segs
+
+
+def get_timestamps(repetition_time, npro, num_frames):
+    vol_scantime = float(repetition_time) * npro
+    base_timestamps = np.arange(num_frames) * vol_scantime
+    target_timestamps = base_timestamps + (vol_scantime / 2)
+    return {'base': base_timestamps, 
+            'target': target_timestamps}
+
+
+def get_segmented_data(fid_f, fid_shape, fid_dtype, 
+                       buff_size, num_frames, 
+                       seg_size, pro_loc,
+                       options):
+    
+    seg = []
+    
+    stc_buffer_size = int(buff_size / fid_shape[3])
+    pro_offset = pro_loc * stc_buffer_size
+    seg_buffer_size = stc_buffer_size * seg_size # total buffer size for current segment
+
+    for t in range(num_frames):
+        frame_offset = t * buff_size
+        seek_loc = int(options.offset or 0) * buff_size + frame_offset + pro_offset
+        fid_f.seek(seek_loc)
+        seg.append(fid_f.read(seg_buffer_size))
+
+    seg_data = np.frombuffer(b''.join(seg), dtype=fid_dtype)
+    seg_data = seg_data.reshape([2, np.prod(fid_shape[1:3]), seg_size, num_frames], order='F')
+    return {
+        'data': seg_data,
+        'offset': pro_offset,
+    }
+
+
+def interpolate_spoketiming(complex_feed, sample_id, pro_id, ref_timestamps, timestamps, corrected_data):
+    """ interpolation step
+    each projection interpolated the timing at the middle of projection
+    number of spokes * receivers processed together
+    therefore, the spoke timing within a projection will not be corrected
+    instead this actually corrected the spoke timing for each projection
+    as single TR represent time of one projection
+    
+    :param complex_feed: Description
+    :param sample_id: Description
+    :param pro_id: Description
+    :param ref_timestamps: Description
+    :param timestamps: Description
+    :param corrected_data: Description
+    """
+    mag = np.abs(complex_feed)
+    phase = np.angle(complex_feed)
+    phase_unw = np.unwrap(phase)
+    interp_mag   = interp1d(ref_timestamps, mag, kind='linear',
+                            bounds_error=False, fill_value='extrapolate') # pyright: ignore[reportArgumentType]
+    interp_phase = interp1d(ref_timestamps, phase_unw, kind='linear',
+                            bounds_error=False, fill_value='extrapolate') # pyright: ignore[reportArgumentType]
+    
+    mag_t   = interp_mag(timestamps['target'])
+    phase_t = interp_phase(timestamps['target'])
+    
+    phase_wrap = (phase_t + np.pi) % (2 * np.pi) - np.pi
+    
+    z_t = mag_t * np.exp(1j * phase_wrap)
+    corrected_data[0, sample_id, pro_id, :] = z_t.real
+    corrected_data[1, sample_id, pro_id, :] = z_t.imag
+    return corrected_data
+
+
+def correct_spoketiming(segs, fid_f, stc_f, recon_info, options):
+    """ Correct timing of each spoke to align center of scan time
+    (Same concept as slice timing correction, but applied to FID signal)
+    """
+    logger.debug("+ Spoketiming correction")
+    fid_shape, fid_dtype = parse_fid_info(recon_info)
+    buff_size = int(np.prod(fid_shape) * fid_dtype.itemsize)
+    num_frames = get_num_frames(recon_info, options)
+    repetition_time = recon_info['RepetitionTime_ms'] / 1000.0
+    timestamps = get_timestamps(repetition_time, fid_shape[3], num_frames)
+    
+    pro_loc = 0
+    results = {
+        'buffer_size': 0,
+        'dtype': None,
+    }
+    for seg_size in progressbar(segs, desc=' - Segments', ncols=100):
+        # load data
+        segmented = get_segmented_data(
+            fid_f, fid_shape, fid_dtype, buff_size, num_frames, seg_size, pro_loc, options
+            )
+        
+        seg_data = segmented['data']
+        corrected_seg_data = np.empty_like(seg_data)
+        for pro_id in range(seg_size):
+            cur_pro = pro_loc + pro_id
+            ref_timestamps = timestamps['base'] + (cur_pro * repetition_time)
+            for sample_id in range(np.prod(fid_shape[1:3])):
+                complex_feed = seg_data[0, sample_id, pro_id, :] + 1j * seg_data[1, sample_id, pro_id, :]
+                try:
+                    corrected_seg_data = interpolate_spoketiming(complex_feed, sample_id, pro_id, 
+                                                                 ref_timestamps, timestamps, 
+                                                                 corrected_seg_data)
+                except Exception as e:
+                    logger.debug("+ Exception occured during spoketiming correction")
+                    logger.debug(f" - RefTimeStamps: {ref_timestamps}")
+                    logger.debug(f" - DataFeed: {complex_feed}")
+                    raise e
+                
+        # Store data
+        for t in range(num_frames):
+            frame_offset = t * buff_size
+            stc_f.seek(frame_offset + segmented['offset'])
+            stc_f.write(corrected_seg_data[:,:,:, t].flatten(order='F').tobytes())
+
+        if results['dtype'] == None:
+            results['dtype'] = corrected_seg_data.dtype
+        else:
+            assert results['dtype'] == corrected_seg_data.dtype
+        
+        pro_loc += seg_size
+
+    results['buffer_size'] = np.prod([fid_shape]) * results['dtype'].itemsize
+    return results

brkraw_sordino/traj.py

@@ -0,0 +1,316 @@
+from typing import Optional, Dict, Any
+from pathlib import Path
+import numpy as np
+import hashlib
+import logging
+from .helper import progressbar
+from .typing import Options
+
+logger = logging.getLogger("brkraw.sordino")
+
+
+def radial_angles(n: int, factor: float) -> int:
+    return int(np.ceil((np.pi * n * factor) / 2))
+
+
+def radial_angle(i: int, n: int) -> float:
+    return np.pi * (i + 0.5) / n
+
+
+def recon_output_shape(matrix_size, ext_factors) -> list[int]:
+    output_shape = (matrix_size * ext_factors).astype(int).tolist()
+    return output_shape
+
+
+def recon_n_frames(total_frames: int, 
+                   offset: int = 0, 
+                   num_frame: Optional[int] = None) -> int:
+    avail_frames = total_frames - offset
+    set_frames = num_frame or total_frames
+    if set_frames > avail_frames:
+        set_frames = avail_frames
+    return int(set_frames)
+
+
+def recon_buffer_offset(buffer_size: int, offset: Optional[int] = 0) -> int:
+    return offset or 0 * buffer_size
+
+
+def get_vol_scantime(repetition_time: float, fid_shape: np.ndarray) -> float:
+    return repetition_time * float(fid_shape[3])
+
+
+def calc_npro(matrix_size: int, under_sampling: float) -> int:
+    usamp = np.sqrt(under_sampling)
+    n_theta = radial_angles(matrix_size, 1 / usamp)
+    n_pro = 0
+    for i_theta in range(n_theta):
+        theta = radial_angle(i_theta, n_theta)
+        n_phi = radial_angles(matrix_size, np.sin(theta) / usamp)
+        n_pro += n_phi
+    return int(n_pro)
+
+
+def find_undersamp(matrix_size: int, n_pro_target: int) -> float:
+    from scipy.optimize import brentq
+
+    def func(under_sampling: float) -> float:
+        n_pro = calc_npro(matrix_size, under_sampling)
+        return float(n_pro - n_pro_target)
+
+    max_val = calc_npro(matrix_size, 1)
+    start = 1e-6
+    end = max_val / matrix_size
+    if func(start) * func(end) > 0:
+        raise ValueError("The function does not change sign over the interval.")
+    undersamp_solution = brentq(func, start, end, xtol=1e-6)
+    if isinstance(undersamp_solution, tuple):
+        return float(undersamp_solution[0])
+    return float(undersamp_solution)
+
+
+def calc_radial_traj3d(
+    grad_array: np.ndarray,
+    matrix_size: int,
+    use_origin: bool,
+    over_sampling: float,
+    correct_ramptime: bool = False,
+    traj_offset: Optional[float] = None,
+) -> np.ndarray:
+    """
+    Calculate trajectory for SORDINO imaging.
+    For each projection, a vector with sampling positions (trajectory) is created.
+
+    Args:
+        grad_array (ndarray): Gradient vector profile for each projection, sized (3 x n_pro).
+        matrix_size (int): Matrix size of the final image.
+        over_sampling (float): Oversampling factor.
+        bandwidth (float): Bandwidth of the imaging process.
+        traj_offset (float, optional): Trajectory offset ratio compared to ADC sampling.
+
+    Returns:
+        ndarray: Calculated trajectory for each projection.
+    """
+    pro_offset = 1 if use_origin else 0
+    g = grad_array.copy()
+    npro = g.shape[-1]
+    traj_offset = traj_offset or 0
+    num_samples = int(matrix_size / 2 * over_sampling)
+    traj = np.zeros([npro, num_samples, 3])
+    scale_factor = (num_samples - 1 + traj_offset) / (num_samples-1)
+
+    logger.debug('++ Processing trajectory calculation...')
+    logger.debug(' + Input arguments')
+    logger.debug(f' - Size of Matrix: {matrix_size}')
+    logger.debug(f' - OverSampling: {over_sampling}')
+    logger.debug(f' - Trajectory offset ratio: {traj_offset}')
+    logger.debug(f' - Ramp-time Correction: {str(correct_ramptime)}')
+    logger.debug(f' - Size of Output Trajectory: {traj.shape}')
+    logger.debug(f' - Image Scailing Factor (*Subject to be corrected in future version): {scale_factor}')
+
+    for i_pro in progressbar(range(pro_offset, npro + pro_offset), desc="traj", ncols=100):
+        for i_samp in range(num_samples):
+            samp = ((i_samp + traj_offset) / (num_samples - 1)) / 2
+            if not correct_ramptime or i_pro == (npro + pro_offset) - 1:
+                correction = np.zeros(3)
+                traj[i_pro, i_samp, :] = samp * (g[:, i_pro] + correction)
+            else:
+                correction = (g[:, i_pro] - g[:, i_pro - 1]) / num_samples * i_samp
+                traj[i_pro, i_samp, :] = samp * (g[:, i_pro - 1] + correction)
+    return traj
+
+
+def calc_radial_grad3d(
+    matrix_size: int,
+    npro_target: int,
+    half_sphere: bool,
+    use_origin: bool,
+    reorder: bool,
+) -> np.ndarray:
+    """
+    Generate 3D radial gradient profile based on input parameters.
+
+    Args:
+        matrix_size (int): Target matrix size.
+        n_pro_target (int): Target number of projections.
+        half_sphere (bool): If True, only generate for half the sphere.
+        use_origin (bool): If True, add center points at the start.
+        reorder (bool): Use reorder scheme provided by Bruker ZTE sequence.
+
+    Returns:
+        ndarray: The gradient profile as an array.
+    """
+
+    n_pro = int(npro_target / (1 if half_sphere else 2) - (1 if use_origin else 0))
+    usamp = np.sqrt(find_undersamp(matrix_size, n_pro))
+
+    logger.debug('\n++ Processing SORDINO 3D Radial Gradient Calculation...')
+    logger.debug(' + Input arguments')
+    logger.debug(f' - Matrix size: {matrix_size}')
+    logger.debug(f' - Undersampling factor: {usamp}')
+    logger.debug(f' - Number of Projections: {npro_target}')
+    logger.debug(f' - Half sphere only: {half_sphere}')
+    logger.debug(f' - Use origin: {use_origin}')
+    logger.debug(f' - Reorder Gradient: {reorder}')
+
+    grad = {"r": [], "p": [], "s": []}
+    radial_n_phi: list[int] = []
+
+    logger.debug(' + Start Calculating Gradient Vectors...')
+    n_theta = radial_angles(matrix_size, 1.0 / usamp)
+    for i_theta in range(n_theta):
+        theta = radial_angle(i_theta, n_theta)
+        n_phi = radial_angles(matrix_size, float(np.sin(theta) / usamp))
+        radial_n_phi.append(n_phi)
+        for i_phi in range(n_phi):
+            phi = radial_angle(i_phi, n_phi)
+            grad["r"].append(np.sin(theta) * np.cos(phi))
+            grad["p"].append(np.sin(theta) * np.sin(phi))
+            grad["s"].append(np.cos(theta))
+    logger.debug('done')
+
+    grad_array = np.stack([grad["r"], grad["p"], grad["s"]], axis=0)
+    n_pro_created = grad_array.shape[-1] * (1 if half_sphere else 2) + (1 if use_origin else 0)
+    if not usamp:
+        if n_pro_created != npro_target:
+            raise ValueError("Target number of projections can't be reached.")
+    grad_array = reorder_projections(n_theta, radial_n_phi, grad_array, reorder)
+    if not half_sphere:
+        grad_array = np.concatenate([grad_array, -1 * grad_array], axis=1)
+    if use_origin:
+        grad_array = np.concatenate([[[0, 0, 0]], grad_array.T], axis=0).T
+    return grad_array
+
+
+def reorder_projections(
+    n_theta: int,
+    radial_n_phi: list[int],
+    grad_array: np.ndarray,
+    reorder: bool,
+) -> np.ndarray:
+    """
+    Reorder radial projections for improved image spoiling.
+
+    Args:
+        n_theta (int): Number of theta angles.
+        radial_n_phi (list): Number of phi angles for each theta.
+        grad_array (ndarray): Gradient array.
+        reorder (bool): Whether to apply the reordering scheme.
+
+    Returns:
+        ndarray: Reordered gradient array.
+    """
+    g = grad_array.copy()
+    if reorder:
+        logger.debug(' + Reordering projections...')
+        def reorder_incr_index(n: int, i: int, d: int) -> tuple[int, int]:
+            if (i + d > n - 1) or (i + d < 0):
+                d *= -1
+            i += d
+            return i, d
+
+        n_pro = g.shape[-1]
+        n_phi_max = max(radial_n_phi)
+        r_g = np.zeros_like(g)
+        r_mask = np.zeros([n_theta, n_phi_max])
+
+        for i_theta in range(n_theta):
+            for i_phi in range(radial_n_phi[i_theta], n_phi_max):
+                r_mask[i_theta][i_phi] = 1
+
+        i_theta = 0
+        d_theta = 1
+        i_phi = 0
+        d_phi = 1
+
+        for i in range(n_pro):
+            while not any(r_mask[i_theta] == 0):
+                i_theta, d_theta = reorder_incr_index(n_theta, i_theta, d_theta)
+
+            while r_mask[i_theta][i_phi] == 1:
+                i_phi, d_phi = reorder_incr_index(n_phi_max, i_phi, d_phi)
+            new_i = sum(radial_n_phi[:i_theta]) + i_phi
+            r_g[:, i] = g[:, new_i]
+            r_mask[i_theta][i_phi] = 1
+
+            i_theta, d_theta = reorder_incr_index(n_theta, i_theta, d_theta)
+            i_phi, d_phi = reorder_incr_index(n_phi_max, i_phi, d_phi)
+        logger.debug('done')
+        return r_g
+
+    i = 0
+    for i_theta in range(n_theta):
+        if i_theta % 2 == 1:
+            for i_phi in range(int(radial_n_phi[i_theta] / 2)):
+                i0 = i + i_phi
+                i1 = i + radial_n_phi[i_theta] - 1 - i_phi
+                g[:, i0], g[:, i1] = g[:, i1].copy(), g[:, i0].copy()
+        i += radial_n_phi[i_theta]
+    return g
+
+
+def generate_hash(*args: Any) -> str:
+    """Generate a hash from the input arguments."""
+    hash_input = "".join(str(arg) for arg in args)
+    return hashlib.md5(hash_input.encode()).hexdigest()
+
+
+def get_trajectory(recon_info: Dict[str, Any], 
+                   options: Options) -> np.ndarray:
+    
+    correct_ramptime = getattr(options, "correct_ramptime", True)
+    ext_factors = getattr(options, "ext_factors", [1.0, 1.0, 1.0])
+    logger.debug(f' + Extension factors applied to matrix: {ext_factors}')
+
+    sample_size = recon_info['Matrix'][0]
+    npro = recon_info['NPro']
+    half_acquisition = recon_info['HalfAcquisition']
+    use_origin = recon_info['UseOrigin']
+    reorder = recon_info['Reorder']
+    
+    eff_bandwidth = recon_info['EffBandwidth_Hz']
+    over_sampling = recon_info['OverSampling']
+    traj_offset = recon_info['AcqDelayTotal_us']
+
+    grad = calc_radial_grad3d(sample_size, 
+                              npro, 
+                              half_acquisition, 
+                              use_origin, 
+                              reorder)
+    offset_factor = traj_offset * (10 ** -6) * eff_bandwidth * over_sampling
+
+    option_for_hash = (
+        float(traj_offset),
+        sample_size,
+        eff_bandwidth,
+        over_sampling,
+            int(npro),
+            float(np.prod(ext_factors)),
+            bool(half_acquisition),
+            bool(use_origin),
+            bool(reorder),
+        correct_ramptime,
+    )
+
+    digest = generate_hash(*option_for_hash)
+    traj_path = options.cache_dir / f"{digest}.npy"
+    if traj_path.exists():
+        logger.debug("Trajectory cache hit: %s", traj_path)
+        traj = np.load(traj_path)
+    else:
+        logger.info("Computing trajectory (matrix=%s, n_pro=%s).", sample_size, npro)
+        traj = calc_radial_traj3d(
+            grad,
+            sample_size,
+            use_origin,
+            over_sampling,
+            correct_ramptime=correct_ramptime,
+            traj_offset=offset_factor,
+        )
+        np.save(traj_path, traj)
+        logger.debug("Saved trajectory cache: %s", traj_path)
+    return traj
+
+__all__ = [
+    'get_trajectory'
+]

brkraw_sordino/typing.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import Tuple, Optional
+from pathlib import Path
+
+
+@dataclass
+class Options:
+    ext_factors: Tuple[float, float, float]
+    ignore_samples: int
+    offset: int
+    num_frames: Optional[int]
+    correct_spoketiming: bool
+    correct_ramptime: bool
+    offreso_ch: Optional[int]
+    offreso_freq: float
+    mem_limit: float
+    clear_cache: bool
+    split_ch: bool
+    cache_dir: Path
+    as_complex: bool
+
+
+__all__ = [
+    'Options'
+]

brkraw_sordino-0.1.3.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: brkraw-sordino
+Version: 0.1.3
+Summary: BrkRaw converter hook for SORDINO-ZTE reconstruction
+Author-email: SungHo Lee <shlee@unc.edu>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: brkraw
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: mri-nufft[finufft]
+Provides-Extra: dev
+Requires-Dist: tomli; extra == "dev"
+
+# brkraw-sordino
+
+SORDINO-ZTE reconstruction hook for BrkRaw.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Hook install
+
+```bash
+brkraw hook install brkraw-sordino
+```
+
+This installs the hook rule from the package manifest (`brkraw_hook.yaml`).
+
+## Usage
+
+Once installed, `brkraw` applies the hook automatically when a dataset matches the rule.
+
+Basic conversion:
+
+```bash
+brkraw convert /path/to/study --scan-id 3 --reco-id 1
+```
+
+The hook behaves the same whether invoked via the CLI or via the Python API (the same hook entrypoint and arguments are used).
+
+To explicitly pass hook options (or override defaults), use `--hook-arg` / `--hook-args-yaml` below.
+
+## Hook options
+
+Hook arguments can be passed via `brkraw convert` using `--hook-arg` with the
+entrypoint name (`sordino`):
+
+```bash
+brkraw convert /path/to/study -s 3 -r 1 \
+  --hook-arg sordino:ext_factors=1.2 \
+  --hook-arg sordino:offset=2 \
+  --hook-arg sordino:split_ch=false
+```
+
+### Pass hook options via YAML (`--hook-args-yaml`)
+
+BrkRaw can also load hook arguments from YAML. Generate a template like this:
+
+```bash
+brkraw hook preset sordino -o hook_args.yaml
+```
+
+Edit the generated YAML, then pass it to `brkraw convert` (repeatable):
+
+```bash
+brkraw convert /path/to/study -s 3 -r 1 --hook-args-yaml hook_args.yaml
+```
+
+Example:
+
+```yaml
+hooks:
+  sordino:
+    ext_factors: 1.2
+    offset: 2
+    split_ch: false
+    # as_complex: true  # optional, return (real, imag)
+    # cache_dir: ~/.brkraw/cache/sordino  # optional (add manually if needed)
+```
+
+Notes:
+
+- CLI `--hook-arg` values override YAML.
+- YAML supports both `{hooks: {sordino: {...}}}` and `{sordino: {...}}` shapes.
+- You can also set `BRKRAW_CONVERT_HOOK_ARGS_YAML` (comma-separated paths).
+
+Supported keys:
+
+- `ext_factors`: scalar or 3-item sequence (default: 1.0)
+- `ignore_samples`: int (default: 1)
+- `offset`: int (default: 0)
+- `num_frames`: int or null (default: None)
+- `correct_spoketiming`: bool (default: false)
+- `correct_ramptime`: bool (default: true)
+- `offreso_ch`: int or null (default: None)
+- `offreso_freq`: float (default: 0.0)
+- `mem_limit`: float (default: 0.5)
+- `clear_cache`: bool (default: true)
+- `split_ch`: bool (default: false, merge channels)
+- `as_complex`: bool (default: false, return complex as (real, imag))
+- `cache_dir`: string path (default: ~/.brkraw/cache/sordino)
+
+## Notes
+
+- The hook reconstructs data using an adjoint NUFFT and returns magnitude images by default.
+- Multi-channel data defaults to merged channels; set `split_ch=true` to keep channels split.
+- When `split_ch=false`, magnitude uses RSS while complex uses coherent sum.
+- Orientation is normalized when the first 3D axes are spatial; see `notebooks/orientation.ipynb`.
+- Cache files live under `~/.brkraw/cache/sordino` (or `BRKRAW_CONFIG_HOME`).

brkraw_sordino-0.1.3.dist-info/RECORD

@@ -0,0 +1,21 @@
+brkraw_sordino/__init__.py,sha256=4wLtPWxTOpwnXT6EA6_k23iayCUY4SxuAlSYuxR7jhk,145
+brkraw_sordino/brkraw_hook.yaml,sha256=NA5j1wGUuakEsB49ATJuFXwYgUnH4RfEcqGES3x_PCU,136
+brkraw_sordino/docs.md,sha256=ue04GqwuFc6-gTYwvvNPz8mspUQ8NSrb8_knD9HqD-0,2802
+brkraw_sordino/helper.py,sha256=1_egvhiVFHU7fdjbLwlC5bxLJz6Ak9JtkClz-Ftn9t4,2210
+brkraw_sordino/hook.py,sha256=1GAdfkPg6j6YftjZEQH3JsOe4Gh92gL_0V0hHCOazu4,6274
+brkraw_sordino/orientation.py,sha256=A3znLacwAIXmqsEdd59qam4aYC_qGhoJ1g894zzZUv4,1082
+brkraw_sordino/recon.py,sha256=2ERseWg_ga-HfugAbQzr4G0-m0dA_Buomc23RpWaKOs,4535
+brkraw_sordino/spoketiming.py,sha256=cbHRZRw_N7tYPqAFwmppzwjUuB4scQYfBEYicFfBP4E,6569
+brkraw_sordino/traj.py,sha256=GkxTWFubcPsiyh3doo3lskR2ozEJSFW_inaesMcRstA,11050
+brkraw_sordino/typing.py,sha256=gh5w1HOZAAyHquFg0Wz-ps7V0bXkcESE5te7zV_FRL0,480
+brkraw_sordino/rules/sordino.yaml,sha256=wb_KeOm50tWGUzfmN9BKPLa9sQYLRq-BnRNWOObmgE4,753
+brkraw_sordino/specs/info_spec.yaml,sha256=NmiUuRuGOvwPEc8GJdrXDOMz3W5u8_loqG1_Ho5769c,2607
+brkraw_sordino/specs/metadata_spec.yaml,sha256=8TynDvfqMIqP2U2dA5u5sauapbNmFh3S8NVIg-v8rDU,2854
+brkraw_sordino/specs/prune4recon.yaml,sha256=qGAf-3Gz-4AfFgefHKR4x_rTLDyoN2a3_gD1RKD2kEE,1042
+brkraw_sordino/specs/recon_spec.yaml,sha256=mBEbRniSIwTpWG_B9I_x1DmxVfUTsLqKK9PFBCk_XGo,1707
+brkraw_sordino/specs/utils.py,sha256=BZA_0-He5hKlmEPF8tpDxq0zc74NelODdlPiFrH-ldk,4963
+brkraw_sordino-0.1.3.dist-info/METADATA,sha256=6qZY2sIuIkrGpj0PyVXwauGQNxCgbhq_0FeaXn40LFI,3196
+brkraw_sordino-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+brkraw_sordino-0.1.3.dist-info/entry_points.txt,sha256=6T_Lc6gPoonrjSSJ2fWRRzl966_ubEiKcvH6mFQBuU8,59
+brkraw_sordino-0.1.3.dist-info/top_level.txt,sha256=i-aGVA4GDdQmfLl4H_ZsgEOhhIWVnSROojNLGgmK7G4,15
+brkraw_sordino-0.1.3.dist-info/RECORD,,

brkraw_sordino-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

brkraw_sordino-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[brkraw.converter_hook]
+sordino = brkraw_sordino.hook:HOOK

brkraw_sordino-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+brkraw_sordino