# This file was auto generated by Styx.
# Do not edit this file directly.

import typing
import pathlib
from styxdefs import *
import dataclasses

MRVIEW_METADATA = Metadata(
    id="1fc2cb0304540f7aaeda0ab60305b06437541161.boutiques",
    name="mrview",
    package="mrtrix",
    container_image_tag="mrtrix3/mrtrix3:3.0.4",
)


@dataclasses.dataclass
class MrviewMode:
    """
    Switch to view mode specified by the integer index, as per the view menu.
    """
    index: int
    """Switch to view mode specified by the integer index, as per the view
    menu."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-mode")
        cargs.append(str(self.index))
        return cargs


@dataclasses.dataclass
class MrviewLoad:
    """
    Load image specified and make it current.
    """
    image: InputPathType
    """Load image specified and make it current."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-load")
        cargs.append(execution.input_file(self.image))
        return cargs


@dataclasses.dataclass
class MrviewReset:
    """
    Reset the view according to current image. This resets the FOV, projection
    and focus.
    """
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-reset")
        return cargs


@dataclasses.dataclass
class MrviewFov:
    """
    Set the field of view, in mm.
    """
    value: float
    """Set the field of view, in mm."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-fov")
        cargs.append(str(self.value))
        return cargs


@dataclasses.dataclass
class MrviewFocus:
    """
    Either set the position of the crosshairs in scanner coordinates, with the
    new position supplied as a comma-separated list of floating-point values or
    show or hide the focus cross hair using a boolean value as argument.
    """
    x_y_z_or_boolean: str
    """Either set the position of the crosshairs in scanner coordinates, with
    the new position supplied as a comma-separated list of floating-point values
    or show or hide the focus cross hair using a boolean value as argument."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-focus")
        cargs.append(self.x_y_z_or_boolean)
        return cargs


@dataclasses.dataclass
class MrviewTarget:
    """
    Set the target location for the viewing window (the scanner coordinate that
    will appear at the centre of the viewing window.
    """
    x_y_z: list[float]
    """Set the target location for the viewing window (the scanner coordinate
    that will appear at the centre of the viewing window"""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-target")
        cargs.extend(map(str, self.x_y_z))
        return cargs


@dataclasses.dataclass
class MrviewVoxel:
    """
    Set the position of the crosshairs in voxel coordinates, relative the image
    currently displayed. The new position should be supplied as a
    comma-separated list of floating-point values.
    """
    x_y_z: list[float]
    """Set the position of the crosshairs in voxel coordinates, relative the
    image currently displayed. The new position should be supplied as a
    comma-separated list of floating-point values."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-voxel")
        cargs.append(",".join(map(str, self.x_y_z)))
        return cargs


@dataclasses.dataclass
class MrviewVolume:
    """
    Set the volume index for the image displayed, as a comma-separated list of
    integers.
    """
    idx: list[int]
    """Set the volume index for the image displayed, as a comma-separated list
    of integers."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-volume")
        cargs.append(",".join(map(str, self.idx)))
        return cargs


@dataclasses.dataclass
class MrviewPlane:
    """
    Set the viewing plane, according to the mappping 0: sagittal; 1: coronal; 2:
    axial.
    """
    index: int
    """Set the viewing plane, according to the mappping 0: sagittal; 1: coronal;
    2: axial."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-plane")
        cargs.append(str(self.index))
        return cargs


@dataclasses.dataclass
class MrviewLock:
    """
    Set whether view is locked to image axes (0: no, 1: yes).
    """
    yesno: str
    """Set whether view is locked to image axes (0: no, 1: yes)."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-lock")
        cargs.append(self.yesno)
        return cargs


@dataclasses.dataclass
class MrviewSelectImage:
    """
    Switch to image number specified, with reference to the list of currently
    loaded images.
    """
    index: int
    """Switch to image number specified, with reference to the list of currently
    loaded images."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-select_image")
        cargs.append(str(self.index))
        return cargs


@dataclasses.dataclass
class MrviewAutoscale:
    """
    Reset the image scaling to automatically determined range.
    """
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-autoscale")
        return cargs


@dataclasses.dataclass
class MrviewInterpolation:
    """
    Enable or disable image interpolation in main image.
    """
    boolean: str
    """Enable or disable image interpolation in main image."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-interpolation")
        cargs.append(self.boolean)
        return cargs


@dataclasses.dataclass
class MrviewColourmap:
    """
    Switch the image colourmap to that specified, as per the colourmap menu.
    """
    index: int
    """Switch the image colourmap to that specified, as per the colourmap
    menu."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-colourmap")
        cargs.append(str(self.index))
        return cargs


@dataclasses.dataclass
class MrviewNoannotations:
    """
    Hide all image annotation overlays.
    """
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-noannotations")
        return cargs


@dataclasses.dataclass
class MrviewComments:
    """
    Show or hide image comments overlay.
    """
    boolean: str
    """Show or hide image comments overlay."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-comments")
        cargs.append(self.boolean)
        return cargs


@dataclasses.dataclass
class MrviewVoxelinfo:
    """
    Show or hide voxel information overlay.
    """
    boolean: str
    """Show or hide voxel information overlay."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-voxelinfo")
        cargs.append(self.boolean)
        return cargs


@dataclasses.dataclass
class MrviewOrientationlabel:
    """
    Show or hide orientation label overlay.
    """
    boolean: str
    """Show or hide orientation label overlay."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-orientationlabel")
        cargs.append(self.boolean)
        return cargs


@dataclasses.dataclass
class MrviewColourbar:
    """
    Show or hide colourbar overlay.
    """
    boolean: str
    """Show or hide colourbar overlay."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-colourbar")
        cargs.append(self.boolean)
        return cargs


@dataclasses.dataclass
class MrviewImagevisible:
    """
    Show or hide the main image.
    """
    boolean: str
    """Show or hide the main image."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-imagevisible")
        cargs.append(self.boolean)
        return cargs


@dataclasses.dataclass
class MrviewIntensityRange:
    """
    Set the image intensity range to that specified.
    """
    min_max: list[float]
    """Set the image intensity range to that specified."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-intensity_range")
        cargs.extend(map(str, self.min_max))
        return cargs


@dataclasses.dataclass
class MrviewSize:
    """
    Set the size of the view area, in pixel units.
    """
    width_height: list[int]
    """Set the size of the view area, in pixel units."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-size")
        cargs.extend(map(str, self.width_height))
        return cargs


@dataclasses.dataclass
class MrviewPosition:
    """
    Set the position of the main window, in pixel units.
    """
    x_y: list[int]
    """Set the position of the main window, in pixel units."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-position")
        cargs.extend(map(str, self.x_y))
        return cargs


@dataclasses.dataclass
class MrviewOverlayLoad:
    """
    Loads the specified image on the overlay tool.
    """
    image: InputPathType
    """Loads the specified image on the overlay tool."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-overlay.load")
        cargs.append(execution.input_file(self.image))
        return cargs


@dataclasses.dataclass
class MrviewOverlayOpacity:
    """
    Sets the overlay opacity to floating value [0-1].
    """
    value: float
    """Sets the overlay opacity to floating value [0-1]."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-overlay.opacity")
        cargs.append(str(self.value))
        return cargs


@dataclasses.dataclass
class MrviewOverlayColourmap:
    """
    Sets the colourmap of the overlay as indexed in the colourmap dropdown menu.
    """
    index: int
    """Sets the colourmap of the overlay as indexed in the colourmap dropdown
    menu."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-overlay.colourmap")
        cargs.append(str(self.index))
        return cargs


@dataclasses.dataclass
class MrviewOverlayColour:
    """
    Specify a manual colour for the overlay, as three comma-separated values.
    """
    r_g_b: list[float]
    """Specify a manual colour for the overlay, as three comma-separated
    values"""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-overlay.colour")
        cargs.append(",".join(map(str, self.r_g_b)))
        return cargs


@dataclasses.dataclass
class MrviewOverlayIntensity:
    """
    Set the intensity windowing of the overlay.
    """
    min_max: list[float]
    """Set the intensity windowing of the overlay"""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-overlay.intensity")
        cargs.extend(map(str, self.min_max))
        return cargs


@dataclasses.dataclass
class MrviewOverlayThresholdMin:
    """
    Set the lower threshold value of the overlay.
    """
    value: float
    """Set the lower threshold value of the overlay"""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-overlay.threshold_min")
        cargs.append(str(self.value))
        return cargs


@dataclasses.dataclass
class MrviewOverlayThresholdMax:
    """
    Set the upper threshold value of the overlay.
    """
    value: float
    """Set the upper threshold value of the overlay"""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-overlay.threshold_max")
        cargs.append(str(self.value))
        return cargs


@dataclasses.dataclass
class MrviewOverlayNoThresholdMin:
    """
    Disable the lower threshold for the overlay.
    """
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-overlay.no_threshold_min")
        return cargs


@dataclasses.dataclass
class MrviewOverlayNoThresholdMax:
    """
    Disable the upper threshold for the overlay.
    """
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-overlay.no_threshold_max")
        return cargs


@dataclasses.dataclass
class MrviewOverlayInterpolation:
    """
    Enable or disable overlay image interpolation.
    """
    value: str
    """Enable or disable overlay image interpolation."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-overlay.interpolation")
        cargs.append(self.value)
        return cargs


@dataclasses.dataclass
class MrviewRoiLoad:
    """
    Loads the specified image on the ROI editor tool.
    """
    image: InputPathType
    """Loads the specified image on the ROI editor tool."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-roi.load")
        cargs.append(execution.input_file(self.image))
        return cargs


@dataclasses.dataclass
class MrviewRoiOpacity:
    """
    Sets the overlay opacity to floating value [0-1].
    """
    value: float
    """Sets the overlay opacity to floating value [0-1]."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-roi.opacity")
        cargs.append(str(self.value))
        return cargs


@dataclasses.dataclass
class MrviewRoiColour:
    """
    Sets the colour of the ROI overlay.
    """
    r_g_b: list[float]
    """Sets the colour of the ROI overlay"""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-roi.colour")
        cargs.extend(map(str, self.r_g_b))
        return cargs


@dataclasses.dataclass
class MrviewTractographyLoad:
    """
    Load the specified tracks file into the tractography tool.
    """
    tracks: InputPathType
    """Load the specified tracks file into the tractography tool."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.load")
        cargs.append(execution.input_file(self.tracks))
        return cargs


@dataclasses.dataclass
class MrviewTractographyThickness:
    """
    Line thickness of tractography display, [-1.0, 1.0], default is 0.0.
    """
    value: float
    """Line thickness of tractography display, [-1.0, 1.0], default is 0.0."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.thickness")
        cargs.append(str(self.value))
        return cargs


@dataclasses.dataclass
class MrviewTractographyGeometry:
    """
    The geometry type to use when rendering tractograms (options are:
    pseudotubes, lines, points).
    """
    value: str
    """The geometry type to use when rendering tractograms (options are:
    pseudotubes, lines, points)"""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.geometry")
        cargs.append(self.value)
        return cargs


@dataclasses.dataclass
class MrviewTractographyOpacity:
    """
    Opacity of tractography display, [0.0, 1.0], default is 1.0.
    """
    value: float
    """Opacity of tractography display, [0.0, 1.0], default is 1.0."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.opacity")
        cargs.append(str(self.value))
        return cargs


@dataclasses.dataclass
class MrviewTractographySlab:
    """
    Slab thickness of tractography display, in mm. -1 to turn off crop to slab.
    """
    value: float
    """Slab thickness of tractography display, in mm. -1 to turn off crop to
    slab."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.slab")
        cargs.append(str(self.value))
        return cargs


@dataclasses.dataclass
class MrviewTractographyLighting:
    """
    Toggle the use of lighting of tractogram geometry.
    """
    value: str
    """Toggle the use of lighting of tractogram geometry"""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.lighting")
        cargs.append(self.value)
        return cargs


@dataclasses.dataclass
class MrviewTractographyColour:
    """
    Specify a manual colour for the tractogram, as three comma-separated values.
    """
    r_g_b: list[float]
    """Specify a manual colour for the tractogram, as three comma-separated
    values"""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.colour")
        cargs.append(",".join(map(str, self.r_g_b)))
        return cargs


@dataclasses.dataclass
class MrviewTractographyTsfLoad:
    """
    Load the specified tractography scalar file.
    """
    tsf: InputPathType
    """Load the specified tractography scalar file."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.tsf_load")
        cargs.append(execution.input_file(self.tsf))
        return cargs


@dataclasses.dataclass
class MrviewTractographyTsfRange:
    """
    Set range for the tractography scalar file. Requires -tractography.tsf_load
    already provided.
    """
    range_min_range_max: list[float]
    """Set range for the tractography scalar file. Requires
    -tractography.tsf_load already provided."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.tsf_range")
        cargs.extend(map(str, self.range_min_range_max))
        return cargs


@dataclasses.dataclass
class MrviewTractographyTsfThresh:
    """
    Set thresholds for the tractography scalar file. Requires
    -tractography.tsf_load already provided.
    """
    threshold_min_theshold_max: list[float]
    """Set thresholds for the tractography scalar file. Requires
    -tractography.tsf_load already provided."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.tsf_thresh")
        cargs.extend(map(str, self.threshold_min_theshold_max))
        return cargs


@dataclasses.dataclass
class MrviewTractographyTsfColourmap:
    """
    Sets the colourmap of the .tsf file as indexed in the tsf colourmap dropdown
    menu. Requires -tractography.tsf_load already.
    """
    index: int
    """Sets the colourmap of the .tsf file as indexed in the tsf colourmap
    dropdown menu. Requires -tractography.tsf_load already."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-tractography.tsf_colourmap")
        cargs.append(str(self.index))
        return cargs


@dataclasses.dataclass
class MrviewOdfLoadSh:
    """
    Loads the specified SH-based ODF image on the ODF tool.
    """
    image: InputPathType
    """Loads the specified SH-based ODF image on the ODF tool."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-odf.load_sh")
        cargs.append(execution.input_file(self.image))
        return cargs


@dataclasses.dataclass
class MrviewOdfLoadTensor:
    """
    Loads the specified tensor image on the ODF tool.
    """
    image: InputPathType
    """Loads the specified tensor image on the ODF tool."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-odf.load_tensor")
        cargs.append(execution.input_file(self.image))
        return cargs


@dataclasses.dataclass
class MrviewOdfLoadDixel:
    """
    Loads the specified dixel-based image on the ODF tool.
    """
    image: InputPathType
    """Loads the specified dixel-based image on the ODF tool."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-odf.load_dixel")
        cargs.append(execution.input_file(self.image))
        return cargs


@dataclasses.dataclass
class MrviewFixelLoad:
    """
    Load a fixel file (any file inside a fixel directory, or an old .msf / .msh
    legacy format file) into the fixel tool.
    """
    image: InputPathType
    """Load a fixel file (any file inside a fixel directory, or an old .msf /
    .msh legacy format file) into the fixel tool."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-fixel.load")
        cargs.append(execution.input_file(self.image))
        return cargs


@dataclasses.dataclass
class MrviewConnectomeLoad:
    """
    Load a matrix file into the connectome tool.
    """
    path: InputPathType
    """Load a matrix file into the connectome tool."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-connectome.load")
        cargs.append(execution.input_file(self.path))
        return cargs


@dataclasses.dataclass
class MrviewCaptureFolder:
    """
    Set the output folder for the screen capture tool.
    """
    path: str
    """Set the output folder for the screen capture tool."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-capture.folder")
        cargs.append(self.path)
        return cargs


@dataclasses.dataclass
class MrviewCapturePrefix:
    """
    Set the output file prefix for the screen capture tool.
    """
    string_: str
    """Set the output file prefix for the screen capture tool."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-capture.prefix")
        cargs.append(self.string_)
        return cargs


@dataclasses.dataclass
class MrviewCaptureGrab:
    """
    Start the screen capture process.
    """
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-capture.grab")
        return cargs


@dataclasses.dataclass
class MrviewConfig:
    """
    temporarily set the value of an MRtrix config file entry.
    """
    key: str
    """temporarily set the value of an MRtrix config file entry."""
    value: str
    """temporarily set the value of an MRtrix config file entry."""
    
    def run(
        self,
        execution: Execution,
    ) -> list[str]:
        """
        Build command line arguments. This method is called by the main command.
        
        Args:
            execution: The execution object.
        Returns:
            Command line arguments
        """
        cargs = []
        cargs.append("-config")
        cargs.append(self.key)
        cargs.append(self.value)
        return cargs


class MrviewOutputs(typing.NamedTuple):
    """
    Output object returned when calling `mrview(...)`.
    """
    root: OutputPathType
    """Output root folder. This is the root folder for all outputs."""


def mrview(
    mode: list[MrviewMode] | None = None,
    load: list[MrviewLoad] | None = None,
    reset: list[MrviewReset] | None = None,
    fov: list[MrviewFov] | None = None,
    focus: list[MrviewFocus] | None = None,
    target: list[MrviewTarget] | None = None,
    voxel: list[MrviewVoxel] | None = None,
    volume: list[MrviewVolume] | None = None,
    plane: list[MrviewPlane] | None = None,
    lock: list[MrviewLock] | None = None,
    select_image: list[MrviewSelectImage] | None = None,
    autoscale: list[MrviewAutoscale] | None = None,
    interpolation: list[MrviewInterpolation] | None = None,
    colourmap: list[MrviewColourmap] | None = None,
    noannotations: list[MrviewNoannotations] | None = None,
    comments: list[MrviewComments] | None = None,
    voxelinfo: list[MrviewVoxelinfo] | None = None,
    orientationlabel: list[MrviewOrientationlabel] | None = None,
    colourbar: list[MrviewColourbar] | None = None,
    imagevisible: list[MrviewImagevisible] | None = None,
    intensity_range: list[MrviewIntensityRange] | None = None,
    size: list[MrviewSize] | None = None,
    position: list[MrviewPosition] | None = None,
    fullscreen: bool = False,
    exit_: bool = False,
    sync_focus: bool = False,
    fps: bool = False,
    overlay_load: list[MrviewOverlayLoad] | None = None,
    overlay_opacity: list[MrviewOverlayOpacity] | None = None,
    overlay_colourmap: list[MrviewOverlayColourmap] | None = None,
    overlay_colour: list[MrviewOverlayColour] | None = None,
    overlay_intensity: list[MrviewOverlayIntensity] | None = None,
    overlay_threshold_min: list[MrviewOverlayThresholdMin] | None = None,
    overlay_threshold_max: list[MrviewOverlayThresholdMax] | None = None,
    overlay_no_threshold_min: list[MrviewOverlayNoThresholdMin] | None = None,
    overlay_no_threshold_max: list[MrviewOverlayNoThresholdMax] | None = None,
    overlay_interpolation: list[MrviewOverlayInterpolation] | None = None,
    roi_load: list[MrviewRoiLoad] | None = None,
    roi_opacity: list[MrviewRoiOpacity] | None = None,
    roi_colour: list[MrviewRoiColour] | None = None,
    tractography_load: list[MrviewTractographyLoad] | None = None,
    tractography_thickness: list[MrviewTractographyThickness] | None = None,
    tractography_geometry: list[MrviewTractographyGeometry] | None = None,
    tractography_opacity: list[MrviewTractographyOpacity] | None = None,
    tractography_slab: list[MrviewTractographySlab] | None = None,
    tractography_lighting: list[MrviewTractographyLighting] | None = None,
    tractography_colour: list[MrviewTractographyColour] | None = None,
    tractography_tsf_load: list[MrviewTractographyTsfLoad] | None = None,
    tractography_tsf_range: list[MrviewTractographyTsfRange] | None = None,
    tractography_tsf_thresh: list[MrviewTractographyTsfThresh] | None = None,
    tractography_tsf_colourmap: list[MrviewTractographyTsfColourmap] | None = None,
    odf_load_sh: list[MrviewOdfLoadSh] | None = None,
    odf_load_tensor: list[MrviewOdfLoadTensor] | None = None,
    odf_load_dixel: list[MrviewOdfLoadDixel] | None = None,
    fixel_load: list[MrviewFixelLoad] | None = None,
    connectome_init: InputPathType | None = None,
    connectome_load: list[MrviewConnectomeLoad] | None = None,
    capture_folder: list[MrviewCaptureFolder] | None = None,
    capture_prefix: list[MrviewCapturePrefix] | None = None,
    capture_grab: list[MrviewCaptureGrab] | None = None,
    info: bool = False,
    quiet: bool = False,
    debug: bool = False,
    force: bool = False,
    nthreads: int | None = None,
    config: list[MrviewConfig] | None = None,
    help_: bool = False,
    version: bool = False,
    image: list[InputPathType] | None = None,
    runner: Runner | None = None,
) -> MrviewOutputs:
    """
    The MRtrix image viewer.
    
    Any images listed as arguments will be loaded and available through the
    image menu, with the first listed displayed initially. Any subsequent
    command-line options will be processed as if the corresponding action had
    been performed through the GUI.
    
    Note that because images loaded as arguments (i.e. simply listed on the
    command-line) are opened before the GUI is shown, subsequent actions to be
    performed via the various command-line options must appear after the last
    argument. This is to avoid confusion about which option will apply to which
    image. If you need fine control over this, please use the -load or
    -select_image options. For example:
    
    $ mrview -load image1.mif -interpolation 0 -load image2.mif -interpolation 0
    
    or
    
    $ mrview image1.mif image2.mif -interpolation 0 -select_image 2
    -interpolation 0
    
    References:
    
    Tournier, J.-D.; Calamante, F. & Connelly, A. MRtrix: Diffusion tractography
    in crossing fiber regions. Int. J. Imaging Syst. Technol., 2012, 22, 53-66.
    
    Author: J-Donald Tournier (jdtournier@gmail.com), Dave Raffelt
    (david.raffelt@florey.edu.au), Robert E. Smith (robert.smith@florey.edu.au),
    Rami Tabbara (rami.tabbara@florey.edu.au), Max Pietsch
    (maximilian.pietsch@kcl.ac.uk), Thijs Dhollander
    (thijs.dhollander@gmail.com)
    
    URL: https://mrtrix.readthedocs.io/en/latest/reference/commands/mrview.html
    
    Args:
        mode: Switch to view mode specified by the integer index, as per the\
            view menu.
        load: Load image specified and make it current.
        reset: Reset the view according to current image. This resets the FOV,\
            projection and focus.
        fov: Set the field of view, in mm.
        focus: Either set the position of the crosshairs in scanner\
            coordinates, with the new position supplied as a comma-separated list\
            of floating-point values or show or hide the focus cross hair using a\
            boolean value as argument.
        target: Set the target location for the viewing window (the scanner\
            coordinate that will appear at the centre of the viewing window.
        voxel: Set the position of the crosshairs in voxel coordinates,\
            relative the image currently displayed. The new position should be\
            supplied as a comma-separated list of floating-point values.
        volume: Set the volume index for the image displayed, as a\
            comma-separated list of integers.
        plane: Set the viewing plane, according to the mappping 0: sagittal; 1:\
            coronal; 2: axial.
        lock: Set whether view is locked to image axes (0: no, 1: yes).
        select_image: Switch to image number specified, with reference to the\
            list of currently loaded images.
        autoscale: Reset the image scaling to automatically determined range.
        interpolation: Enable or disable image interpolation in main image.
        colourmap: Switch the image colourmap to that specified, as per the\
            colourmap menu.
        noannotations: Hide all image annotation overlays.
        comments: Show or hide image comments overlay.
        voxelinfo: Show or hide voxel information overlay.
        orientationlabel: Show or hide orientation label overlay.
        colourbar: Show or hide colourbar overlay.
        imagevisible: Show or hide the main image.
        intensity_range: Set the image intensity range to that specified.
        size: Set the size of the view area, in pixel units.
        position: Set the position of the main window, in pixel units.
        fullscreen: Start fullscreen.
        exit_: Quit MRView.
        sync_focus: Sync the focus with other MRView windows that also have\
            this turned on.
        fps: Display frames per second, averaged over the last 10 frames. The\
            maximum over the last 3 seconds is also displayed.
        overlay_load: Loads the specified image on the overlay tool.
        overlay_opacity: Sets the overlay opacity to floating value [0-1].
        overlay_colourmap: Sets the colourmap of the overlay as indexed in the\
            colourmap dropdown menu.
        overlay_colour: Specify a manual colour for the overlay, as three\
            comma-separated values.
        overlay_intensity: Set the intensity windowing of the overlay.
        overlay_threshold_min: Set the lower threshold value of the overlay.
        overlay_threshold_max: Set the upper threshold value of the overlay.
        overlay_no_threshold_min: Disable the lower threshold for the overlay.
        overlay_no_threshold_max: Disable the upper threshold for the overlay.
        overlay_interpolation: Enable or disable overlay image interpolation.
        roi_load: Loads the specified image on the ROI editor tool.
        roi_opacity: Sets the overlay opacity to floating value [0-1].
        roi_colour: Sets the colour of the ROI overlay.
        tractography_load: Load the specified tracks file into the tractography\
            tool.
        tractography_thickness: Line thickness of tractography display, [-1.0,\
            1.0], default is 0.0.
        tractography_geometry: The geometry type to use when rendering\
            tractograms (options are: pseudotubes, lines, points).
        tractography_opacity: Opacity of tractography display, [0.0, 1.0],\
            default is 1.0.
        tractography_slab: Slab thickness of tractography display, in mm. -1 to\
            turn off crop to slab.
        tractography_lighting: Toggle the use of lighting of tractogram\
            geometry.
        tractography_colour: Specify a manual colour for the tractogram, as\
            three comma-separated values.
        tractography_tsf_load: Load the specified tractography scalar file.
        tractography_tsf_range: Set range for the tractography scalar file.\
            Requires -tractography.tsf_load already provided.
        tractography_tsf_thresh: Set thresholds for the tractography scalar\
            file. Requires -tractography.tsf_load already provided.
        tractography_tsf_colourmap: Sets the colourmap of the .tsf file as\
            indexed in the tsf colourmap dropdown menu. Requires\
            -tractography.tsf_load already.
        odf_load_sh: Loads the specified SH-based ODF image on the ODF tool.
        odf_load_tensor: Loads the specified tensor image on the ODF tool.
        odf_load_dixel: Loads the specified dixel-based image on the ODF tool.
        fixel_load: Load a fixel file (any file inside a fixel directory, or an\
            old .msf / .msh legacy format file) into the fixel tool.
        connectome_init: Initialise the connectome tool using a parcellation\
            image.
        connectome_load: Load a matrix file into the connectome tool.
        capture_folder: Set the output folder for the screen capture tool.
        capture_prefix: Set the output file prefix for the screen capture tool.
        capture_grab: Start the screen capture process.
        info: display information messages.
        quiet: do not display information messages or progress status;\
            alternatively, this can be achieved by setting the MRTRIX_QUIET\
            environment variable to a non-empty string.
        debug: display debugging messages.
        force: force overwrite of output files (caution: using the same file as\
            input and output might cause unexpected behaviour).
        nthreads: use this number of threads in multi-threaded applications\
            (set to 0 to disable multi-threading).
        config: temporarily set the value of an MRtrix config file entry.
        help_: display this information page and exit.
        version: display version information and exit.
        image: An image to be loaded.
        runner: Command runner.
    Returns:
        NamedTuple of outputs (described in `MrviewOutputs`).
    """
    runner = runner or get_global_runner()
    execution = runner.start_execution(MRVIEW_METADATA)
    cargs = []
    cargs.append("mrview")
    if mode is not None:
        cargs.extend([a for c in [s.run(execution) for s in mode] for a in c])
    if load is not None:
        cargs.extend([a for c in [s.run(execution) for s in load] for a in c])
    if reset is not None:
        cargs.extend([a for c in [s.run(execution) for s in reset] for a in c])
    if fov is not None:
        cargs.extend([a for c in [s.run(execution) for s in fov] for a in c])
    if focus is not None:
        cargs.extend([a for c in [s.run(execution) for s in focus] for a in c])
    if target is not None:
        cargs.extend([a for c in [s.run(execution) for s in target] for a in c])
    if voxel is not None:
        cargs.extend([a for c in [s.run(execution) for s in voxel] for a in c])
    if volume is not None:
        cargs.extend([a for c in [s.run(execution) for s in volume] for a in c])
    if plane is not None:
        cargs.extend([a for c in [s.run(execution) for s in plane] for a in c])
    if lock is not None:
        cargs.extend([a for c in [s.run(execution) for s in lock] for a in c])
    if select_image is not None:
        cargs.extend([a for c in [s.run(execution) for s in select_image] for a in c])
    if autoscale is not None:
        cargs.extend([a for c in [s.run(execution) for s in autoscale] for a in c])
    if interpolation is not None:
        cargs.extend([a for c in [s.run(execution) for s in interpolation] for a in c])
    if colourmap is not None:
        cargs.extend([a for c in [s.run(execution) for s in colourmap] for a in c])
    if noannotations is not None:
        cargs.extend([a for c in [s.run(execution) for s in noannotations] for a in c])
    if comments is not None:
        cargs.extend([a for c in [s.run(execution) for s in comments] for a in c])
    if voxelinfo is not None:
        cargs.extend([a for c in [s.run(execution) for s in voxelinfo] for a in c])
    if orientationlabel is not None:
        cargs.extend([a for c in [s.run(execution) for s in orientationlabel] for a in c])
    if colourbar is not None:
        cargs.extend([a for c in [s.run(execution) for s in colourbar] for a in c])
    if imagevisible is not None:
        cargs.extend([a for c in [s.run(execution) for s in imagevisible] for a in c])
    if intensity_range is not None:
        cargs.extend([a for c in [s.run(execution) for s in intensity_range] for a in c])
    if size is not None:
        cargs.extend([a for c in [s.run(execution) for s in size] for a in c])
    if position is not None:
        cargs.extend([a for c in [s.run(execution) for s in position] for a in c])
    if fullscreen:
        cargs.append("-fullscreen")
    if exit_:
        cargs.append("-exit")
    if sync_focus:
        cargs.append("-sync.focus")
    if fps:
        cargs.append("-fps")
    if overlay_load is not None:
        cargs.extend([a for c in [s.run(execution) for s in overlay_load] for a in c])
    if overlay_opacity is not None:
        cargs.extend([a for c in [s.run(execution) for s in overlay_opacity] for a in c])
    if overlay_colourmap is not None:
        cargs.extend([a for c in [s.run(execution) for s in overlay_colourmap] for a in c])
    if overlay_colour is not None:
        cargs.extend([a for c in [s.run(execution) for s in overlay_colour] for a in c])
    if overlay_intensity is not None:
        cargs.extend([a for c in [s.run(execution) for s in overlay_intensity] for a in c])
    if overlay_threshold_min is not None:
        cargs.extend([a for c in [s.run(execution) for s in overlay_threshold_min] for a in c])
    if overlay_threshold_max is not None:
        cargs.extend([a for c in [s.run(execution) for s in overlay_threshold_max] for a in c])
    if overlay_no_threshold_min is not None:
        cargs.extend([a for c in [s.run(execution) for s in overlay_no_threshold_min] for a in c])
    if overlay_no_threshold_max is not None:
        cargs.extend([a for c in [s.run(execution) for s in overlay_no_threshold_max] for a in c])
    if overlay_interpolation is not None:
        cargs.extend([a for c in [s.run(execution) for s in overlay_interpolation] for a in c])
    if roi_load is not None:
        cargs.extend([a for c in [s.run(execution) for s in roi_load] for a in c])
    if roi_opacity is not None:
        cargs.extend([a for c in [s.run(execution) for s in roi_opacity] for a in c])
    if roi_colour is not None:
        cargs.extend([a for c in [s.run(execution) for s in roi_colour] for a in c])
    if tractography_load is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_load] for a in c])
    if tractography_thickness is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_thickness] for a in c])
    if tractography_geometry is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_geometry] for a in c])
    if tractography_opacity is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_opacity] for a in c])
    if tractography_slab is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_slab] for a in c])
    if tractography_lighting is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_lighting] for a in c])
    if tractography_colour is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_colour] for a in c])
    if tractography_tsf_load is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_tsf_load] for a in c])
    if tractography_tsf_range is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_tsf_range] for a in c])
    if tractography_tsf_thresh is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_tsf_thresh] for a in c])
    if tractography_tsf_colourmap is not None:
        cargs.extend([a for c in [s.run(execution) for s in tractography_tsf_colourmap] for a in c])
    if odf_load_sh is not None:
        cargs.extend([a for c in [s.run(execution) for s in odf_load_sh] for a in c])
    if odf_load_tensor is not None:
        cargs.extend([a for c in [s.run(execution) for s in odf_load_tensor] for a in c])
    if odf_load_dixel is not None:
        cargs.extend([a for c in [s.run(execution) for s in odf_load_dixel] for a in c])
    if fixel_load is not None:
        cargs.extend([a for c in [s.run(execution) for s in fixel_load] for a in c])
    if connectome_init is not None:
        cargs.extend([
            "-connectome.init",
            execution.input_file(connectome_init)
        ])
    if connectome_load is not None:
        cargs.extend([a for c in [s.run(execution) for s in connectome_load] for a in c])
    if capture_folder is not None:
        cargs.extend([a for c in [s.run(execution) for s in capture_folder] for a in c])
    if capture_prefix is not None:
        cargs.extend([a for c in [s.run(execution) for s in capture_prefix] for a in c])
    if capture_grab is not None:
        cargs.extend([a for c in [s.run(execution) for s in capture_grab] for a in c])
    if info:
        cargs.append("-info")
    if quiet:
        cargs.append("-quiet")
    if debug:
        cargs.append("-debug")
    if force:
        cargs.append("-force")
    if nthreads is not None:
        cargs.extend([
            "-nthreads",
            str(nthreads)
        ])
    if config is not None:
        cargs.extend([a for c in [s.run(execution) for s in config] for a in c])
    if help_:
        cargs.append("-help")
    if version:
        cargs.append("-version")
    if image is not None:
        cargs.extend([execution.input_file(f) for f in image])
    ret = MrviewOutputs(
        root=execution.output_file("."),
    )
    execution.run(cargs)
    return ret


__all__ = [
    "MRVIEW_METADATA",
    "MrviewAutoscale",
    "MrviewCaptureFolder",
    "MrviewCaptureGrab",
    "MrviewCapturePrefix",
    "MrviewColourbar",
    "MrviewColourmap",
    "MrviewComments",
    "MrviewConfig",
    "MrviewConnectomeLoad",
    "MrviewFixelLoad",
    "MrviewFocus",
    "MrviewFov",
    "MrviewImagevisible",
    "MrviewIntensityRange",
    "MrviewInterpolation",
    "MrviewLoad",
    "MrviewLock",
    "MrviewMode",
    "MrviewNoannotations",
    "MrviewOdfLoadDixel",
    "MrviewOdfLoadSh",
    "MrviewOdfLoadTensor",
    "MrviewOrientationlabel",
    "MrviewOutputs",
    "MrviewOverlayColour",
    "MrviewOverlayColourmap",
    "MrviewOverlayIntensity",
    "MrviewOverlayInterpolation",
    "MrviewOverlayLoad",
    "MrviewOverlayNoThresholdMax",
    "MrviewOverlayNoThresholdMin",
    "MrviewOverlayOpacity",
    "MrviewOverlayThresholdMax",
    "MrviewOverlayThresholdMin",
    "MrviewPlane",
    "MrviewPosition",
    "MrviewReset",
    "MrviewRoiColour",
    "MrviewRoiLoad",
    "MrviewRoiOpacity",
    "MrviewSelectImage",
    "MrviewSize",
    "MrviewTarget",
    "MrviewTractographyColour",
    "MrviewTractographyGeometry",
    "MrviewTractographyLighting",
    "MrviewTractographyLoad",
    "MrviewTractographyOpacity",
    "MrviewTractographySlab",
    "MrviewTractographyThickness",
    "MrviewTractographyTsfColourmap",
    "MrviewTractographyTsfLoad",
    "MrviewTractographyTsfRange",
    "MrviewTractographyTsfThresh",
    "MrviewVolume",
    "MrviewVoxel",
    "MrviewVoxelinfo",
    "mrview",
]
