navaltoolbox 0.3.0__tar.gz → 0.4.0__tar.gz

{navaltoolbox-0.3.0 → navaltoolbox-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: navaltoolbox
-Version: 0.3.0
+Version: 0.4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)

{navaltoolbox-0.3.0 → navaltoolbox-0.4.0}/navaltoolbox/__init__.py

@@ -58,6 +58,9 @@ from .navaltoolbox import (
     CriteriaResult,
     CriteriaContext,
     ScriptEngine,
+    Appendage,
+    DeckEdge,
+    DeckEdgeSide,
 )
 
 __all__ = [
@@ -77,4 +80,7 @@ __all__ = [
     "CriteriaResult",
     "CriteriaContext",
     "ScriptEngine",
+    "Appendage",
+    "DeckEdge",
+    "DeckEdgeSide",
 ]

{navaltoolbox-0.3.0 → navaltoolbox-0.4.0}/navaltoolbox/navaltoolbox.pyi

@@ -27,6 +27,9 @@ __all__ = [
     "Hull",
     "Vessel",
     "Silhouette",
+    "Appendage",
+    "DeckEdge",
+    "DeckEdgeSide",
     "OpeningType",
     "DownfloodingOpening",
     "HydrostaticState",
@@ -342,6 +345,58 @@ class Vessel:
             List of DownfloodingOpening objects.
         """
         ...
+    
+    # Appendage methods
+    
+    def add_appendage(self, appendage: "Appendage") -> None:
+        """Add an appendage to the vessel."""
+        ...
+        
+    def num_appendages(self) -> int:
+        """Returns the number of appendages."""
+        ...
+        
+    def clear_appendages(self) -> None:
+        """Removes all appendages."""
+        ...
+        
+    def get_appendages(self) -> List["Appendage"]:
+        """Get all appendages."""
+        ...
+        
+    def get_total_appendage_volume(self) -> float:
+        """Returns the total appendage volume in m³."""
+        ...
+        
+    def get_total_appendage_wetted_surface(self) -> float:
+        """Returns the total appendage wetted surface in m²."""
+        ...
+        
+    # Deck Edge methods
+    
+    def add_deck_edge(self, deck_edge: "DeckEdge") -> None:
+        """Add a deck edge to the vessel."""
+        ...
+        
+    def num_deck_edges(self) -> int:
+        """Returns the number of deck edges."""
+        ...
+        
+    def has_deck_edges(self) -> bool:
+        """Returns true if any deck edges are defined."""
+        ...
+        
+    def clear_deck_edges(self) -> None:
+        """Removes all deck edges."""
+        ...
+        
+    def get_deck_edges(self) -> List["DeckEdge"]:
+        """Get all deck edges."""
+        ...
+        
+    def get_min_freeboard(self, heel: float, trim: float, waterline_z: float) -> float | None:
+        """Calculate minimum freeboard across all deck edges."""
+        ...
 
 
 class Silhouette:
@@ -426,6 +481,137 @@ class Silhouette:
         ...
 
 
+
+class Appendage:
+    """An appendage (additional volume element) attached to the vessel.
+    
+    Appendages represent volume contributions from items like keels, rudders,
+    bulbous bows, etc. that are not part of the main hull geometry.
+    """
+    
+    @staticmethod
+    def from_point(name: str, center: Tuple[float, float, float], volume: float) -> "Appendage":
+        """Create an appendage from a point (fixed volume at position)."""
+        ...
+        
+    @staticmethod
+    def from_file(name: str, file_path: str) -> "Appendage":
+        """Create an appendage from an STL or VTK file."""
+        ...
+        
+    @staticmethod
+    def from_box(name: str, xmin: float, xmax: float, ymin: float, ymax: float, zmin: float, zmax: float) -> "Appendage":
+        """Create an appendage from a box (parallelepiped)."""
+        ...
+        
+    @staticmethod
+    def from_cube(name: str, center: Tuple[float, float, float], volume: float) -> "Appendage":
+        """Create an appendage from a cube (center and volume)."""
+        ...
+        
+    @staticmethod
+    def from_sphere(name: str, center: Tuple[float, float, float], volume: float) -> "Appendage":
+        """Create an appendage from a sphere (center and volume)."""
+        ...
+    
+    @property
+    def name(self) -> str:
+        """The appendage name."""
+        ...
+    
+    @name.setter
+    def name(self, value: str) -> None:
+        ...
+        
+    @property
+    def volume(self) -> float:
+        """Volume in m³."""
+        ...
+        
+    @property
+    def center(self) -> Tuple[float, float, float]:
+        """Center of volume (x, y, z) in meters."""
+        ...
+        
+    @property
+    def wetted_surface(self) -> float | None:
+        """Wetted surface area in m², or None if not set."""
+        ...
+        
+    @wetted_surface.setter
+    def wetted_surface(self, value: float | None) -> None:
+        ...
+        
+    def geometry_type(self) -> str:
+        """Returns the geometry type (Point, Mesh, Box, etc.)."""
+        ...
+    
+    def get_mesh_data(self) -> Tuple[List[Tuple[float, float, float]], List[Tuple[int, int, int]]] | None:
+        """Returns mesh data (vertices, faces) if geometry is a mesh.
+        
+        Returns:
+            Tuple of (vertices, faces), or None if not a mesh.
+        """
+        ...
+    
+    @property
+    def bounds(self) -> Tuple[float, float, float, float, float, float] | None:
+        """Returns bounds (xmin, xmax, ymin, ymax, zmin, zmax)."""
+        ...
+
+
+class DeckEdgeSide:
+    """Side of the deck edge (Port, Starboard, or Both)."""
+    
+    @staticmethod
+    def port() -> "DeckEdgeSide": ...
+    
+    @staticmethod
+    def starboard() -> "DeckEdgeSide": ...
+    
+    @staticmethod
+    def both() -> "DeckEdgeSide": ...
+
+
+class DeckEdge:
+    """A deck edge contour (livet) for freeboard calculation."""
+    
+    @staticmethod
+    def from_points(name: str, points: List[Tuple[float, float, float]], side: DeckEdgeSide) -> "DeckEdge":
+        """Create a deck edge from a list of 3D points."""
+        ...
+        
+    @staticmethod
+    def from_file(name: str, file_path: str) -> "DeckEdge":
+        """Load a deck edge from a DXF or VTK file."""
+        ...
+    
+    @property
+    def name(self) -> str:
+        """The deck edge name."""
+        ...
+    
+    @name.setter
+    def name(self, value: str) -> None:
+        ...
+        
+    def num_points(self) -> int:
+        """Returns the number of points."""
+        ...
+        
+    def get_points(self) -> List[Tuple[float, float, float]]:
+        """Returns points as list of (x, y, z) tuples."""
+        ...
+        
+    def get_side(self) -> str:
+        """Returns the side as a string."""
+        ...
+        
+    def get_freeboard(self, heel: float, trim: float, pivot: Tuple[float, float, float], waterline_z: float) -> float:
+        """Calculate freeboard at given conditions."""
+        ...
+
+
 class OpeningType:
     """Type of opening that can cause downflooding.
     
@@ -635,6 +821,8 @@ class HydrostaticState:
         free_surface_correction_t: Transverse FSC in meters.
         free_surface_correction_l: Longitudinal FSC in meters.
         stiffness_matrix: 6x6 hydrostatic stiffness matrix (flattened).
+        sectional_areas: List of (x, area) pairs representing the sectional area curve.
+        freeboard: Minimum freeboard in meters, or None.
     """
     
     draft: float
@@ -646,6 +834,9 @@ class HydrostaticState:
     volume: float
     displacement: float
     
+    sectional_areas: List[Tuple[float, float]]
+    freeboard: float | None
+    
     @property
     def cob(self) -> Tuple[float, float, float]:
         """Center of buoyancy (lcb, tcb, vcb) in meters."""
@@ -753,6 +944,7 @@ class HydrostaticsCalculator:
         trim: float = 0.0,
         heel: float = 0.0,
         vcg: float | None = None,
+        num_stations: int | None = None,
     ) -> HydrostaticState:
         """Calculate hydrostatics at a given draft, trim, and heel.
         
@@ -1274,7 +1466,53 @@ class CriteriaResult:
 
 
 class CriteriaContext:
-    """Context for Rhai scripts, wrapping stability results."""
+    """Context for Rhai scripts, wrapping stability results.
+    
+    This context provides access to stability data within Rhai scripts.
+    The following methods are available when writing Rhai scripts:
+    
+    **GZ Curve Methods:**
+    - `get_heels()` -> list of heel angles
+    - `get_gz_values()` -> list of GZ values
+    - `area_under_curve(from, to)` -> area in m·rad
+    - `gz_at_angle(angle)` -> GZ value at angle
+    - `find_max_gz()` -> map with `angle` and `value`
+    - `find_angle_of_vanishing_stability()` -> angle or ()
+    - `get_first_flooding_angle()` -> angle or ()
+    - `find_equilibrium_angle(heeling_arm)` -> angle or ()
+    - `find_second_intercept(heeling_arm)` -> angle or ()
+    - `get_limiting_angle(default)` -> limiting angle
+    
+    **Hydrostatic Properties:**
+    - `get_gm0()` -> initial GM in meters
+    - `get_gm0_dry()` -> GM without FSC
+    - `get_draft()` -> draft in meters
+    - `get_trim()` -> trim angle in degrees
+    - `get_displacement()` -> displacement in kg
+    - `get_cog()` -> [x, y, z] center of gravity
+    
+    **Form Coefficients:**
+    - `get_cb()` -> block coefficient
+    - `get_cm()` -> midship coefficient  
+    - `get_cp()` -> prismatic coefficient
+    - `get_lwl()` -> waterline length
+    - `get_bwl()` -> waterline breadth
+    - `get_vcb()` -> vertical center of buoyancy
+    
+    **Wind Data:**
+    - `has_wind_data()` -> bool
+    - `get_emerged_area()` -> area in m²
+    - `get_wind_lever_arm()` -> arm in meters
+    - `calculate_wind_heeling_lever(pressure)` -> lever at given pressure
+    
+    **Parameters:**
+    - `get_param(key)` -> value or ()
+    - `has_param(key)` -> bool
+    
+    **Metadata:**
+    - `get_vessel_name()` -> string
+    - `get_loading_condition()` -> string
+    """
     
     @staticmethod
     def from_result(

{navaltoolbox-0.3.0 → navaltoolbox-0.4.0}/navaltoolbox/visualization.py

@@ -24,8 +24,11 @@ def plot_vessel_3d(
     show_tanks: bool = True,
     show_silhouettes: bool = True,
     show_openings: bool = True,
+    show_appendages: bool = True,
+    show_deck_edges: bool = True,
     opacity_hull: float = 0.5,
     opacity_tank: float = 0.3,
+    opacity_appendage: float = 0.5,
     title: str = "Vessel Visualization",
     enable_opacity_slider: bool = True,
     show_axes: bool = True,
@@ -39,8 +42,11 @@ def plot_vessel_3d(
         show_tanks: Whether to show tank meshes.
         show_silhouettes: Whether to show silhouette profiles.
         show_openings: Whether to show downflooding openings.
+        show_appendages: Whether to show appendages.
+        show_deck_edges: Whether to show deck edges.
         opacity_hull: Opacity for hull meshes (0.0 to 1.0).
         opacity_tank: Opacity for tank meshes (0.0 to 1.0).
+        opacity_appendage: Opacity for appendage meshes (0.0 to 1.0).
         title: Title of the plot.
         enable_opacity_slider: Whether to add a slider to control hull opacity.
         show_axes: Whether to show axes, grid, and background.
@@ -183,6 +189,40 @@ def plot_vessel_3d(
                 )
             )
 
+    # 5. Appendages
+    if show_appendages:
+        for app in vessel.get_appendages():
+            _add_appendage_trace(fig, app, opacity_appendage)
+
+    # 6. Deck Edges
+    if show_deck_edges:
+        for edge in vessel.get_deck_edges():
+            points = edge.get_points()
+            if not points:
+                continue
+
+            x, y, z = zip(*points)
+            side = edge.get_side()
+
+            # Determine color based on side
+            color = "orange"  # Default/Both
+            if "Port" in side:
+                color = "red"
+            elif "Starboard" in side:
+                color = "green"
+
+            fig.add_trace(
+                go.Scatter3d(
+                    x=x,
+                    y=y,
+                    z=z,
+                    mode="lines+markers",
+                    line=dict(color=color, width=4),
+                    marker=dict(size=3, color=color),
+                    name=f"Deck Edge: {edge.name} ({side})",
+                )
+            )
+
     # 5. Reference Points (AP/FP)
     # Using Y=0, Z=0 for reference
     ap_x = vessel.ap
@@ -326,8 +366,11 @@ def plot_hydrostatic_condition(
     show_tanks: bool = True,
     show_silhouettes: bool = True,
     show_openings: bool = True,
+    show_appendages: bool = True,
+    show_deck_edges: bool = True,
     opacity_hull: float = 0.5,
     opacity_tank: float = 0.3,
+    opacity_appendage: float = 0.5,
     title: str = "Hydrostatic Condition",
     enable_opacity_slider: bool = True,
     cog: Optional[Tuple[float, float, float]] = None,
@@ -348,8 +391,11 @@ def plot_hydrostatic_condition(
         show_tanks: Whether to show tank meshes.
         show_silhouettes: Whether to show silhouette profiles.
         show_openings: Whether to show downflooding openings.
+        show_appendages: Whether to show appendages.
+        show_deck_edges: Whether to show deck edges.
         opacity_hull: Opacity for hull meshes (0.0 to 1.0).
         opacity_tank: Opacity for tank meshes (0.0 to 1.0).
+        opacity_appendage: Opacity for appendage meshes (0.0 to 1.0).
         title: Title of the plot.
         enable_opacity_slider: Whether to add a slider to control hull opacity.
         cog: Optional Center of Gravity (x, y, z) to display.
@@ -599,7 +645,103 @@ def plot_hydrostatic_condition(
                 )
             )
 
-    # 5. Reference Points
+    # 5. Appendages
+    if show_appendages:
+        for app in vessel.get_appendages():
+            geo_type = app.geometry_type()
+
+            if geo_type == "Mesh":
+                mesh_data = app.get_mesh_data()
+                if mesh_data:
+                    verts, faces = mesh_data
+                    if verts and faces:
+                        t_verts = transform_points(verts)
+                        x, y, z = t_verts[:, 0], t_verts[:, 1], t_verts[:, 2]
+                        i_idx, j_idx, k_idx = zip(*faces)
+
+                        fig.add_trace(
+                            go.Mesh3d(
+                                x=x, y=y, z=z, i=i_idx, j=j_idx, k=k_idx,
+                                color="darkkhaki",
+                                opacity=opacity_appendage,
+                                name=f"{app.name} (Appendage)",
+                                showscale=False,
+                                flatshading=True,
+                            )
+                        )
+            elif geo_type == "Box" or geo_type == "Cube":
+                bounds = app.bounds
+                if bounds:
+                    xmin, xmax, ymin, ymax, zmin, zmax = bounds
+                    # Create a box mesh
+                    box_verts = [
+                        (xmin, ymin, zmin), (xmax, ymin, zmin),
+                        (xmax, ymax, zmin), (xmin, ymax, zmin),
+                        (xmin, ymin, zmax), (xmax, ymin, zmax),
+                        (xmax, ymax, zmax), (xmin, ymax, zmax)
+                    ]
+                    t_verts = transform_points(box_verts)
+                    x, y, z = t_verts[:, 0], t_verts[:, 1], t_verts[:, 2]
+
+                    i = [7, 0, 0, 0, 4, 4, 6, 6, 4, 0, 3, 2]
+                    j = [3, 4, 1, 2, 5, 6, 5, 2, 0, 1, 6, 3]
+                    k = [0, 7, 2, 3, 6, 7, 1, 1, 5, 5, 7, 6]
+
+                    fig.add_trace(
+                        go.Mesh3d(
+                            x=x, y=y, z=z, i=i, j=j, k=k,
+                            color="goldenrod",
+                            opacity=opacity_appendage,
+                            name=f"{app.name} (Appendage)",
+                            showscale=False,
+                        )
+                    )
+            elif geo_type == "Sphere" or geo_type == "Point":
+                center = app.center
+                volume = app.volume
+                t_center = transform_points([center])[0]
+
+                fig.add_trace(
+                    go.Scatter3d(
+                        x=[t_center[0]],
+                        y=[t_center[1]],
+                        z=[t_center[2]],
+                        mode="markers",
+                        marker=dict(
+                            size=10, color="goldenrod", symbol="circle"),
+                        name=f"{app.name} (Appendage)",
+                        text=f"Vol: {volume:.3f}m³",
+                    )
+                )
+
+    # 6. Deck Edges
+    if show_deck_edges:
+        for edge in vessel.get_deck_edges():
+            points = edge.get_points()
+            if not points:
+                continue
+
+            t_points = transform_points(points)
+            x, y, z = t_points[:, 0], t_points[:, 1], t_points[:, 2]
+            side = edge.get_side()
+
+            color = "orange"
+            if "Port" in side:
+                color = "red"
+            elif "Starboard" in side:
+                color = "green"
+
+            fig.add_trace(
+                go.Scatter3d(
+                    x=x, y=y, z=z,
+                    mode="lines+markers",
+                    line=dict(color=color, width=4),
+                    marker=dict(size=3, color=color),
+                    name=f"Deck Edge: {edge.name} ({side})",
+                )
+            )
+
+    # 7. Reference Points
     ap_pt = transform_points([(vessel.ap, 0, 0)])[0]
     fp_pt = transform_points([(vessel.fp, 0, 0)])[0]
 
@@ -615,7 +757,7 @@ def plot_hydrostatic_condition(
         )
     )
 
-    # 6. Center of Gravity
+    # 8. Center of Gravity
     if cog:
         cog_pt = transform_points([cog])[0]
         fig.add_trace(
@@ -801,25 +943,91 @@ def _add_hull_trace(fig: go.Figure, hull: Hull, name: str, opacity: float):
     if hasattr(hull, "get_vertices") and hasattr(hull, "get_faces"):
         verts = hull.get_vertices()
         faces = hull.get_faces()
+        if verts and faces:
+            x, y, z = zip(*verts)
+            i_idx, j_idx, k_idx = zip(*faces)
 
-        if not verts or not faces:
-            return
+            fig.add_trace(
+                go.Mesh3d(
+                    x=x,
+                    y=y,
+                    z=z,
+                    i=i_idx,
+                    j=j_idx,
+                    k=k_idx,
+                    color="gray",
+                    opacity=opacity,
+                    name=name,
+                    showscale=False,
+                    flatshading=True,
+                )
+            )
+
+
+def _add_appendage_trace(fig: go.Figure, app: Any, opacity: float):
+    """Helper to add appendage to figure."""
+    geo_type = app.geometry_type()
+
+    if geo_type == "Mesh":
+        mesh_data = app.get_mesh_data()
+        if mesh_data:
+            verts, faces = mesh_data
+            if verts and faces:
+                x, y, z = zip(*verts)
+                i_idx, j_idx, k_idx = zip(*faces)
+
+                fig.add_trace(
+                    go.Mesh3d(
+                        x=x,
+                        y=y,
+                        z=z,
+                        i=i_idx,
+                        j=j_idx,
+                        k=k_idx,
+                        color="darkkhaki",
+                        opacity=opacity,
+                        name=f"{app.name} (Appendage)",
+                        showscale=False,
+                        flatshading=True,
+                    )
+                )
+    elif geo_type == "Box" or geo_type == "Cube":
+        bounds = app.bounds
+        if bounds:
+            xmin, xmax, ymin, ymax, zmin, zmax = bounds
 
-        x, y, z = zip(*verts)
-        i, j, k = zip(*faces)
+            # Create a box mesh
+            x = [xmin, xmin, xmax, xmax, xmin, xmin, xmax, xmax]
+            y = [ymin, ymax, ymax, ymin, ymin, ymax, ymax, ymin]
+            z = [zmin, zmin, zmin, zmin, zmax, zmax, zmax, zmax]
 
+            i = [7, 0, 0, 0, 4, 4, 6, 6, 4, 0, 3, 2]
+            j = [3, 4, 1, 2, 5, 6, 5, 2, 0, 1, 6, 3]
+            k = [0, 7, 2, 3, 6, 7, 1, 1, 5, 5, 7, 6]
+
+            fig.add_trace(
+                go.Mesh3d(
+                    x=x, y=y, z=z, i=i, j=j, k=k,
+                    color="goldenrod",
+                    opacity=opacity,
+                    name=f"{app.name} (Appendage)",
+                    showscale=False,
+                )
+            )
+    elif geo_type == "Sphere" or geo_type == "Point":
+        # Draw as a marker or simple sphere if we want
+        center = app.center
+        volume = app.volume
+
+        # Simple marker for now
         fig.add_trace(
-            go.Mesh3d(
-                x=x,
-                y=y,
-                z=z,
-                i=i,
-                j=j,
-                k=k,
-                color="gray",
-                opacity=opacity,
-                name=name,
-                showscale=False,
-                flatshading=True,
+            go.Scatter3d(
+                x=[center[0]],
+                y=[center[1]],
+                z=[center[2]],
+                mode="markers",
+                marker=dict(size=10, color="goldenrod", symbol="circle"),
+                name=f"{app.name} (Appendage)",
+                text=f"Vol: {volume:.3f}m³",
             )
         )

{navaltoolbox-0.3.0 → navaltoolbox-0.4.0}/rust/Cargo.lock

@@ -655,7 +655,7 @@ dependencies = [
 
 [[package]]
 name = "navaltoolbox"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "approx",
  "dxf",

{navaltoolbox-0.3.0 → navaltoolbox-0.4.0}/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "navaltoolbox"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2021"
 description = "High-performance naval architecture library for hydrostatics, stability, and tank calculations"
 authors = ["Antoine ANCEAU"]
@@ -23,8 +23,6 @@ parry3d-f64 = "0.18"
 nalgebra = "0.33"
 # STL file loading
 stl_io = "0.8"
-# VTK file loading (optional, for later)
-# vtkio = "0.6"
 # Fast polygon triangulation for waterline caps
 earcutr = "0.4"
 # Ordered floats for HashMap keys

{navaltoolbox-0.3.0 → navaltoolbox-0.4.0}/rust/README.md

@@ -38,7 +38,7 @@ Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-navaltoolbox = "0.2"
+navaltoolbox = "0.4"
 ```
 
 ## Quick Start