_options_mixin.py

# This file is automatically generated by scripts/generate_options_mixin.py
# Do not edit this file directly
from __future__ import annotations
import typing

from ._constants import SliceType, MuliplanarType, DragMode

__all__ = ["OptionsMixin"]

class OptionsMixin:
    @property
    def text_height(self) -> float:
        return self._opts.get('textHeight', 0.06)

    @text_height.setter
    def text_height(self, value: float):
        self._opts = { **self._opts, "textHeight": value }

    @property
    def colorbar_height(self) -> float:
        return self._opts.get('colorbarHeight', 0.05)

    @colorbar_height.setter
    def colorbar_height(self, value: float):
        self._opts = { **self._opts, "colorbarHeight": value }

    @property
    def crosshair_width(self) -> int:
        return self._opts.get('crosshairWidth', 1)

    @crosshair_width.setter
    def crosshair_width(self, value: int):
        self._opts = { **self._opts, "crosshairWidth": value }

    @property
    def ruler_width(self) -> int:
        return self._opts.get('rulerWidth', 4)

    @ruler_width.setter
    def ruler_width(self, value: int):
        self._opts = { **self._opts, "rulerWidth": value }

    @property
    def show3_dcrosshair(self) -> bool:
        return self._opts.get('show3Dcrosshair', False)

    @show3_dcrosshair.setter
    def show3_dcrosshair(self, value: bool):
        self._opts = { **self._opts, "show3Dcrosshair": value }

    @property
    def back_color(self) -> tuple:
        return self._opts.get('backColor', (0, 0, 0, 1))

    @back_color.setter
    def back_color(self, value: tuple):
        self._opts = { **self._opts, "backColor": value }

    @property
    def crosshair_color(self) -> tuple:
        return self._opts.get('crosshairColor', (1, 0, 0, 1))

    @crosshair_color.setter
    def crosshair_color(self, value: tuple):
        self._opts = { **self._opts, "crosshairColor": value }

    @property
    def font_color(self) -> tuple:
        return self._opts.get('fontColor', (0.5, 0.5, 0.5, 1))

    @font_color.setter
    def font_color(self, value: tuple):
        self._opts = { **self._opts, "fontColor": value }

    @property
    def selection_box_color(self) -> tuple:
        return self._opts.get('selectionBoxColor', (1, 1, 1, 0.5))

    @selection_box_color.setter
    def selection_box_color(self, value: tuple):
        self._opts = { **self._opts, "selectionBoxColor": value }

    @property
    def clip_plane_color(self) -> tuple:
        return self._opts.get('clipPlaneColor', (0.7, 0, 0.7, 0.5))

    @clip_plane_color.setter
    def clip_plane_color(self, value: tuple):
        self._opts = { **self._opts, "clipPlaneColor": value }

    @property
    def ruler_color(self) -> tuple:
        return self._opts.get('rulerColor', (1, 0, 0, 0.8))

    @ruler_color.setter
    def ruler_color(self, value: tuple):
        self._opts = { **self._opts, "rulerColor": value }

    @property
    def colorbar_margin(self) -> float:
        return self._opts.get('colorbarMargin', 0.05)

    @colorbar_margin.setter
    def colorbar_margin(self, value: float):
        self._opts = { **self._opts, "colorbarMargin": value }

    @property
    def trust_cal_min_max(self) -> bool:
        return self._opts.get('trustCalMinMax', True)

    @trust_cal_min_max.setter
    def trust_cal_min_max(self, value: bool):
        self._opts = { **self._opts, "trustCalMinMax": value }

    @property
    def clip_plane_hot_key(self) -> str:
        return self._opts.get('clipPlaneHotKey', 'KeyC')

    @clip_plane_hot_key.setter
    def clip_plane_hot_key(self, value: str):
        self._opts = { **self._opts, "clipPlaneHotKey": value }

    @property
    def view_mode_hot_key(self) -> str:
        return self._opts.get('viewModeHotKey', 'KeyV')

    @view_mode_hot_key.setter
    def view_mode_hot_key(self, value: str):
        self._opts = { **self._opts, "viewModeHotKey": value }

    @property
    def double_touch_timeout(self) -> int:
        return self._opts.get('doubleTouchTimeout', 500)

    @double_touch_timeout.setter
    def double_touch_timeout(self, value: int):
        self._opts = { **self._opts, "doubleTouchTimeout": value }

    @property
    def long_touch_timeout(self) -> int:
        return self._opts.get('longTouchTimeout', 1000)

    @long_touch_timeout.setter
    def long_touch_timeout(self, value: int):
        self._opts = { **self._opts, "longTouchTimeout": value }

    @property
    def key_debounce_time(self) -> int:
        return self._opts.get('keyDebounceTime', 50)

    @key_debounce_time.setter
    def key_debounce_time(self, value: int):
        self._opts = { **self._opts, "keyDebounceTime": value }

    @property
    def is_nearest_interpolation(self) -> bool:
        return self._opts.get('isNearestInterpolation', False)

    @is_nearest_interpolation.setter
    def is_nearest_interpolation(self, value: bool):
        self._opts = { **self._opts, "isNearestInterpolation": value }

    @property
    def is_resize_canvas(self) -> bool:
        return self._opts.get('isResizeCanvas', True)

    @is_resize_canvas.setter
    def is_resize_canvas(self, value: bool):
        self._opts = { **self._opts, "isResizeCanvas": value }

    @property
    def is_atlas_outline(self) -> bool:
        return self._opts.get('isAtlasOutline', False)

    @is_atlas_outline.setter
    def is_atlas_outline(self, value: bool):
        self._opts = { **self._opts, "isAtlasOutline": value }

    @property
    def is_ruler(self) -> bool:
        return self._opts.get('isRuler', False)

    @is_ruler.setter
    def is_ruler(self, value: bool):
        self._opts = { **self._opts, "isRuler": value }

    @property
    def is_colorbar(self) -> bool:
        return self._opts.get('isColorbar', False)

    @is_colorbar.setter
    def is_colorbar(self, value: bool):
        self._opts = { **self._opts, "isColorbar": value }

    @property
    def is_orient_cube(self) -> bool:
        return self._opts.get('isOrientCube', False)

    @is_orient_cube.setter
    def is_orient_cube(self, value: bool):
        self._opts = { **self._opts, "isOrientCube": value }

    @property
    def multiplanar_pad_pixels(self) -> int:
        return self._opts.get('multiplanarPadPixels', 0)

    @multiplanar_pad_pixels.setter
    def multiplanar_pad_pixels(self, value: int):
        self._opts = { **self._opts, "multiplanarPadPixels": value }

    @property
    def multiplanar_force_render(self) -> bool:
        return self._opts.get('multiplanarForceRender', False)

    @multiplanar_force_render.setter
    def multiplanar_force_render(self, value: bool):
        self._opts = { **self._opts, "multiplanarForceRender": value }

    @property
    def is_radiological_convention(self) -> bool:
        return self._opts.get('isRadiologicalConvention', False)

    @is_radiological_convention.setter
    def is_radiological_convention(self, value: bool):
        self._opts = { **self._opts, "isRadiologicalConvention": value }

    @property
    def mesh_thickness_on2_d(self) -> float:
        return self._opts.get('meshThicknessOn2D', inf)

    @mesh_thickness_on2_d.setter
    def mesh_thickness_on2_d(self, value: float):
        self._opts = { **self._opts, "meshThicknessOn2D": value }

    @property
    def drag_mode(self) -> DragMode:
        return self._opts.get('dragMode', DragMode.CONTRAST)

    @drag_mode.setter
    def drag_mode(self, value: DragMode):
        self._opts = { **self._opts, "dragMode": value }

    @property
    def yoke3_dto2_d_zoom(self) -> bool:
        return self._opts.get('yoke3Dto2DZoom', False)

    @yoke3_dto2_d_zoom.setter
    def yoke3_dto2_d_zoom(self, value: bool):
        self._opts = { **self._opts, "yoke3Dto2DZoom": value }

    @property
    def is_depth_pick_mesh(self) -> bool:
        return self._opts.get('isDepthPickMesh', False)

    @is_depth_pick_mesh.setter
    def is_depth_pick_mesh(self, value: bool):
        self._opts = { **self._opts, "isDepthPickMesh": value }

    @property
    def is_corner_orientation_text(self) -> bool:
        return self._opts.get('isCornerOrientationText', False)

    @is_corner_orientation_text.setter
    def is_corner_orientation_text(self, value: bool):
        self._opts = { **self._opts, "isCornerOrientationText": value }

    @property
    def sagittal_nose_left(self) -> bool:
        return self._opts.get('sagittalNoseLeft', False)

    @sagittal_nose_left.setter
    def sagittal_nose_left(self, value: bool):
        self._opts = { **self._opts, "sagittalNoseLeft": value }

    @property
    def is_slice_m_m(self) -> bool:
        return self._opts.get('isSliceMM', False)

    @is_slice_m_m.setter
    def is_slice_m_m(self, value: bool):
        self._opts = { **self._opts, "isSliceMM": value }

    @property
    def is_v1_slice_shader(self) -> bool:
        return self._opts.get('isV1SliceShader', False)

    @is_v1_slice_shader.setter
    def is_v1_slice_shader(self, value: bool):
        self._opts = { **self._opts, "isV1SliceShader": value }

    @property
    def is_high_resolution_capable(self) -> bool:
        return self._opts.get('isHighResolutionCapable', True)

    @is_high_resolution_capable.setter
    def is_high_resolution_capable(self, value: bool):
        self._opts = { **self._opts, "isHighResolutionCapable": value }

    @property
    def log_level(self) -> str:
        return self._opts.get('logLevel', 'info')

    @log_level.setter
    def log_level(self, value: str):
        self._opts = { **self._opts, "logLevel": value }

    @property
    def loading_text(self) -> str:
        return self._opts.get('loadingText', 'waiting for images...')

    @loading_text.setter
    def loading_text(self, value: str):
        self._opts = { **self._opts, "loadingText": value }

    @property
    def is_force_mouse_click_to_voxel_centers(self) -> bool:
        return self._opts.get('isForceMouseClickToVoxelCenters', False)

    @is_force_mouse_click_to_voxel_centers.setter
    def is_force_mouse_click_to_voxel_centers(self, value: bool):
        self._opts = { **self._opts, "isForceMouseClickToVoxelCenters": value }

    @property
    def drag_and_drop_enabled(self) -> bool:
        return self._opts.get('dragAndDropEnabled', True)

    @drag_and_drop_enabled.setter
    def drag_and_drop_enabled(self, value: bool):
        self._opts = { **self._opts, "dragAndDropEnabled": value }

    @property
    def drawing_enabled(self) -> bool:
        return self._opts.get('drawingEnabled', False)

    @drawing_enabled.setter
    def drawing_enabled(self, value: bool):
        self._opts = { **self._opts, "drawingEnabled": value }

    @property
    def pen_value(self) -> int:
        return self._opts.get('penValue', 1)

    @pen_value.setter
    def pen_value(self, value: int):
        self._opts = { **self._opts, "penValue": value }

    @property
    def flood_fill_neighbors(self) -> int:
        return self._opts.get('floodFillNeighbors', 6)

    @flood_fill_neighbors.setter
    def flood_fill_neighbors(self, value: int):
        self._opts = { **self._opts, "floodFillNeighbors": value }

    @property
    def is_filled_pen(self) -> bool:
        return self._opts.get('isFilledPen', False)

    @is_filled_pen.setter
    def is_filled_pen(self, value: bool):
        self._opts = { **self._opts, "isFilledPen": value }

    @property
    def thumbnail(self) -> str:
        return self._opts.get('thumbnail', '')

    @thumbnail.setter
    def thumbnail(self, value: str):
        self._opts = { **self._opts, "thumbnail": value }

    @property
    def max_draw_undo_bitmaps(self) -> int:
        return self._opts.get('maxDrawUndoBitmaps', 8)

    @max_draw_undo_bitmaps.setter
    def max_draw_undo_bitmaps(self, value: int):
        self._opts = { **self._opts, "maxDrawUndoBitmaps": value }

    @property
    def slice_type(self) -> SliceType:
        return self._opts.get('sliceType', SliceType.MULTIPLANAR)

    @slice_type.setter
    def slice_type(self, value: SliceType):
        self._opts = { **self._opts, "sliceType": value }

    @property
    def mesh_x_ray(self) -> float:
        return self._opts.get('meshXRay', 0.0)

    @mesh_x_ray.setter
    def mesh_x_ray(self, value: float):
        self._opts = { **self._opts, "meshXRay": value }

    @property
    def is_anti_alias(self) -> typing.Any:
        return self._opts.get('isAntiAlias', None)

    @is_anti_alias.setter
    def is_anti_alias(self, value: typing.Any):
        self._opts = { **self._opts, "isAntiAlias": value }

    @property
    def limit_frames4_d(self) -> float:
        return self._opts.get('limitFrames4D', nan)

    @limit_frames4_d.setter
    def limit_frames4_d(self, value: float):
        self._opts = { **self._opts, "limitFrames4D": value }

    @property
    def is_additive_blend(self) -> bool:
        return self._opts.get('isAdditiveBlend', False)

    @is_additive_blend.setter
    def is_additive_blend(self, value: bool):
        self._opts = { **self._opts, "isAdditiveBlend": value }

    @property
    def show_legend(self) -> bool:
        return self._opts.get('showLegend', True)

    @show_legend.setter
    def show_legend(self, value: bool):
        self._opts = { **self._opts, "showLegend": value }

    @property
    def legend_background_color(self) -> tuple:
        return self._opts.get('legendBackgroundColor', (0.3, 0.3, 0.3, 0.5))

    @legend_background_color.setter
    def legend_background_color(self, value: tuple):
        self._opts = { **self._opts, "legendBackgroundColor": value }

    @property
    def legend_text_color(self) -> tuple:
        return self._opts.get('legendTextColor', (1.0, 1.0, 1.0, 1.0))

    @legend_text_color.setter
    def legend_text_color(self, value: tuple):
        self._opts = { **self._opts, "legendTextColor": value }

    @property
    def multiplanar_layout(self) -> MuliplanarType:
        return self._opts.get('multiplanarLayout', MuliplanarType.AUTO)

    @multiplanar_layout.setter
    def multiplanar_layout(self, value: MuliplanarType):
        self._opts = { **self._opts, "multiplanarLayout": value }

    @property
    def render_overlay_blend(self) -> float:
        return self._opts.get('renderOverlayBlend', 1.0)

    @render_overlay_blend.setter
    def render_overlay_blend(self, value: float):
        self._opts = { **self._opts, "renderOverlayBlend": value }