"""Module containing pyvista implementation of :vtk:`vtkCamera`."""

from __future__ import annotations

from pathlib import Path
from weakref import proxy
import xml.dom.minidom as md
from xml.etree import ElementTree as ET

import numpy as np

import pyvista as pv
from pyvista import _vtk
from pyvista._deprecate_positional_args import _deprecate_positional_args
from pyvista.core._vtk_utilities import DisableVtkSnakeCase
from pyvista.core.utilities.misc import _NoNewAttrMixin

from .helpers import view_vectors


class Camera(_NoNewAttrMixin, DisableVtkSnakeCase, _vtk.vtkCamera):
    """PyVista wrapper for the VTK Camera class.

    Parameters
    ----------
    renderer : pyvista.Renderer, optional
        Renderer to attach the camera to.

    Examples
    --------
    Create a camera at the pyvista module level.

    >>> import pyvista as pv
    >>> camera = pv.Camera()

    Access the active camera of a plotter and get the position of the
    camera.

    >>> pl = pv.Plotter()
    >>> pl.camera.position
    (1.0, 1.0, 1.0)

    """

    def __init__(self, renderer=None):
        """Initialize a new camera descriptor."""
        self._parallel_projection = False
        self._elevation = 0.0
        self._azimuth = 0.0
        self._is_set = False
        self._focus = None  # Used by BackgroundRenderer

        if renderer:
            if not isinstance(renderer, pv.Renderer):
                msg = 'Camera only accepts a pyvista.Renderer or None as the ``renderer`` argument'
                raise TypeError(msg)
            self._renderer = proxy(renderer)
        else:
            self._renderer = None  # type: ignore[assignment]

    def __eq__(self, other) -> bool:
        """Compare whether the relevant attributes of two cameras are equal."""
        # attributes which are native python types and thus implement __eq__

        native_attrs = [
            'position',
            'focal_point',
            'parallel_projection',
            'distance',
            'thickness',
            'parallel_scale',
            'clipping_range',
            'view_angle',
            'roll',
        ]
        for attr in native_attrs:
            if getattr(self, attr) != getattr(other, attr):
                return False

        this_trans = self.model_transform_matrix
        that_trans = other.model_transform_matrix
        trans_count = sum(1 for trans in [this_trans, that_trans] if trans is not None)
        if trans_count == 1:
            # either but not both are None
            return False
        return not (trans_count == 2 and not np.array_equal(this_trans, that_trans))

    __hash__ = None  # type: ignore[assignment]  # https://github.com/pyvista/pyvista/pull/7671

    def __repr__(self):
        """Print a repr specifying the id of the camera and its camera type."""
        repr_str = f'{self.__class__.__name__} ({hex(id(self))})'
        repr_str += f'\n  Position:            {self.position}'
        repr_str += f'\n  Focal Point:         {self.focal_point}'
        repr_str += f'\n  Parallel Projection: {self.parallel_projection}'
        repr_str += f'\n  Distance:            {self.distance}'
        repr_str += f'\n  Thickness:           {self.thickness}'
        repr_str += f'\n  Parallel Scale:      {self.parallel_scale}'
        repr_str += f'\n  Clipping Range:      {self.clipping_range}'
        repr_str += f'\n  View Angle:          {self.view_angle}'
        repr_str += f'\n  Roll:                {self.roll}'
        return repr_str

    def __str__(self):
        """Return the object string representation."""
        return self.__repr__()

    def __del__(self):
        """Delete the camera."""
        self.RemoveAllObservers()

    @property
    def is_set(self) -> bool:  # numpydoc ignore=RT01
        """Get or set whether this camera has been configured."""
        return self._is_set

    @is_set.setter
    def is_set(self, value: bool):
        self._is_set = bool(value)

    @classmethod
    def from_paraview_pvcc(cls, filename: str | Path) -> Camera:
        """Load a Paraview camera file (.pvcc extension).

        Returns a pyvista.Camera object for which attributes has been read
        from the filename argument.

        Parameters
        ----------
        filename : str or pathlib.Path
            Path to Paraview camera file (.pvcc).

        Returns
        -------
        pyvista.Camera
            Camera from the camera file.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera = pv.Camera.from_paraview_pvcc('camera.pvcc')  # doctest:+SKIP
        >>> pl.camera.position
        (1.0, 1.0, 1.0)

        """
        to_find = {
            'CameraPosition': ('position', float),
            'CameraFocalPoint': ('focal_point', float),
            'CameraViewAngle': ('view_angle', float),
            'CameraViewUp': ('up', float),
            'CameraParallelProjection': ('parallel_projection', int),
            'CameraParallelScale': ('parallel_scale', float),
        }
        camera = cls()

        tree = ET.parse(filename)
        root = tree.getroot()[0]
        for element in root:
            attrib = element.attrib
            attrib_name = attrib['name']

            if attrib_name in to_find:
                name, typ = to_find[attrib_name]
                nelems = int(attrib['number_of_elements'])

                # Set the camera attributes
                if nelems == 3:
                    values = [typ(e.attrib['value']) for e in element]
                    setattr(camera, name, values)
                elif nelems == 1:
                    # Special case for bool since bool("0") returns True.
                    # So first convert to int from `to_find` and then apply bool
                    if 'name' in element[-1].attrib and element[-1].attrib['name'] == 'bool':
                        val = bool(typ(element[0].attrib['value']))
                    else:
                        val = typ(element[0].attrib['value'])
                    setattr(camera, name, val)

        camera.is_set = True
        return camera

    def to_paraview_pvcc(self, filename: str | Path):
        """Write the camera parameters to a Paraview camera file (.pvcc extension).

        Parameters
        ----------
        filename : str or pathlib.Path
            Path to Paraview camera file (.pvcc).

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.to_paraview_pvcc('camera.pvcc')  # doctest:+SKIP

        """
        root = ET.Element('PVCameraConfiguration')
        root.attrib['description'] = 'ParaView camera configuration'
        root.attrib['version'] = '1.0'

        dico = dict(group='views', type='RenderView', id='0', servers='21')
        proxy = ET.SubElement(root, 'Proxy', dico)

        # Add tuples
        to_find = {
            'CameraPosition': 'position',
            'CameraFocalPoint': 'focal_point',
            'CameraViewUp': 'up',
        }
        for name, attr in to_find.items():
            e = ET.SubElement(
                proxy,
                'Property',
                dict(name=name, id=f'0.{name}', number_of_elements='3'),
            )

            for i in range(3):
                tmp = ET.Element('Element')
                tmp.attrib['index'] = str(i)
                tmp.attrib['value'] = str(getattr(self, attr)[i])
                e.append(tmp)

        # Add single values
        to_find = {
            'CameraViewAngle': 'view_angle',
            'CameraParallelScale': 'parallel_scale',
            'CameraParallelProjection': 'parallel_projection',
        }

        for name, attr in to_find.items():
            e = ET.SubElement(
                proxy,
                'Property',
                dict(name=name, id=f'0.{name}', number_of_elements='1'),
            )
            tmp = ET.Element('Element')
            tmp.attrib['index'] = '0'

            val = getattr(self, attr)
            if not isinstance(val, bool):
                tmp.attrib['value'] = str(val)
                e.append(tmp)
            else:
                tmp.attrib['value'] = '1' if val else '0'
                e.append(tmp)
                e.append(ET.Element('Domain', dict(name='bool', id=f'0.{name}.bool')))

        xmlstr = ET.tostring(root).decode()
        newxml = md.parseString(xmlstr)
        with Path(filename).open('w') as outfile:
            outfile.write(newxml.toprettyxml(indent='\t', newl='\n'))

    @property
    def position(self):  # numpydoc ignore=RT01
        """Return or set the position of the camera in world coordinates.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.position
        (1.0, 1.0, 1.0)
        >>> pl.camera.position = (2.0, 1.0, 1.0)
        >>> pl.camera.position
        (2.0, 1.0, 1.0)

        """
        return self.GetPosition()

    @position.setter
    def position(self, value):
        self.SetPosition(value)
        self._elevation = 0.0
        self._azimuth = 0.0
        if self._renderer:  # type: ignore[truthy-bool]
            self.reset_clipping_range()
        self.is_set = True

    def reset_clipping_range(self):
        """Reset the camera clipping range based on the bounds of the visible actors.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> _ = pl.add_mesh(pv.Sphere())
        >>> pl.camera.clipping_range = (1, 2)
        >>> pl.camera.reset_clipping_range()  # doctest:+SKIP
        (0.0039213485598532955, 3.9213485598532953)

        """
        if self._renderer is None:
            msg = 'Camera is must be associated with a renderer to reset its clipping range.'  # type: ignore[unreachable]
            raise AttributeError(msg)
        self._renderer.reset_camera_clipping_range()

    @property
    def focal_point(self):  # numpydoc ignore=RT01
        """Location of the camera's focus in world coordinates.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.focal_point
        (0.0, 0.0, 0.0)
        >>> pl.camera.focal_point = (2.0, 0.0, 0.0)
        >>> pl.camera.focal_point
        (2.0, 0.0, 0.0)

        """
        return self.GetFocalPoint()

    @focal_point.setter
    def focal_point(self, point):
        self.SetFocalPoint(point)
        self.is_set = True

    @property
    def model_transform_matrix(self):  # numpydoc ignore=RT01
        """Return or set the camera's model transformation matrix.

        Examples
        --------
        >>> import pyvista as pv
        >>> import numpy as np
        >>> pl = pv.Plotter()
        >>> pl.camera.model_transform_matrix
        array([[1., 0., 0., 0.],
               [0., 1., 0., 0.],
               [0., 0., 1., 0.],
               [0., 0., 0., 1.]])
        >>> pl.camera.model_transform_matrix = np.array(
        ...     [
        ...         [1.0, 0.0, 0.0, 0.0],
        ...         [0.0, 1.0, 0.0, 0.0],
        ...         [0.0, 0.0, 1.0, 0.0],
        ...         [0.0, 0.0, 0.0, 0.5],
        ...     ]
        ... )
        >>>
        array([[1., 0., 0., 0.],
               [0., 1., 0., 0.],
               [0., 0., 1., 0.],
               [0., 0., 0., 0.5]])

        """
        vtk_matrix = self.GetModelTransformMatrix()
        matrix = np.empty((4, 4))
        vtk_matrix.DeepCopy(matrix.ravel(), vtk_matrix)
        return matrix

    @model_transform_matrix.setter
    def model_transform_matrix(self, matrix):
        vtk_matrix = _vtk.vtkMatrix4x4()
        vtk_matrix.DeepCopy(matrix.ravel())
        self.SetModelTransformMatrix(vtk_matrix)

    @property
    def distance(self):  # numpydoc ignore=RT01
        """Return or set the distance of the focal point from the camera.

        Notes
        -----
        Setting the distance keeps the camera fixed and moves the focal point.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.distance
        1.73205
        >>> pl.camera.distance = 2.0
        >>> pl.camera.distance
        2.0

        """
        return self.GetDistance()

    @distance.setter
    def distance(self, distance):
        self.SetDistance(distance)
        self.is_set = True

    @property
    def thickness(self):  # numpydoc ignore=RT01
        """Return or set the distance between clipping planes.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.thickness
        1000.0
        >>> pl.camera.thickness = 100
        >>> pl.camera.thickness
        100.0

        """
        return self.GetThickness()

    @thickness.setter
    def thickness(self, length):
        self.SetThickness(length)

    @property
    def parallel_scale(self):  # numpydoc ignore=RT01
        """Return or set the scaling used for a parallel projection.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.parallel_scale
        1.0
        >>> pl.camera.parallel_scale = 2.0
        >>> pl.camera.parallel_scale
        2.0

        """
        return self.GetParallelScale()

    @parallel_scale.setter
    def parallel_scale(self, scale):
        self.SetParallelScale(scale)

    def zoom(self, value):
        """Set the zoom of the camera.

        In perspective mode, decrease the view angle by the specified
        factor.

        In parallel mode, decrease the parallel scale by the specified
        factor. A value greater than 1 is a zoom-in, a value less than
        1 is a zoom-out.

        Parameters
        ----------
        value : float or str
            Zoom of the camera. If a float, must be greater than 0. Otherwise,
            if a string, must be ``"tight"``. If tight, the plot will be zoomed
            such that the actors fill the entire viewport.

        Examples
        --------
        Show the Default zoom.

        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> _ = pl.add_mesh(pv.Sphere())
        >>> pl.camera.zoom(1.0)
        >>> pl.show()

        Show 2x zoom.

        >>> pl = pv.Plotter()
        >>> _ = pl.add_mesh(pv.Sphere())
        >>> pl.camera.zoom(2.0)
        >>> pl.show()

        Zoom so the actor fills the entire render window.

        >>> pl = pv.Plotter()
        >>> _ = pl.add_mesh(pv.Sphere())
        >>> pl.camera.zoom('tight')
        >>> pl.show()

        """
        if isinstance(value, str):
            if value != 'tight':
                msg = 'If a string, ``zoom`` can only be "tight"'
                raise ValueError(msg)
            self.tight()
            return

        self.Zoom(value)
        self.is_set = True

    @property
    def up(self):  # numpydoc ignore=RT01
        """Return or set the "up" of the camera.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.up
        (0.0, 0.0, 1.0)
        >>> pl.camera.up = (0.410018, 0.217989, 0.885644)
        >>> pl.camera.up
        (0.410018, 0.217989, 0.885644)

        """
        return self.GetViewUp()

    @up.setter
    def up(self, vector):
        self.SetViewUp(vector)
        self.is_set = True

    def enable_parallel_projection(self):
        """Enable parallel projection.

        The camera will have a parallel projection. Parallel
        projection is often useful when viewing images or 2D datasets,
        but will look odd when viewing 3D datasets.

        Examples
        --------
        >>> import pyvista as pv
        >>> from pyvista import demos
        >>> pl = pv.demos.orientation_plotter()
        >>> pl.enable_parallel_projection()
        >>> pl.show()

        """
        self._parallel_projection = True
        self.SetParallelProjection(True)

    def disable_parallel_projection(self):
        """Disable the use of parallel projection.

        This is default behavior.

        Examples
        --------
        >>> import pyvista as pv
        >>> from pyvista import demos
        >>> pl = pv.demos.orientation_plotter()
        >>> pl.disable_parallel_projection()
        >>> pl.show()

        """
        self._parallel_projection = False
        self.SetParallelProjection(False)

    @property
    def parallel_projection(self):  # numpydoc ignore=RT01
        """Return the state of the parallel projection.

        Examples
        --------
        >>> import pyvista as pv
        >>> from pyvista import demos
        >>> pl = pv.Plotter()
        >>> pl.disable_parallel_projection()
        >>> pl.parallel_projection
        False

        """
        return self._parallel_projection

    @parallel_projection.setter
    def parallel_projection(self, state):
        if state:
            self.enable_parallel_projection()
        else:
            self.disable_parallel_projection()

    @property
    def clipping_range(self):  # numpydoc ignore=RT01
        """Return or set the location of the clipping planes.

        Clipping planes are the near and far clipping planes along
        the direction of projection.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.clipping_range
        (0.01, 1000.01)
        >>> pl.camera.clipping_range = (1, 10)
        >>> pl.camera.clipping_range
        (1.0, 10.0)

        """
        return self.GetClippingRange()

    @clipping_range.setter
    def clipping_range(self, points):
        if points[0] > points[1]:
            msg = 'Near point must be lower than the far point.'
            raise ValueError(msg)
        self.SetClippingRange(points[0], points[1])

    @property
    def view_angle(self):  # numpydoc ignore=RT01
        """Return or set the camera view angle.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.view_angle
        30.0
        >>> pl.camera.view_angle = 60.0
        >>> pl.camera.view_angle
        60.0

        """
        return self.GetViewAngle()

    @view_angle.setter
    def view_angle(self, value):
        self.SetViewAngle(value)

    @property
    def direction(self):  # numpydoc ignore=RT01
        """Vector from the camera position to the focal point.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.direction  # doctest:+SKIP
        (-0.5773502691896257, -0.5773502691896257, -0.5773502691896257)

        """
        return self.GetDirectionOfProjection()

    def view_frustum(self, aspect=1.0):
        """Get the view frustum.

        Parameters
        ----------
        aspect : float, default: 1.0
            The aspect of the viewport to compute the planes.

        Returns
        -------
        pyvista.PolyData
            View frustum.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> frustum = pl.camera.view_frustum(1.0)
        >>> frustum.n_points
        8
        >>> frustum.n_cells
        6

        """
        frustum_planes = [0] * 24
        self.GetFrustumPlanes(aspect, frustum_planes)  # type: ignore[arg-type]
        planes = _vtk.vtkPlanes()
        planes.SetFrustumPlanes(frustum_planes)  # type: ignore[arg-type]

        frustum_source = _vtk.vtkFrustumSource()
        frustum_source.ShowLinesOff()
        frustum_source.SetPlanes(planes)
        frustum_source.Update()

        return pv.wrap(frustum_source.GetOutput())

    @property
    def roll(self):  # numpydoc ignore=RT01
        """Return or set the roll of the camera about the direction of projection.

        This will spin the camera about its axis.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.roll
        -120.00000000000001
        >>> pl.camera.roll = 45.0
        >>> pl.camera.roll
        45.0

        """
        return self.GetRoll()

    @roll.setter
    def roll(self, angle):
        self.SetRoll(angle)
        self.is_set = True

    @property
    def elevation(self):  # numpydoc ignore=RT01
        """Return or set the vertical rotation of the scene.

        Rotate the camera about the cross product of the negative of
        the direction of projection and the view up vector, using the
        focal point as the center of rotation.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.elevation
        0.0
        >>> pl.camera.elevation = 45.0
        >>> pl.camera.elevation
        45.0

        """
        return self._elevation

    @elevation.setter
    def elevation(self, angle):
        if self._elevation:
            self.Elevation(-self._elevation)
        self._elevation = angle
        self.Elevation(angle)
        self.is_set = True

    @property
    def azimuth(self):  # numpydoc ignore=RT01
        """Return or set the azimuth of the camera.

        Rotate the camera about the view up vector centered at the
        focal point. Note that the view up vector is whatever was set
        via SetViewUp, and is not necessarily perpendicular to the
        direction of projection.

        Examples
        --------
        >>> import pyvista as pv
        >>> pl = pv.Plotter()
        >>> pl.camera.azimuth
        0.0
        >>> pl.camera.azimuth = 45.0
        >>> pl.camera.azimuth
        45.0

        """
        return self._azimuth

    @azimuth.setter
    def azimuth(self, angle):
        if self._azimuth:
            self.Azimuth(-self._azimuth)
        self._azimuth = angle
        self.Azimuth(angle)
        self.is_set = True

    def copy(self):
        """Return a deep copy of the camera.

        Returns
        -------
        pyvista.Camera
            Deep copy of the camera.

        Examples
        --------
        Create a camera and check that it shares a transformation
        matrix with its shallow copy.

        >>> import pyvista as pv
        >>> import numpy as np
        >>> camera = pv.Camera()
        >>> camera.model_transform_matrix = np.array(
        ...     [
        ...         [1.0, 0.0, 0.0, 0.0],
        ...         [0.0, 1.0, 0.0, 0.0],
        ...         [0.0, 0.0, 1.0, 0.0],
        ...         [0.0, 0.0, 0.0, 1.0],
        ...     ]
        ... )
        >>> copied_camera = camera.copy()
        >>> copied_camera == camera
        True
        >>> camera.model_transform_matrix = np.array(
        ...     [
        ...         [1.0, 0.0, 0.0, 0.0],
        ...         [0.0, 1.0, 0.0, 0.0],
        ...         [0.0, 0.0, 1.0, 0.0],
        ...         [0.0, 0.0, 0.0, 0.5],
        ...     ]
        ... )
        >>> copied_camera == camera
        False

        """
        immutable_attrs = [
            'position',
            'focal_point',
            'model_transform_matrix',
            'distance',
            'thickness',
            'parallel_scale',
            'up',
            'clipping_range',
            'view_angle',
            'roll',
            'parallel_projection',
            'is_set',
        ]
        new_camera = Camera()

        for attr in immutable_attrs:
            value = getattr(self, attr)
            setattr(new_camera, attr, value)

        return new_camera

    @_deprecate_positional_args
    def tight(  # noqa: PLR0917
        self,
        padding=0.0,
        adjust_render_window: bool = True,  # noqa: FBT001, FBT002
        view='xy',
        negative: bool = False,  # noqa: FBT001, FBT002
    ):
        """Adjust the camera position so that the actors fill the entire renderer.

        The camera view direction is reoriented to be normal to the ``view``
        plane. When ``negative=False``, The first letter of ``view`` refers
        to the axis that points to the right. The second letter of ``view``
        refers to axis that points up.  When ``negative=True``, the first
        letter refers to the axis that points left.  The up direction is
        unchanged.

        Parallel projection is enabled when using this function.

        Parameters
        ----------
        padding : float, default: 0.0
            Additional padding around the actor(s). This is effectively a zoom,
            where a value of 0.01 results in a zoom out of 1%.

        adjust_render_window : bool, default: True
            Adjust the size of the render window as to match the dimensions of
            the visible actors.

        view : {'xy', 'yx', 'xz', 'zx', 'yz', 'zy'}, default: 'xy'
            Plane to which the view is oriented.

        negative : bool, default: False
            Whether to view in opposite direction.

        Notes
        -----
        This resets the view direction to look at a plane with parallel projection.

        Examples
        --------
        Display the bird image with a tight view.

        >>> import pyvista as pv
        >>> from pyvista import examples
        >>> bird = examples.download_bird()
        >>> pl = pv.Plotter(border=True, border_width=5)
        >>> _ = pl.add_mesh(bird, rgb=True)
        >>> pl.camera.tight()
        >>> pl.show()

        Set the background to blue use a 5% padding around the image.

        >>> pl = pv.Plotter()
        >>> _ = pl.add_mesh(bird, rgb=True)
        >>> pl.background_color = 'b'
        >>> pl.camera.tight(padding=0.05)
        >>> pl.show()

        """
        # Inspired by vedo resetCamera. Thanks @marcomusy.
        x0, x1, y0, y1, z0, z1 = self._renderer.bounds

        self.enable_parallel_projection()

        self._renderer.ComputeAspect()
        aspect = self._renderer.GetAspect()

        position0 = np.array([x0, y0, z0])
        position1 = np.array([x1, y1, z1])
        objects_size = position1 - position0
        position = position0 + objects_size / 2

        direction, viewup = view_vectors(view, negative=negative)
        horizontal = np.cross(direction, viewup)

        vert_dist = abs(objects_size @ viewup)
        horiz_dist = abs(objects_size @ horizontal)

        # set focal point to objects' center
        # offset camera position from objects center by dist in opposite of viewing direction
        # (actual distance doesn't matter due to parallel projection)
        dist = 1
        camera_position = position + dist * direction

        self.SetViewUp(*viewup)
        self.SetPosition(*camera_position)
        self.SetFocalPoint(*position)

        ps = max(horiz_dist / aspect[0], vert_dist) / 2
        self.parallel_scale = ps * (1 + padding)
        self._renderer.ResetCameraClippingRange(x0, x1, y0, y1, z0, z1)

        if adjust_render_window:
            ren_win = self._renderer.GetRenderWindow()
            size = list(ren_win.GetSize())
            size_ratio = size[0] / size[1]
            tight_ratio = horiz_dist / vert_dist
            resize_ratio = tight_ratio / size_ratio
            if resize_ratio < 1:
                size[0] = round(size[0] * resize_ratio)
            else:
                size[1] = round(size[1] / resize_ratio)

            ren_win.SetSize(size)

            # simply call tight again to reset the parallel scale due to the
            # resized window
            self.tight(padding=padding, adjust_render_window=False, view=view, negative=negative)

        self.is_set = True
