civet.minc

  1"""
  2Defines types and operations related to MINC files.
  3"""
  4from dataclasses import dataclass
  5from os import PathLike
  6from typing import Literal, TypeVar, Generic, Optional
  7
  8from civet.bases import DataFile
  9from civet.extraction.kernels import ngh_count_kernel
 10from civet.xfm import TransformProgram, TransformableMixin
 11
 12_M = TypeVar('_M', bound='GenericMinc')
 13_V = TypeVar('_V', bound='GenericMinc')
 14
 15
 16@dataclass(frozen=True)
 17class GenericMinc(TransformableMixin[_M], DataFile[_M], Generic[_M]):
 18
 19    preferred_suffix = '.mnc'
 20    transform_program: TransformProgram = 'transform_volume'
 21
 22    def mincresample(self, like_volume: _V) -> _V:
 23        def command(output):
 24            return (
 25                'mincresample', '-clobber', '-quiet',
 26                '-like', like_volume, self, output
 27            )
 28        return like_volume.create_command(command)
 29
 30    def reshape255(self) -> 'GenericMask':
 31        def command(output):
 32            return (
 33                'mincreshape', '-quiet', '-clobber', '-unsigned', '-byte',
 34                '-image_range', '0', '255', '-valid_range', '0', '255',
 35                self, output
 36            )
 37        return GenericMask(self).create_command(command)
 38
 39    def resamplef64(self, *extra_flags: str) -> 'GenericFloatMinc':
 40        def command(output):
 41            return 'mincresample', '-quiet', '-double', *extra_flags, self, output
 42        return GenericFloatMinc(self).create_command(command)
 43
 44
 45class MincVolume(GenericMinc['MincVolume']):
 46    """
 47    A `MincVolume` represents a volume (`.mnc`).
 48    """
 49    pass
 50
 51
 52_MA = TypeVar('_MA', bound='GenericMask')
 53
 54
 55class GenericMask(GenericMinc[_MA], Generic[_MA]):
 56
 57    def dilate_volume(self, dilation_value: int, neighbors: Literal[6, 26], n_dilations: int) -> _MA:
 58        def command(output):
 59            return (
 60                'dilate_volume', self, output,
 61                str(dilation_value), str(neighbors), str(n_dilations)
 62            )
 63        return self.create_command(command)
 64
 65    def minccalc_u8(self, expression: str, *other_volumes: 'GenericMask') -> _MA:
 66        def command(output):
 67            return (
 68                'minccalc', '-clobber', '-quiet',
 69                '-unsigned', '-byte',
 70                '-expression', expression,
 71                self, *other_volumes, output
 72            )
 73        return self.create_command(command)
 74
 75    def mincdefrag(self, label: int, stencil: Literal[6, 19, 27], max_connect: Optional[int] = None) -> _MA:
 76        def command(output):
 77            cmd = ['mincdefrag', self, output, str(label), str(stencil)]
 78            if max_connect is not None:
 79                cmd.append(str(max_connect))
 80            return cmd
 81        return self.create_command(command)
 82
 83    def reshape_bbox(self) -> _MA:
 84        def command(output):
 85            return 'mincreshape_bbox_helper', self, output
 86        return self.create_command(command)
 87
 88    def mincmorph_convolve_u8(self, kernel: str | PathLike = ngh_count_kernel) -> _MA:
 89        def command(output):
 90            return (
 91                'mincmorph',
 92                '-unsigned', '-byte',
 93                '-convolve',
 94                '-kernel', kernel,
 95                self, output
 96            )
 97        return self.create_command(command)
 98
 99
100class Mask(GenericMask['Mask']):
101    """
102    A `Mask` represents a volume (`.mnc`) with discrete intensities (segmentation volume or brain mask).
103    """
104    pass
105
106
107_F = TypeVar('_F', bound='GenericFloatMinc')
108
109
110class GenericFloatMinc(GenericMinc[_F], Generic[_F]):
111    def mincblur(self, fwhm: float) -> _F:
112        # result is not a binary mask, it has float values in [0, 1],
113        # maybe define a unique type?
114        def command(output):
115            return 'mincblur_correct_name.sh', '-quiet', '-fwhm', str(fwhm), self, output
116        return self.create_command(command)
117
118
119class FloatMinc(GenericFloatMinc['FloatMinc']):
120    pass