compas-timber 2.1.2__tar.gz → 2.2.0__tar.gz

{compas_timber-2.1.2/src/compas_timber.egg-info → compas_timber-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compas_timber
-Version: 2.1.2
+Version: 2.2.0
 Summary: COMPAS package for modeling, designing and fabricating timber assemblies.
 Author-email: Aleksandra Anna Apolinarska <apolinarska@arch.ethz.ch>, Chen Kasirer <kasirer@arch.ethz.ch>, Gonzalo Casas <casas@arch.ethz.ch>, Jonas Haldemann <haldemann@arch.ethz.ch>, Oliver Appling Bucklin <bucklin@arch.ethz.ch>, "Aurèle L. Gheyselinck" <gheyselinck@arch.ethz.ch>, Panayiotis Papacharalambous <papacharalambous@arch.ethz.ch>, Anastasiia Stryzhevska <astryzhevska@arch.ethz.ch>, Jelle Feringa <jelleferinga@gmail.com>, Joseph Kenny <jk6372@princeton.edu>, Beverly Lytle <lytle@arch.ethz.ch>, Eric Gozzi <eric.gozzi@arch.ethz.ch>, Rodrigo Arca Zimmermann <rodrigo.arca@gmail.com>, Nicolas Benjamin Boscoboinik <boscoboinik@arch.ethz.ch>
 License-Expression: MIT

{compas_timber-2.1.2 → compas_timber-2.2.0}/pyproject.toml

@@ -96,7 +96,7 @@ where = ["src"]
 # ============================================================================
 
 [tool.bumpversion]
-current_version = "2.1.2"
+current_version = "2.2.0"
 message = "Bump version to {new_version}"
 commit = true
 tag = true

{compas_timber-2.1.2 → compas_timber-2.2.0}/src/compas_timber/__init__.py

@@ -1,7 +1,7 @@
 import os
 import compas
 
-__version__ = "2.1.2"
+__version__ = "2.2.0"
 
 HERE = os.path.dirname(__file__)
 HOME = os.path.abspath(os.path.join(HERE, "..", ".."))

{compas_timber-2.1.2 → compas_timber-2.2.0}/src/compas_timber/connections/__init__.py

@@ -1,8 +1,10 @@
 from .joint import Joint
 from .butt_joint import ButtJoint
+from .i_simple_scarf import ISimpleScarf
 from .l_butt import LButtJoint
 from .l_lap import LLapJoint
 from .l_miter import LMiterJoint
+from .l_miter import MiterPlaneSpec
 from .l_french_ridge_lap import LFrenchRidgeLapJoint
 from .lap_joint import LapJoint
 from .joint_candidate import JointCandidate
@@ -24,6 +26,7 @@ from .l_tenon_mortise import LTenonMortiseJoint
 from .ball_node import BallNodeJoint
 from .y_butt import YButtJoint
 from .oligina import TOliGinaJoint
+from .butt_joint import CutPlaneSpec
 from .utilities import beam_ref_side_incidence
 from .utilities import beam_ref_side_incidence_with_vector
 from .utilities import point_centerline_towards_joint
@@ -46,6 +49,7 @@ __all__ = [
     "LapJoint",
     "ButtJoint",
     "TButtJoint",
+    "ISimpleScarf",
     "LButtJoint",
     "TButtJoint",
     "TStepJoint",
@@ -69,6 +73,8 @@ __all__ = [
     "LTenonMortiseJoint",
     "YButtJoint",
     "TOliGinaJoint",
+    "CutPlaneSpec",
+    "MiterPlaneSpec",
     "beam_ref_side_incidence",
     "beam_ref_side_incidence_with_vector",
     "point_centerline_towards_joint",

{compas_timber-2.1.2 → compas_timber-2.2.0}/src/compas_timber/connections/butt_joint.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
+import math
 from typing import TYPE_CHECKING
 from typing import Optional
 
+from compas.data import Data
 from compas.geometry import Plane
 from compas.geometry import Polyhedron
+from compas.geometry import dot_vectors
 
 from compas_timber.errors import BeamJoiningError
 from compas_timber.fabrication import JackRafterCutProxy
@@ -15,11 +18,91 @@ from compas_timber.geometry import polyhedron_from_box_planes
 from .joint import Joint
 from .solver import JointTopology
 from .utilities import beam_ref_side_incidence
+from .utilities import decompose_plane_to_ref_side
+from .utilities import plane_from_ref_side_angle_offset
 
 if TYPE_CHECKING:
     from compas_timber.elements.beam import Beam
 
 
+class CutPlaneSpec(Data):
+    """A cutting plane stored relative to a beam's reference side.
+
+    Encodes a world-coordinate plane as a ``(ref_side_index, angle, offset)`` triple, matching the
+    parameterisation of :func:`plane_from_ref_side_angle_offset`.  The encoded plane's line of
+    intersection with the reference side stays parallel to the beam's centerline (x-axis constraint).
+    Use the named constructors :meth:`from_butt_plane` and :meth:`from_back_plane` to build instances
+    from world-coordinate planes, and :meth:`to_plane` to reconstruct the plane at query time.
+
+    """
+
+    @property
+    def __data__(self):
+        return {"ref_side_index": self.ref_side_index, "angle": self.angle, "offset": self.offset}
+
+    def __init__(self, ref_side_index: int, angle: float = 0.0, offset: float = 0.0):
+        super().__init__()
+        self.ref_side_index = ref_side_index
+        self.angle = angle
+        self.offset = offset
+
+    def to_plane(self, beam: Beam) -> Plane:
+        """Reconstruct the world-coordinate plane relative to `beam`."""
+        ref_side = beam.ref_sides[self.ref_side_index]
+        return plane_from_ref_side_angle_offset(ref_side, self.angle, self.offset)
+
+    @classmethod
+    def from_butt_plane(cls, main_beam: Beam, cross_beam: Beam, plane: Plane) -> CutPlaneSpec:
+        """Encode `plane` relative to the cross beam's face that is closest to the main beam.
+
+        Use this when the plane is intended to cut the **main beam** (i.e. as
+        :attr:`~compas_timber.connections.ButtJoint.butt_plane`).
+
+        Parameters
+        ----------
+        main_beam
+            Main beam of the joint.
+        cross_beam
+            Cross beam of the joint.
+        plane
+            Cutting plane in world coordinates.  Its normal must be perpendicular to the cross beam's
+            centerline axis.
+
+        """
+        if not dot_vectors(cross_beam.frame.xaxis, plane.normal) == 0:
+            raise ValueError("plane normal must be perpendicular to cross_beam centerline axis")
+        ref_side_dict = beam_ref_side_incidence(main_beam, cross_beam, ignore_ends=True)
+        ref_side_index = min(ref_side_dict, key=lambda k: ref_side_dict[k])
+        ref_side = cross_beam.ref_sides[ref_side_index]
+        angle, offset = decompose_plane_to_ref_side(ref_side, plane, plane_name="butt_plane", reference_name="cross_beam")
+        return cls(ref_side_index, angle, offset)
+
+    @classmethod
+    def from_back_plane(cls, main_beam: Beam, cross_beam: Beam, plane: Plane) -> CutPlaneSpec:
+        """Encode `plane` relative to the back face of the main beam (the face opposite the cross beam).
+
+        Use this when the plane is intended to cut the **cross beam** from behind the main beam (i.e. as
+        :attr:`~compas_timber.connections.LButtJoint.back_plane`).
+
+        Parameters
+        ----------
+        main_beam
+            Main beam of the joint.
+        cross_beam
+            Cross beam of the joint.
+        plane
+            Cutting plane in world coordinates.  Its normal must be perpendicular to the main beam's
+            centerline axis.
+
+        """
+        ref_side_dict = beam_ref_side_incidence(cross_beam, main_beam, ignore_ends=True)
+        facing_side_index = min(ref_side_dict, key=lambda k: ref_side_dict[k])
+        back_side_index = (facing_side_index + 2) % 4  # opposite face of main_beam
+        ref_side = main_beam.ref_sides[back_side_index]
+        angle, offset = decompose_plane_to_ref_side(ref_side, plane, plane_name="back_plane", reference_name="main_beam")
+        return cls(back_side_index, angle, offset)
+
+
 class ButtJoint(Joint):
     """Represents an L-Butt type joint which joins two beam in their ends, trimming the main beam.
 
@@ -34,9 +117,10 @@ class ButtJoint(Joint):
     cross_beam : :class:`~compas_timber.elements.Beam`
         The cross beam to be joined.
     mill_depth : float
-        The depth of the pocket to be milled in the cross beam. This will be ignored if `butt_plane` is provided.
-    butt_plane : :class:`~compas.geometry.Plane`, optional
-        The plane used to cut the main beam. If not provided, the closest side of the cross beam will be used.
+        The depth of the pocket to be milled in the cross beam. This will be ignored if `butt_plane_spec` is provided.
+    butt_plane_spec : :class:`~compas_timber.connections.JointCutPlane`, optional
+        Overrides the plane used to cut the main beam. Build with
+        :meth:`~compas_timber.connections.JointCutPlane.from_butt_plane`.
     force_pocket : bool
         If `True` applies a `:~compas_timber.fabrication.Pocket` feature instead of a `:~compas_timber.fabrication.Lap` on the cross beam. Default is `False`.
     conical_tool : bool
@@ -52,16 +136,14 @@ class ButtJoint(Joint):
         A list containing the main beam and the cross beam.
     mill_depth : float
         The depth of the pocket to be milled in the cross beam.
-    butt_plane : :class:`~compas.geometry.Plane`, optional
-        The plane used to cut the main beam. If not provided, the closest side of the cross beam will be used.
     force_pocket : bool
         If `True` applies a `:~compas_timber.fabrication.Pocket` feature instead of a `:~compas_timber.fabrication.Lap` on the cross beam. Default is `False`.
     conical_tool : bool
         If `True` it can apply smaller than 90 degrees angles to the TiltSide parameters of the `:~compas_timber.fabrication.Pocket` feature. Default is `False`.
-    features: list[BTLxProcessing]
+    features: list[:class:`~compas_timber.fabrication.BTLxProcessing`]
         List of features to be applied to the cross beam and main beam.
     cross_beam_ref_side_index : int
-        The index of the side of the cross beam relative to the main beam..
+        The index of the side of the cross beam relative to the main beam.
     main_beam_ref_side_index : int
         The index of the side of the main beam relative to the cross beam.
 
@@ -73,7 +155,7 @@ class ButtJoint(Joint):
     def __data__(self):
         data = super(ButtJoint, self).__data__
         data["mill_depth"] = self.mill_depth
-        data["butt_plane"] = self.butt_plane
+        data["butt_plane_spec"] = self._butt_plane_spec
         data["force_pocket"] = self.force_pocket
         data["conical_tool"] = self.conical_tool
         return data
@@ -83,17 +165,17 @@ class ButtJoint(Joint):
         main_beam: Beam = None,
         cross_beam: Beam = None,
         mill_depth: Optional[float] = None,
-        butt_plane: Optional[Plane] = None,
+        butt_plane_spec: Optional[CutPlaneSpec] = None,
         force_pocket: bool = False,
         conical_tool: bool = False,
         **kwargs,
     ):
         super(ButtJoint, self).__init__(elements=(main_beam, cross_beam), **kwargs)
-        self.mill_depth = mill_depth
-        self.force_pocket = force_pocket
-        self.conical_tool = conical_tool
+        self.mill_depth: float = mill_depth or 0.0
+        self._butt_plane_spec: Optional[CutPlaneSpec] = butt_plane_spec
+        self.force_pocket: bool = force_pocket
+        self.conical_tool: bool = conical_tool
         self.features = []
-        self._butt_plane = butt_plane
 
     @property
     def main_beam(self):
@@ -121,13 +203,24 @@ class ButtJoint(Joint):
 
     @property
     def butt_plane(self) -> Plane:
-        if self._butt_plane is None:
-            cutting_plane = self.cross_beam.ref_sides[self.cross_beam_ref_side_index]
-            cutting_plane.xaxis = -cutting_plane.xaxis
-            if self.mill_depth:
-                cutting_plane.translate(cutting_plane.normal * self.mill_depth)
-            self._butt_plane = Plane.from_frame(cutting_plane)
-        return self._butt_plane
+        """The plane used to cut the main beam.
+
+        If a :class:`~compas_timber.connections.JointCutPlane` override is set, it is resolved against the cross beam.
+        Otherwise defaults to the cross beam's side closest to the main beam, offset outward by `mill_depth`.
+        """
+        if self._butt_plane_spec is not None:
+            return self._butt_plane_spec.to_plane(self.cross_beam)
+        # default: the cross beam's closest side, facing the main beam, offset by mill_depth
+        ref_side = self.cross_beam.ref_sides[self.cross_beam_ref_side_index]
+        return plane_from_ref_side_angle_offset(ref_side, math.pi, self.mill_depth)
+
+    def _back_cutting_plane(self) -> Plane:
+        """The plane used to extend/cut the cross beam when `modify_cross` is True.
+
+        Defaults to the side of the main beam opposite the one facing the cross beam. `LButtJoint` overrides this to
+        support a user-defined `back_plane`; this is not a general `ButtJoint` concept.
+        """
+        return Plane.from_frame(self.main_beam.opp_side(self.main_beam_ref_side_index))
 
     def add_extensions(self):
         """Calculates and adds the necessary extensions to the beams.

compas_timber-2.2.0/src/compas_timber/connections/i_simple_scarf.py

@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import List
+from typing import Optional
+from typing import Tuple
+
+from compas.geometry import Plane
+from compas.tolerance import TOL
+
+from compas_timber.errors import BeamJoiningError
+from compas_timber.fabrication import SimpleScarf
+
+from .joint import Joint
+from .solver import JointTopology
+from .utilities import beam_ref_side_incidence_with_vector
+
+if TYPE_CHECKING:
+    from compas.geometry import Frame
+    from compas.geometry import Point
+
+    from compas_timber.elements import Beam
+
+
+class ISimpleScarf(Joint):
+    """Represents a Simple Scarf joint for two parallel beams (Topology I).
+
+    Parameters
+    ----------
+    main_beam : :class:`~compas_timber.elements.Beam`, optional
+        The first beam of the joint.
+    cross_beam : :class:`~compas_timber.elements.Beam`, optional
+        The second beam of the joint, parallel to the main beam.
+    length : float, optional
+        The length of the scarf overlap along the beam axis. If not provided,
+        defaults to ``DEFAULT_LENGTH_TO_HEIGHT_RATIO`` times the beam height.
+    depth_ref_side : float, optional
+        The cut depth on the reference side of the beam. If not provided,
+        defaults to ``DEFAULT_DEPTH_TO_HEIGHT_RATIO`` times the beam height.
+    depth_opp_side : float, optional
+        The cut depth on the opposite side of the beam. If not provided,
+        defaults to ``DEFAULT_DEPTH_TO_HEIGHT_RATIO`` times the beam height.
+    num_drill_hole : int, optional
+        Number of drill holes through the joint (0, 1, or 2). Defaults to 0.
+    drill_hole_diam : float, optional
+        Diameter of the drill holes in mm. Defaults to 20.0.
+    ref_side_index : int, optional
+        Zero-based index of the reference side (RS1–RS6 → 0–5). Defaults to 0.
+
+    Attributes
+    ----------
+    main_beam : :class:`~compas_timber.elements.Beam`
+        The first beam of the joint (alias for ``element_a``).
+    cross_beam : :class:`~compas_timber.elements.Beam`
+        The second beam of the joint (alias for ``element_b``).
+    main_beam_ref_side_index : int
+        Reference side index for the main beam. Equal to ``ref_side_index``.
+    cross_beam_ref_side_index : int
+        Reference side index for the cross beam, resolved automatically from
+        the face most aligned with the main beam's reference side normal.
+    origin : :class:`~compas.geometry.Point`
+        The origin point of the joint (alias for ``location``).
+    length : float
+        The length of the scarf overlap.
+    depth_ref_side : float
+        The cut depth on the reference side.
+    depth_opp_side : float
+        The cut depth on the opposite side.
+    num_drill_hole : int
+        Number of drill holes (0, 1, or 2).
+    drill_hole_diam : float
+        Diameter of the drill holes in mm.
+    ref_side_index : int
+        Zero-based index of the reference side used for the main beam.
+    features : list
+        List of :class:`~compas_timber.fabrication.SimpleScarf` features
+        added to the beams by this joint.
+
+    """
+
+    SUPPORTED_TOPOLOGY = JointTopology.TOPO_I
+
+    # Scarf length defaults to 3x the beam height — a common rule of thumb
+    # that provides enough glue/contact area for structural performance.
+    DEFAULT_LENGTH_TO_HEIGHT_RATIO = 3
+    # Depth on each face defaults to 1/4 of the beam height,
+    # leaving the middle half as the straight (uncut) section.
+    DEFAULT_DEPTH_TO_HEIGHT_RATIO = 0.25
+
+    @property
+    def __data__(self):
+        data = super(ISimpleScarf, self).__data__
+        data["main_beam_guid"] = self.main_beam_guid
+        data["cross_beam_guid"] = self.cross_beam_guid
+        data["length"] = self.length
+        data["depth_ref_side"] = self.depth_ref_side
+        data["depth_opp_side"] = self.depth_opp_side
+        data["num_drill_hole"] = self.num_drill_hole
+        data["drill_hole_diam"] = self.drill_hole_diam
+        data["ref_side_index"] = self.ref_side_index
+        return data
+
+    def __init__(
+        self,
+        main_beam: Optional[Beam] = None,
+        cross_beam: Optional[Beam] = None,
+        length: Optional[float] = None,
+        depth_ref_side: Optional[float] = None,
+        depth_opp_side: Optional[float] = None,
+        num_drill_hole: int = 0,
+        drill_hole_diam: float = 20.0,
+        ref_side_index: int = 0,
+        **kwargs,
+    ):
+        super(ISimpleScarf, self).__init__(elements=(main_beam, cross_beam), **kwargs)
+        self.main_beam_guid = kwargs.get("main_beam_guid") or (str(main_beam.guid) if main_beam else None)
+        self.cross_beam_guid = kwargs.get("cross_beam_guid") or (str(cross_beam.guid) if cross_beam else None)
+
+        self.length = length
+        self.depth_ref_side = depth_ref_side
+        self.depth_opp_side = depth_opp_side
+        self.num_drill_hole = num_drill_hole
+        self.drill_hole_diam = drill_hole_diam
+        self.ref_side_index = ref_side_index
+
+        self.features = []
+
+        if self.main_beam and self.cross_beam:
+            self._set_unset_attributes()
+
+    @property
+    def main_beam(self) -> Beam:
+        return self.element_a
+
+    @property
+    def cross_beam(self) -> Beam:
+        return self.element_b
+
+    @property
+    def main_beam_ref_side_index(self) -> int:
+        return self.ref_side_index
+
+    @property
+    def cross_beam_ref_side_index(self) -> int:
+        ref_side_dict = beam_ref_side_incidence_with_vector(self.cross_beam, self.main_beam.ref_sides[self.main_beam_ref_side_index].normal, ignore_ends=True)
+        return max(ref_side_dict, key=ref_side_dict.get)
+
+    @property
+    def origin(self) -> Point:
+        return self.location
+
+    def _get_beam_side(self, beam: Beam) -> str:
+        """Finds whether the scarf end of the beam is its start or end.
+
+        Parameters
+        ----------
+        beam : :class:`~compas_timber.elements.Beam`
+            The beam to evaluate.
+
+        Returns
+        -------
+        str
+            ``"start"`` or ``"end"`` depending on which endpoint of the beam
+            is closest to the joint origin.
+        """
+        side, _ = beam.endpoint_closest_to_point(self.origin)
+        return side
+
+    def extension_plane(self, beam: Beam) -> Tuple[int, Frame]:
+        """Returns the end-face index and frame used to compute the blank extension for a beam.
+
+        The end face is RS5 (index 4) when the scarf sits at the beam start,
+        or RS6 (index 5) when it sits at the beam end.
+
+        Parameters
+        ----------
+        beam : :class:`~compas_timber.elements.Beam`
+            The beam for which to determine the extension plane.
+
+        Returns
+        -------
+        tuple(int, :class:`~compas.geometry.Frame`)
+            A tuple of ``(ext_side_index, frame)`` where ``ext_side_index`` is
+            the zero-based index of the end face (4 or 5) and ``frame`` is the
+            corresponding reference-side frame.
+        """
+        ext_side_index = 4 if self._get_beam_side(beam) == "start" else 5
+        return ext_side_index, beam.ref_sides[ext_side_index]
+
+    def add_extensions(self) -> None:
+        """Calculates and adds the required blank extensions to both beams."""
+        assert self.main_beam and self.cross_beam
+
+        try:
+            _, main_extension_frame = self.extension_plane(self.main_beam)
+            main_extension_frame.translate(main_extension_frame.normal * self.length / 2)
+
+            _, cross_extension_frame = self.extension_plane(self.cross_beam)
+            cross_extension_frame.translate(cross_extension_frame.normal * self.length / 2)
+
+            start_a, end_a = self.main_beam.extension_to_plane(Plane.from_frame(main_extension_frame))
+            start_b, end_b = self.cross_beam.extension_to_plane(Plane.from_frame(cross_extension_frame))
+
+        except AttributeError as ae:
+            raise BeamJoiningError(self.elements, self, debug_info=str(ae), debug_geometries=[main_extension_frame])
+        except Exception as ex:
+            raise BeamJoiningError(self.elements, self, debug_info=str(ex))
+
+        self.main_beam.add_blank_extension(start_a, end_a, self.guid)
+        self.cross_beam.add_blank_extension(start_b, end_b, self.guid)
+
+    def add_features(self) -> None:
+        """Generates and assigns the SimpleScarf fabrication features.
+
+        Raises
+        ------
+        AssertionError
+            If either beam is not set.
+        """
+        assert self.main_beam and self.cross_beam
+
+        if self.features:
+            self.main_beam.remove_features(self.features)
+            self.cross_beam.remove_features(self.features)
+            self.features = []
+
+        main_feature = SimpleScarf.from_beam_and_side(
+            self.main_beam,
+            side=self._get_beam_side(self.main_beam),
+            length=self.length,
+            depth_ref_side=self.depth_ref_side,
+            depth_opp_side=self.depth_opp_side,
+            num_drill_hole=self.num_drill_hole,
+            drill_hole_diam=self.drill_hole_diam,
+            ref_side_index=self.ref_side_index,
+        )
+
+        cross_feature = SimpleScarf.from_beam_and_side(
+            self.cross_beam,
+            side=self._get_beam_side(self.cross_beam),
+            length=self.length,
+            depth_ref_side=self.depth_opp_side,
+            depth_opp_side=self.depth_ref_side,
+            num_drill_hole=self.num_drill_hole,
+            drill_hole_diam=self.drill_hole_diam,
+            ref_side_index=self.cross_beam_ref_side_index,
+        )
+
+        self.main_beam.add_features(main_feature)
+        self.cross_beam.add_features(cross_feature)
+        self.features.extend([main_feature, cross_feature])
+
+    @classmethod
+    def check_elements_compatibility(cls, elements: List[Beam], raise_error: bool = False) -> bool:
+        """Checks if the two beams are parallel, as required for an ISimpleScarf joint.
+
+        Parameters
+        ----------
+        elements : list(:class:`~compas_timber.elements.Beam`)
+            The two beams to check.
+        raise_error : bool, optional
+            If ``True``, raise a :class:`~compas_timber.errors.BeamJoiningError`
+            instead of returning ``False``. Defaults to ``False``.
+
+        Returns
+        -------
+        bool
+            ``True`` if the beams are parallel, ``False`` otherwise
+            (when ``raise_error`` is ``False``).
+
+        Raises
+        ------
+        :class:`~compas_timber.errors.BeamJoiningError`
+            If the beams are not parallel and ``raise_error`` is ``True``.
+        """
+        dot = abs(elements[0].centerline.direction.dot(elements[1].centerline.direction))
+        if not TOL.is_close(dot, 1):
+            if not raise_error:
+                return False
+            raise BeamJoiningError(elements, cls, debug_info="The two beams are not parallel to create a Simple Scarf joint.")
+        return True
+
+    def _set_unset_attributes(self) -> None:
+        """Sets attributes that were not provided at initialization based on the geometry of the beams."""
+        width, height = self.main_beam.get_dimensions_relative_to_side(self.ref_side_index)
+
+        if self.length is None:
+            self.length = height * self.DEFAULT_LENGTH_TO_HEIGHT_RATIO
+
+        if self.depth_ref_side is None:
+            self.depth_ref_side = height * self.DEFAULT_DEPTH_TO_HEIGHT_RATIO
+
+        if self.depth_opp_side is None:
+            self.depth_opp_side = height * self.DEFAULT_DEPTH_TO_HEIGHT_RATIO