feat(motor): motor-only drawing-geometry endpoint

Add a standalone GET /motors/{id}/drawing-geometry that returns
exactly the motor patches rocketpy's Rocket.draw() would produce,
rendered at the motor's own coordinate origin rather than embedded
inside a rocket. Lets the jarvis playground show 'rocket + motor'
and 'motor only' as distinct views without duplicating render logic
client-side.

Refactor:
- Extracted motor-drawing code out of RocketService._build_motor_geometry
  into MotorService.build_drawing_geometry(motor_position, parent_csys)
  and a public MotorService.get_drawing_geometry() wrapper. One code
  path now serves both endpoints; RocketService.build_motor_geometry
  is a two-line delegate.
- Moved shared helpers (_polygon_xy, _rebuild_polygon,
  _build_generic_chamber_patch) from src/services/rocket.py to
  src/services/motor.py where they logically belong.
- Moved shared drawing view types (NoseConeGeometry, TailGeometry,
  FinOutline, FinsGeometry, TubeGeometry, MotorPatch,
  MotorDrawingGeometry, RailButtonsGeometry, SensorGeometry,
  DrawingBounds) from src/views/rocket.py to a new
  src/views/drawing.py so both views/rocket.py and views/motor.py
  can depend on them without a circular import. views/rocket.py
  re-exports them for backwards compatibility with callers that
  still import from the old location.

Surface:
- New src/views/motor.py::MotorDrawingGeometryView: thin response
  envelope with motor (MotorDrawingGeometry), bounds (DrawingBounds),
  coordinate_system_orientation. ser_json_exclude_none matches the
  rocket response convention.
- New MotorController.get_motor_drawing_geometry(motor_id) method
  returning the view. 422 when the motor has no drawable patches
  (EmptyMotor edge); 404 from the existing get_motor_by_id path.
- New route GET /motors/{motor_id}/drawing-geometry.

Verified end-to-end against real rocketpy for every motor kind:
- Generic: 3 patches (chamber, nozzle, outline)
- Solid:   9 patches (chamber, 7x grain, nozzle, outline)
- Liquid:  3 patches (tank, nozzle, outline)
- Hybrid:  6 patches (chamber, grain, tank, nozzle, outline)
Rocket-embedded drawing unchanged (regression-tested: rocket.motor
remains at rocket.motor_position; bounds, patch roles, and patch
counts identical to pre-refactor).

Full suite: 156/156 passing.

Author: aasitvora99

src/controllers/motor.py

@@ -2,7 +2,7 @@
     ControllerBase,
     controller_exception_handler,
 )
-from src.views.motor import MotorSimulation
+from src.views.motor import MotorSimulation, MotorDrawingGeometryView
 from src.models.motor import MotorModel
 from src.services.motor import MotorService
 
@@ -57,3 +57,27 @@ async def get_motor_simulation(self, motor_id: str) -> MotorSimulation:
         motor = await self.get_motor_by_id(motor_id)
         motor_service = MotorService.from_motor_model(motor.motor)
         return motor_service.get_motor_simulation()
+
+    @controller_exception_handler
+    async def get_motor_drawing_geometry(
+        self, motor_id: str
+    ) -> MotorDrawingGeometryView:
+        """
+        Build the motor-only drawing-geometry payload for a persisted motor.
+
+        Renders the motor at its own coordinate origin (motor_position=0,
+        parent_csys=1) so the playground can show a motor in isolation.
+
+        Args:
+            motor_id: str
+
+        Returns:
+            views.MotorDrawingGeometryView
+
+        Raises:
+            HTTP 404 Not Found: If the motor does not exist in the database.
+            HTTP 422: If the motor has no drawable geometry.
+        """
+        motor = await self.get_motor_by_id(motor_id)
+        motor_service = MotorService.from_motor_model(motor.motor)
+        return motor_service.get_drawing_geometry()

src/routes/motor.py

@@ -9,6 +9,7 @@
     MotorSimulation,
     MotorCreated,
     MotorRetrieved,
+    MotorDrawingGeometryView,
 )
 from src.models.motor import MotorModel
 from src.dependencies import MotorControllerDep
@@ -138,3 +139,24 @@ async def get_motor_simulation(
     """
     with tracer.start_as_current_span("get_motor_simulation"):
         return await controller.get_motor_simulation(motor_id)
+
+
+@router.get("/{motor_id}/drawing-geometry")
+async def get_motor_drawing_geometry(
+    motor_id: str,
+    controller: MotorControllerDep,
+) -> MotorDrawingGeometryView:
+    """
+    Returns motor-only drawing geometry so a frontend can render the
+    motor in isolation. The payload mirrors what the motor portion of
+    `rocketpy.Rocket.draw()` would produce, but at the motor's own
+    coordinate origin rather than embedded inside a rocket.
+
+    Use `GET /rockets/{rocket_id}/drawing-geometry` instead when the
+    motor should be shown inside a complete rocket.
+
+    ## Args
+    ``` motor_id: Motor ID ```
+    """
+    with tracer.start_as_current_span("get_motor_drawing_geometry"):
+        return await controller.get_motor_drawing_geometry(motor_id)

src/services/motor.py

@@ -1,12 +1,15 @@
 from typing import Self
 
 import dill
+import numpy as np
 
-from rocketpy.motors.motor import GenericMotor, Motor as RocketPyMotor
+from rocketpy.motors.motor import Motor as RocketPyMotor
 from rocketpy.motors.solid_motor import SolidMotor
 from rocketpy.motors.liquid_motor import LiquidMotor
 from rocketpy.motors.hybrid_motor import HybridMotor
-from rocketpy import (
+from rocketpy.motors import (
+    EmptyMotor,
+    GenericMotor,
     LevelBasedTank,
     MassBasedTank,
     MassFlowRateBasedTank,
@@ -16,12 +19,72 @@
 
 from fastapi import HTTPException, status
 
+from src import logger
 from src.models.sub.tanks import TankKinds
 from src.models.motor import MotorKinds, MotorModel
-from src.views.motor import MotorSimulation
+from src.views.motor import MotorSimulation, MotorDrawingGeometryView
+from src.views.drawing import (
+    DrawingBounds,
+    MotorDrawingGeometry,
+    MotorPatch,
+)
 from src.utils import collect_attributes
 
 
+# ---------------------------------------------------------------------------
+# Drawing-geometry helpers (module-level, shared by the motor and rocket
+# drawing paths). Kept private with the `_` prefix; consumers should go
+# through `MotorService.get_drawing_geometry` for the motor-only response
+# or through `RocketService.get_drawing_geometry` for the composed rocket
+# view (which delegates motor assembly here).
+# ---------------------------------------------------------------------------
+def _polygon_xy(patch) -> dict:
+    """Extract (x, y) coordinate lists from a matplotlib Polygon patch.
+
+    Rocketpy's `_MotorPlots` generator helpers return matplotlib `Polygon`
+    objects; we only ever read `patch.xy` (an Nx2 numpy array) as a data
+    carrier, never for rendering.
+    """
+    xy = np.asarray(patch.xy)
+    return {"x": xy[:, 0].tolist(), "y": xy[:, 1].tolist()}
+
+
+def _rebuild_polygon(x: list[float], y: list[float]):
+    """Rebuild a matplotlib `Polygon` from coordinate lists.
+
+    Used only so `_MotorPlots._generate_motor_region` can read `patch.xy`
+    bounds when we assemble the motor outline.
+    """
+    from matplotlib.patches import (
+        Polygon,
+    )  # local import keeps service cold-start lean
+
+    return Polygon(np.column_stack([np.asarray(x), np.asarray(y)]))
+
+
+def _build_generic_chamber_patch(
+    center_x: float, chamber_height: float, chamber_radius: float
+):
+    """Build a rectangular combustion-chamber polygon for a GenericMotor.
+
+    Mirrors the vertex order of
+    `rocketpy.plots.motor_plots._generate_combustion_chamber` so the patch
+    can flow through `_generate_motor_region` for outline computation
+    identically to a SolidMotor chamber.
+    """
+    from matplotlib.patches import (
+        Polygon,
+    )  # local import keeps service cold-start lean
+
+    half_len = chamber_height / 2.0
+    x = np.array([-half_len, half_len, half_len, -half_len])
+    y = np.array(
+        [chamber_radius, chamber_radius, -chamber_radius, -chamber_radius]
+    )
+    x = x + center_x
+    return Polygon(np.column_stack([x, y]))
+
+
 class MotorService:
     _motor: RocketPyMotor
 
@@ -184,3 +247,193 @@ def get_motor_binary(self) -> bytes:
             bytes
         """
         return dill.dumps(self.motor)
+
+    # --------------------------------------------------------------------
+    # Drawing geometry
+    # --------------------------------------------------------------------
+    def get_drawing_geometry(
+        self,
+        motor_position: float = 0.0,
+        parent_csys: int = 1,
+    ) -> MotorDrawingGeometryView:
+        """Build a motor-only drawing-geometry response.
+
+        Defaults render the motor at its own coordinate origin
+        (`motor_position=0`, `parent_csys=1`) so the payload can be used
+        standalone in the playground's "motor-only" view. Callers that
+        embed the motor into a rocket (see ``RocketService``) pass the
+        rocket-level position + csys to align the motor inside the rocket
+        frame.
+
+        Raises:
+            HTTPException 422 if the motor has no drawable patches.
+        """
+        motor_geometry, _nozzle_position = self.build_drawing_geometry(
+            motor_position=motor_position, parent_csys=parent_csys
+        )
+        if motor_geometry is None:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail="Motor has no drawable geometry.",
+            )
+        # Fall back to the nozzle radius when the motor has no drawable
+        # patches (e.g. EmptyMotor) so the bounds aren't a zero-height
+        # line. Every real rocketpy motor class exposes nozzle_radius.
+        fallback_radius = float(getattr(self._motor, "nozzle_radius", 0.0) or 0.0)
+        return MotorDrawingGeometryView(
+            motor=motor_geometry,
+            coordinate_system_orientation=str(
+                self._motor.coordinate_system_orientation
+            ),
+            bounds=_compute_motor_bounds(motor_geometry, fallback_radius),
+        )
+
+    def build_drawing_geometry(
+        self,
+        motor_position: float,
+        parent_csys: int,
+    ) -> tuple[MotorDrawingGeometry | None, float]:
+        """Construct motor patches + the absolute nozzle x-position.
+
+        Returned as a tuple so the rocket service can use the nozzle
+        position when extending body tubes to meet the motor. Standalone
+        motor rendering can discard the second element.
+        """
+        motor = self._motor
+        total_csys = parent_csys * motor._csys
+        nozzle_position = motor_position + motor.nozzle_position * total_csys
+
+        if isinstance(motor, EmptyMotor):
+            return (
+                MotorDrawingGeometry(
+                    type="empty",
+                    position=float(motor_position),
+                    nozzle_position=float(nozzle_position),
+                    patches=[],
+                ),
+                float(nozzle_position),
+            )
+
+        patches: list[MotorPatch] = []
+        grains_cm_position: float | None = None
+        motor_type = "generic"
+
+        if isinstance(motor, SolidMotor):
+            motor_type = "solid"
+            grains_cm_position = (
+                motor_position
+                + motor.grains_center_of_mass_position * total_csys
+            )
+            chamber = motor.plots._generate_combustion_chamber(
+                translate=(grains_cm_position, 0), label=None
+            )
+            patches.append(MotorPatch(role="chamber", **_polygon_xy(chamber)))
+            for grain in motor.plots._generate_grains(
+                translate=(grains_cm_position, 0)
+            ):
+                patches.append(MotorPatch(role="grain", **_polygon_xy(grain)))
+        elif isinstance(motor, HybridMotor):
+            motor_type = "hybrid"
+            grains_cm_position = (
+                motor_position
+                + motor.grains_center_of_mass_position * total_csys
+            )
+            chamber = motor.plots._generate_combustion_chamber(
+                translate=(grains_cm_position, 0), label=None
+            )
+            patches.append(MotorPatch(role="chamber", **_polygon_xy(chamber)))
+            for grain in motor.plots._generate_grains(
+                translate=(grains_cm_position, 0)
+            ):
+                patches.append(MotorPatch(role="grain", **_polygon_xy(grain)))
+            for tank, _center in motor.plots._generate_positioned_tanks(
+                translate=(motor_position, 0), csys=total_csys
+            ):
+                patches.append(MotorPatch(role="tank", **_polygon_xy(tank)))
+        elif isinstance(motor, LiquidMotor):
+            motor_type = "liquid"
+            for tank, _center in motor.plots._generate_positioned_tanks(
+                translate=(motor_position, 0), csys=total_csys
+            ):
+                patches.append(MotorPatch(role="tank", **_polygon_xy(tank)))
+        elif isinstance(motor, GenericMotor):
+            # RocketPy's Rocket.draw() does not render a chamber for
+            # GenericMotor — `_generate_combustion_chamber` depends on
+            # grain fields GenericMotor lacks. We build an equivalent
+            # rectangular chamber from the GenericMotor fields so users
+            # see their chamber geometry in the playground.
+            motor_type = "generic"
+            chamber_center_x = (
+                motor_position + motor.chamber_position * total_csys
+            )
+            chamber_patch = _build_generic_chamber_patch(
+                center_x=chamber_center_x,
+                chamber_height=motor.chamber_height,
+                chamber_radius=motor.chamber_radius,
+            )
+            patches.append(
+                MotorPatch(role="chamber", **_polygon_xy(chamber_patch))
+            )
+
+        # Nozzle is always appended after the body so the motor-region
+        # outline encompasses it, matching rocketpy.
+        nozzle_patch = motor.plots._generate_nozzle(
+            translate=(nozzle_position, 0), csys=parent_csys
+        )
+        patches.append(MotorPatch(role="nozzle", **_polygon_xy(nozzle_patch)))
+
+        # Motor-region outline. `_generate_motor_region` reads patch.xy
+        # arrays, so we rebuild matplotlib Polygons once from our
+        # coordinate copies. Any failure here is logged and dropped; the
+        # outline is advisory, not load-bearing.
+        try:
+            mpl_patches = [_rebuild_polygon(p.x, p.y) for p in patches]
+            outline_patch = motor.plots._generate_motor_region(
+                list_of_patches=mpl_patches
+            )
+            patches.insert(
+                0, MotorPatch(role="outline", **_polygon_xy(outline_patch))
+            )
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.warning("Failed to generate motor outline patch: %s", exc)
+
+        return (
+            MotorDrawingGeometry(
+                type=motor_type,
+                position=float(motor_position),
+                nozzle_position=float(nozzle_position),
+                grains_center_of_mass_position=(
+                    float(grains_cm_position)
+                    if grains_cm_position is not None
+                    else None
+                ),
+                patches=patches,
+            ),
+            float(nozzle_position),
+        )
+
+
+def _compute_motor_bounds(
+    motor: MotorDrawingGeometry, radius: float
+) -> DrawingBounds:
+    """Compute a tight bounding box for a motor-only drawing payload.
+
+    Mirrors the rocket-side bounds helper but limited to motor patches —
+    callers who want rocket-wide bounds use the rocket service's own
+    computation.
+    """
+    xs: list[float] = []
+    ys: list[float] = []
+    for patch in motor.patches:
+        xs += patch.x
+        ys += patch.y
+    if not xs:
+        xs = [float(motor.position)]
+    if not ys:
+        ys = [-float(radius), float(radius)]
+    return DrawingBounds(
+        x_min=float(min(xs)),
+        x_max=float(max(xs)),
+        y_min=float(min(ys)),
+        y_max=float(max(ys)),
+    )