Skip to content

Python API: Plugins (Mixins)

These mixins contain the specific commands injected into the main FViewer class.

fviewer.plugins.image_control

ImageControlMixin

Methods for controlling the FViewer canvas display.

Source code in fviewer/plugins/image_control.py 
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class ImageControlMixin:
    """Methods for controlling the FViewer canvas display."""

    def get_colormap(self) -> str:
        """Retrieves the currently active colormap in the image viewer."""
        return self._send("get_colormap").get("colormap", "")

    def get_stretch(self) -> str:
        """Retrieves the currently active image stretch."""
        return self._send("get_stretch").get("stretch", "")

    def set_colormap(self, cmap: str) -> Dict[str, Any]:
        """Sets the colormap for the image viewer."""
        return self._send("set_colormap", cmap=cmap)

    def set_stretch(self, stretch: str) -> Dict[str, Any]:
        """Sets the stretch algorithm for the image viewer."""
        return self._send("set_stretch", stretch=stretch)

get_colormap()

Retrieves the currently active colormap in the image viewer.

Source code in fviewer/plugins/image_control.py 
 9
10
11
def get_colormap(self) -> str:
    """Retrieves the currently active colormap in the image viewer."""
    return self._send("get_colormap").get("colormap", "")

get_stretch()

Retrieves the currently active image stretch.

Source code in fviewer/plugins/image_control.py 
13
14
15
def get_stretch(self) -> str:
    """Retrieves the currently active image stretch."""
    return self._send("get_stretch").get("stretch", "")

set_colormap(cmap)

Sets the colormap for the image viewer.

Source code in fviewer/plugins/image_control.py 
17
18
19
def set_colormap(self, cmap: str) -> Dict[str, Any]:
    """Sets the colormap for the image viewer."""
    return self._send("set_colormap", cmap=cmap)

set_stretch(stretch)

Sets the stretch algorithm for the image viewer.

Source code in fviewer/plugins/image_control.py 
21
22
23
def set_stretch(self, stretch: str) -> Dict[str, Any]:
    """Sets the stretch algorithm for the image viewer."""
    return self._send("set_stretch", stretch=stretch)

fviewer.plugins.regions

RegionsMixin

Methods for managing and drawing regions on the FViewer canvas.

Source code in fviewer/plugins/regions.py 
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
class RegionsMixin:
    """Methods for managing and drawing regions on the FViewer canvas."""

    def get_regions(self, format: str = "image") -> List[Dict[str, Any]]:
        """
        Retrieves a list of all currently drawn regions from the viewer.

        Args:
            format (str): The coordinate system to return the regions in.
                Valid options are 'image' (pixel coordinates), 'physical',
                'fk5' (RA/Dec), or 'wcs'. Defaults to "image".

        Returns:
            List[Dict[str, Any]]: A list of dictionaries, where each dictionary
            represents a region and its properties (type, coordinates,
            color, etc.).

        Raises:
            ValueError: If an unsupported format string is provided.
        """
        valid_formats = ["image", "physical", "fk5", "wcs"]
        if format not in valid_formats:
            raise ValueError(
                "format must be 'image', 'physical', 'fk5', or 'wcs'"
            )

        return self._send("get_regions", format=format).get("regions", [])

    def clear_regions(self) -> Dict[str, Any]:
        """
        Removes all currently drawn regions from the canvas.

        Returns:
            Dict[str, Any]: A dictionary containing the status of the operation
            (e.g., `{"status": "ok"}`).
        """
        return self._send("clear_regions")

    def add_circle(
        self,
        x: float,
        y: float,
        radius: float,
        color: str = "#00ff00",
        format: str = "image",
        is_background: bool = False,
    ) -> Dict[str, Any]:
        """
        Draws a circular region on the image.

        Args:
            x (float): The X coordinate (or RA) of the circle's center.
            y (float): The Y coordinate (or Dec) of the circle's center.
            radius (float): The radius of the circle.
            color (str): Hex color code for the region outline.
                Defaults to "#00ff00".
            format (str): The coordinate system used for x, y, and radius.
                Options: 'image', 'physical', 'fk5', 'wcs'.
                Defaults to "image".
            is_background (bool): If True, designates this region
                as a background estimation area (typically rendered
                with a dashed line).

        Returns:
            Dict[str, Any]: Server acknowledgment of the command.
        """
        return self._send(
            "add_region",
            type="circle",
            x=x,
            y=y,
            radius=radius,
            color=color,
            format=format,
            isBackground=is_background,
        )

    def add_box(
        self,
        x: float,
        y: float,
        width: float,
        height: float,
        angle: float = 0,
        color: str = "#00ff00",
        format: str = "image",
        is_background: bool = False,
    ) -> Dict[str, Any]:
        """
        Draws a rectangular box region on the image.

        Args:
            x (float): The X coordinate (or RA) of the box's center.
            y (float): The Y coordinate (or Dec) of the box's center.
            width (float): The full width of the box.
            height (float): The full height of the box.
            angle (float): Rotation angle in degrees (counter-clockwise).
                Defaults to 0.
            color (str): Hex color code for the region outline.
                Defaults to "#00ff00".
            format (str): The coordinate system used. Defaults to "image".
            is_background (bool): Designates as a background region.
                Defaults to False.

        Returns:
            Dict[str, Any]: Server acknowledgment of the command.
        """
        return self._send(
            "add_region",
            type="box",
            x=x,
            y=y,
            width=width,
            height=height,
            angle=angle,
            color=color,
            format=format,
            isBackground=is_background,
        )

    def add_ellipse(
        self,
        x: float,
        y: float,
        rx: float,
        ry: float,
        angle: float = 0,
        color: str = "#00ff00",
        format: str = "image",
        is_background: bool = False,
    ) -> Dict[str, Any]:
        """
        Draws an elliptical region on the image.

        Args:
            x (float): The X coordinate (or RA) of the ellipse's center.
            y (float): The Y coordinate (or Dec) of the ellipse's center.
            rx (float): The semi-major axis radius.
            ry (float): The semi-minor axis radius.
            angle (float): Rotation angle in degrees. Defaults to 0.
            color (str): Hex color code for the region outline.
                Defaults to "#00ff00".
            format (str): The coordinate system used. Defaults to "image".
            is_background (bool): Designates as a background region.
                Defaults to False.

        Returns:
            Dict[str, Any]: Server acknowledgment of the command.
        """
        return self._send(
            "add_region",
            type="ellipse",
            x=x,
            y=y,
            rx=rx,
            ry=ry,
            angle=angle,
            color=color,
            format=format,
            isBackground=is_background,
        )

    def add_annulus(
        self,
        x: float,
        y: float,
        inner_r: float,
        outer_r: float,
        color: str = "#00ff00",
        format: str = "image",
        is_background: bool = False,
    ) -> Dict[str, Any]:
        """
        Draws an annular (ring) region on the image.

        Args:
            x (float): The X coordinate (or RA) of the annulus center.
            y (float): The Y coordinate (or Dec) of the annulus center.
            inner_r (float): The inner radius of the ring.
            outer_r (float): The outer radius of the ring.
            color (str): Hex color code for the region outline.
                Defaults to "#00ff00".
            format (str): The coordinate system used. Defaults to "image".
            is_background (bool): Designates as a background region.
                Defaults to False.

        Returns:
            Dict[str, Any]: Server acknowledgment of the command.
        """
        return self._send(
            "add_region",
            type="annulus",
            x=x,
            y=y,
            innerR=inner_r,
            outerR=outer_r,
            color=color,
            format=format,
            isBackground=is_background,
        )

    def load_regions(self, filepath: str) -> Dict[str, Any]:
        """
        Reads a local DS9 `.reg` file and applies it to the viewer.

        Args:
            filepath (str): The absolute or relative path to the
                region file on disk.

        Returns:
            Dict[str, Any]: Server acknowledgment after parsing and drawing.
        """
        with open(filepath, "r") as f:
            content = f.read()

        return self._send("load_regions_from_string", content=content)

    def save_regions(
        self, filepath: str, format: str = "image"
    ) -> Dict[str, str]:
        """
        Fetches regions from the viewer and saves them to a `.reg` file.

        This method requests a formatted DS9 region string from the React
        frontend and writes it securely to the local disk. It includes
        safeguards against unsupported extensions and excessively large
        memory payloads.

        Args:
            filepath (str): The destination path for the saved file.
                Must end with '.reg' or '.txt'.
            format (str): The coordinate system to save the regions in.
                Options: 'image' or 'fk5'. Defaults to "image".

        Returns:
            Dict[str, str]: A dictionary containing the status and the
                saved file path.

        Raises:
            ValueError: If an invalid format or unsafe file extension is
                provided.
            RuntimeError: If the region payload returned by the UI exceeds 5MB.
        """
        if format not in ["image", "physical", "fk5"]:
            raise ValueError("format must be 'image' or 'fk5'")

        safe_exts = (".reg", ".txt")
        if not filepath.lower().endswith(safe_exts):
            raise ValueError(
                f"For security, filepath must end with {safe_exts}"
            )

        response = self._send("get_regions_string", format=format)
        content = response.get("content", "")

        max_bytes = 5 * 1024 * 1024
        if len(content.encode("utf-8")) > max_bytes:
            raise RuntimeError(
                "Received region data exceeds 5MB limit. Aborting save."
            )

        with open(filepath, "w") as f:
            f.write(content)

        return {"status": "ok", "file": filepath}

add_annulus(x, y, inner_r, outer_r, color='#00ff00', format='image', is_background=False)

Draws an annular (ring) region on the image.

Parameters:

Name Type Description Default
x float

The X coordinate (or RA) of the annulus center.

 required
y float

The Y coordinate (or Dec) of the annulus center.

 required
inner_r float

The inner radius of the ring.

 required
outer_r float

The outer radius of the ring.

 required
color str

Hex color code for the region outline. Defaults to "#00ff00".

 '#00ff00'
format str

The coordinate system used. Defaults to "image".

 'image'
is_background bool

Designates as a background region. Defaults to False.

 False

Returns:

Type Description
Dict[str, Any]

Dict[str, Any]: Server acknowledgment of the command.
Source code in fviewer/plugins/regions.py 
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
def add_annulus(
    self,
    x: float,
    y: float,
    inner_r: float,
    outer_r: float,
    color: str = "#00ff00",
    format: str = "image",
    is_background: bool = False,
) -> Dict[str, Any]:
    """
    Draws an annular (ring) region on the image.

    Args:
        x (float): The X coordinate (or RA) of the annulus center.
        y (float): The Y coordinate (or Dec) of the annulus center.
        inner_r (float): The inner radius of the ring.
        outer_r (float): The outer radius of the ring.
        color (str): Hex color code for the region outline.
            Defaults to "#00ff00".
        format (str): The coordinate system used. Defaults to "image".
        is_background (bool): Designates as a background region.
            Defaults to False.

    Returns:
        Dict[str, Any]: Server acknowledgment of the command.
    """
    return self._send(
        "add_region",
        type="annulus",
        x=x,
        y=y,
        innerR=inner_r,
        outerR=outer_r,
        color=color,
        format=format,
        isBackground=is_background,
    )

add_box(x, y, width, height, angle=0, color='#00ff00', format='image', is_background=False)

Draws a rectangular box region on the image.

Parameters:

Name Type Description Default
x float

The X coordinate (or RA) of the box's center.

 required
y float

The Y coordinate (or Dec) of the box's center.

 required
width float

The full width of the box.

 required
height float

The full height of the box.

 required
angle float

Rotation angle in degrees (counter-clockwise). Defaults to 0.

 0
color str

Hex color code for the region outline. Defaults to "#00ff00".

 '#00ff00'
format str

The coordinate system used. Defaults to "image".

 'image'
is_background bool

Designates as a background region. Defaults to False.

 False

Returns:

Type Description
Dict[str, Any]

Dict[str, Any]: Server acknowledgment of the command.
Source code in fviewer/plugins/regions.py 
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
def add_box(
    self,
    x: float,
    y: float,
    width: float,
    height: float,
    angle: float = 0,
    color: str = "#00ff00",
    format: str = "image",
    is_background: bool = False,
) -> Dict[str, Any]:
    """
    Draws a rectangular box region on the image.

    Args:
        x (float): The X coordinate (or RA) of the box's center.
        y (float): The Y coordinate (or Dec) of the box's center.
        width (float): The full width of the box.
        height (float): The full height of the box.
        angle (float): Rotation angle in degrees (counter-clockwise).
            Defaults to 0.
        color (str): Hex color code for the region outline.
            Defaults to "#00ff00".
        format (str): The coordinate system used. Defaults to "image".
        is_background (bool): Designates as a background region.
            Defaults to False.

    Returns:
        Dict[str, Any]: Server acknowledgment of the command.
    """
    return self._send(
        "add_region",
        type="box",
        x=x,
        y=y,
        width=width,
        height=height,
        angle=angle,
        color=color,
        format=format,
        isBackground=is_background,
    )

add_circle(x, y, radius, color='#00ff00', format='image', is_background=False)

Draws a circular region on the image.

Parameters:

Name Type Description Default
x float

The X coordinate (or RA) of the circle's center.

 required
y float

The Y coordinate (or Dec) of the circle's center.

 required
radius float

The radius of the circle.

 required
color str

Hex color code for the region outline. Defaults to "#00ff00".

 '#00ff00'
format str

The coordinate system used for x, y, and radius. Options: 'image', 'physical', 'fk5', 'wcs'. Defaults to "image".

 'image'
is_background bool

If True, designates this region as a background estimation area (typically rendered with a dashed line).

 False

Returns:

Type Description
Dict[str, Any]

Dict[str, Any]: Server acknowledgment of the command.
Source code in fviewer/plugins/regions.py 
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
def add_circle(
    self,
    x: float,
    y: float,
    radius: float,
    color: str = "#00ff00",
    format: str = "image",
    is_background: bool = False,
) -> Dict[str, Any]:
    """
    Draws a circular region on the image.

    Args:
        x (float): The X coordinate (or RA) of the circle's center.
        y (float): The Y coordinate (or Dec) of the circle's center.
        radius (float): The radius of the circle.
        color (str): Hex color code for the region outline.
            Defaults to "#00ff00".
        format (str): The coordinate system used for x, y, and radius.
            Options: 'image', 'physical', 'fk5', 'wcs'.
            Defaults to "image".
        is_background (bool): If True, designates this region
            as a background estimation area (typically rendered
            with a dashed line).

    Returns:
        Dict[str, Any]: Server acknowledgment of the command.
    """
    return self._send(
        "add_region",
        type="circle",
        x=x,
        y=y,
        radius=radius,
        color=color,
        format=format,
        isBackground=is_background,
    )

add_ellipse(x, y, rx, ry, angle=0, color='#00ff00', format='image', is_background=False)

Draws an elliptical region on the image.

Parameters:

Name Type Description Default
x float

The X coordinate (or RA) of the ellipse's center.

 required
y float

The Y coordinate (or Dec) of the ellipse's center.

 required
rx float

The semi-major axis radius.

 required
ry float

The semi-minor axis radius.

 required
angle float

Rotation angle in degrees. Defaults to 0.

 0
color str

Hex color code for the region outline. Defaults to "#00ff00".

 '#00ff00'
format str

The coordinate system used. Defaults to "image".

 'image'
is_background bool

Designates as a background region. Defaults to False.

 False

Returns:

Type Description
Dict[str, Any]

Dict[str, Any]: Server acknowledgment of the command.
Source code in fviewer/plugins/regions.py 
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
def add_ellipse(
    self,
    x: float,
    y: float,
    rx: float,
    ry: float,
    angle: float = 0,
    color: str = "#00ff00",
    format: str = "image",
    is_background: bool = False,
) -> Dict[str, Any]:
    """
    Draws an elliptical region on the image.

    Args:
        x (float): The X coordinate (or RA) of the ellipse's center.
        y (float): The Y coordinate (or Dec) of the ellipse's center.
        rx (float): The semi-major axis radius.
        ry (float): The semi-minor axis radius.
        angle (float): Rotation angle in degrees. Defaults to 0.
        color (str): Hex color code for the region outline.
            Defaults to "#00ff00".
        format (str): The coordinate system used. Defaults to "image".
        is_background (bool): Designates as a background region.
            Defaults to False.

    Returns:
        Dict[str, Any]: Server acknowledgment of the command.
    """
    return self._send(
        "add_region",
        type="ellipse",
        x=x,
        y=y,
        rx=rx,
        ry=ry,
        angle=angle,
        color=color,
        format=format,
        isBackground=is_background,
    )

clear_regions()

Removes all currently drawn regions from the canvas.

Returns:

Type Description
Dict[str, Any]

Dict[str, Any]: A dictionary containing the status of the operation
Dict[str, Any]

(e.g., {"status": "ok"}).
Source code in fviewer/plugins/regions.py 
34
35
36
37
38
39
40
41
42
def clear_regions(self) -> Dict[str, Any]:
    """
    Removes all currently drawn regions from the canvas.

    Returns:
        Dict[str, Any]: A dictionary containing the status of the operation
        (e.g., `{"status": "ok"}`).
    """
    return self._send("clear_regions")

get_regions(format='image')

Retrieves a list of all currently drawn regions from the viewer.

Parameters:

Name Type Description Default
format str

The coordinate system to return the regions in. Valid options are 'image' (pixel coordinates), 'physical', 'fk5' (RA/Dec), or 'wcs'. Defaults to "image".

 'image'

Returns:

Type Description
List[Dict[str, Any]]

List[Dict[str, Any]]: A list of dictionaries, where each dictionary
List[Dict[str, Any]]

represents a region and its properties (type, coordinates,
List[Dict[str, Any]]

color, etc.).

Raises:

Type Description
ValueError

If an unsupported format string is provided.
Source code in fviewer/plugins/regions.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def get_regions(self, format: str = "image") -> List[Dict[str, Any]]:
    """
    Retrieves a list of all currently drawn regions from the viewer.

    Args:
        format (str): The coordinate system to return the regions in.
            Valid options are 'image' (pixel coordinates), 'physical',
            'fk5' (RA/Dec), or 'wcs'. Defaults to "image".

    Returns:
        List[Dict[str, Any]]: A list of dictionaries, where each dictionary
        represents a region and its properties (type, coordinates,
        color, etc.).

    Raises:
        ValueError: If an unsupported format string is provided.
    """
    valid_formats = ["image", "physical", "fk5", "wcs"]
    if format not in valid_formats:
        raise ValueError(
            "format must be 'image', 'physical', 'fk5', or 'wcs'"
        )

    return self._send("get_regions", format=format).get("regions", [])

load_regions(filepath)

Reads a local DS9 .reg file and applies it to the viewer.

Parameters:

Name Type Description Default
filepath str

The absolute or relative path to the region file on disk.

 required

Returns:

Type Description
Dict[str, Any]

Dict[str, Any]: Server acknowledgment after parsing and drawing.
Source code in fviewer/plugins/regions.py 
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
def load_regions(self, filepath: str) -> Dict[str, Any]:
    """
    Reads a local DS9 `.reg` file and applies it to the viewer.

    Args:
        filepath (str): The absolute or relative path to the
            region file on disk.

    Returns:
        Dict[str, Any]: Server acknowledgment after parsing and drawing.
    """
    with open(filepath, "r") as f:
        content = f.read()

    return self._send("load_regions_from_string", content=content)

save_regions(filepath, format='image')

Fetches regions from the viewer and saves them to a .reg file.

This method requests a formatted DS9 region string from the React frontend and writes it securely to the local disk. It includes safeguards against unsupported extensions and excessively large memory payloads.

Parameters:

Name Type Description Default
filepath str

The destination path for the saved file. Must end with '.reg' or '.txt'.

 required
format str

The coordinate system to save the regions in. Options: 'image' or 'fk5'. Defaults to "image".

 'image'

Returns:

Type Description
Dict[str, str]

Dict[str, str]: A dictionary containing the status and the saved file path.

Raises:

Type Description
ValueError

If an invalid format or unsafe file extension is provided.
RuntimeError

If the region payload returned by the UI exceeds 5MB.
Source code in fviewer/plugins/regions.py 
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
def save_regions(
    self, filepath: str, format: str = "image"
) -> Dict[str, str]:
    """
    Fetches regions from the viewer and saves them to a `.reg` file.

    This method requests a formatted DS9 region string from the React
    frontend and writes it securely to the local disk. It includes
    safeguards against unsupported extensions and excessively large
    memory payloads.

    Args:
        filepath (str): The destination path for the saved file.
            Must end with '.reg' or '.txt'.
        format (str): The coordinate system to save the regions in.
            Options: 'image' or 'fk5'. Defaults to "image".

    Returns:
        Dict[str, str]: A dictionary containing the status and the
            saved file path.

    Raises:
        ValueError: If an invalid format or unsafe file extension is
            provided.
        RuntimeError: If the region payload returned by the UI exceeds 5MB.
    """
    if format not in ["image", "physical", "fk5"]:
        raise ValueError("format must be 'image' or 'fk5'")

    safe_exts = (".reg", ".txt")
    if not filepath.lower().endswith(safe_exts):
        raise ValueError(
            f"For security, filepath must end with {safe_exts}"
        )

    response = self._send("get_regions_string", format=format)
    content = response.get("content", "")

    max_bytes = 5 * 1024 * 1024
    if len(content.encode("utf-8")) > max_bytes:
        raise RuntimeError(
            "Received region data exceeds 5MB limit. Aborting save."
        )

    with open(filepath, "w") as f:
        f.write(content)

    return {"status": "ok", "file": filepath}

fviewer.plugins.datacube

DataCubeMixin

Source code in fviewer/plugins/datacube.py 
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
class DataCubeMixin:
    def set_slice(self, slice_indices: list[int]):
        """
        Set the current frame/slice for multidimensional FITS data cubes.

        Args:
            slice_indices: A list of 1-based indices for the extra dimensions.
                           For a 3D cube (X, Y, Z), pass [Z].
                           For a 4D cube (X, Y, Z, W), pass [Z, W].

        Example:
            viewer.set_slice([42])     # Move to Z=42
            viewer.set_slice([42, 5])  # Move to Z=42, W=5
        """
        if not isinstance(slice_indices, list):
            # Allow users to pass a single integer for 3D cubes convenience
            slice_indices = [slice_indices]

        return self._send("set_slice", sliceIndices=slice_indices)

set_slice(slice_indices)

Set the current frame/slice for multidimensional FITS data cubes.

Parameters:

Name Type Description Default
slice_indices list[int]

A list of 1-based indices for the extra dimensions. For a 3D cube (X, Y, Z), pass [Z]. For a 4D cube (X, Y, Z, W), pass [Z, W].

 required
Example

viewer.set_slice([42]) # Move to Z=42 viewer.set_slice([42, 5]) # Move to Z=42, W=5

Source code in fviewer/plugins/datacube.py 
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def set_slice(self, slice_indices: list[int]):
    """
    Set the current frame/slice for multidimensional FITS data cubes.

    Args:
        slice_indices: A list of 1-based indices for the extra dimensions.
                       For a 3D cube (X, Y, Z), pass [Z].
                       For a 4D cube (X, Y, Z, W), pass [Z, W].

    Example:
        viewer.set_slice([42])     # Move to Z=42
        viewer.set_slice([42, 5])  # Move to Z=42, W=5
    """
    if not isinstance(slice_indices, list):
        # Allow users to pass a single integer for 3D cubes convenience
        slice_indices = [slice_indices]

    return self._send("set_slice", sliceIndices=slice_indices)