tangram-ship162 0.2.1__cp314-cp314-musllinux_1_1_aarch64.whl

tangram_ship162/ShipCountWidget.vue

@@ -0,0 +1,50 @@
+<template>
+  <div class="ship-count-widget">
+    <div class="count-display">
+      <span id="visible_ships_count">{{ visibleCount }}</span> (<span>{{
+        totalCount ?? 0
+      }}</span
+      >)
+    </div>
+    <span id="count_ships">visible ships</span>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, inject } from "vue";
+import type { TangramApi } from "@open-aviation/tangram-core/api";
+
+const tangramApi = inject<TangramApi>("tangramApi");
+if (!tangramApi) {
+  throw new Error("assert: tangram api not provided");
+}
+
+const totalCount = computed(
+  () => tangramApi.state.totalCounts.value?.get("ship162_ship") ?? 0
+);
+const visibleCount = computed(
+  () => tangramApi.state.getEntitiesByType("ship162_ship").value?.size ?? 0
+);
+</script>
+
+<style scoped>
+#visible_ships_count {
+  font-size: 1em;
+  color: #4c78a8;
+}
+#count_ships {
+  color: #79706e;
+  font-size: 9pt;
+  text-align: center;
+}
+.ship-count-widget {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: 1px;
+  border-bottom: 1px solid #ddd;
+}
+.count-display {
+  text-align: center;
+}
+</style>

tangram_ship162/ShipInfoWidget.vue

@@ -0,0 +1,277 @@
+<template>
+  <div class="ship-list">
+    <div
+      v-for="item in shipList"
+      :key="item.id"
+      class="list-item"
+      :class="{ expanded: isExpanded(item.id) }"
+    >
+      <div class="header" @click="toggleExpand(item.id)">
+        <div class="row main-row">
+          <div class="left-group">
+            <span v-if="item.state.ship_name" class="ship-name">{{
+              item.state.ship_name
+            }}</span>
+            <span v-else class="ship-name no-data">[no name]</span>
+            <span v-if="item.state.ship_type" class="chip blue">{{
+              item.state.ship_type
+            }}</span>
+            <span class="chip yellow">{{ item.state.mmsi }}</span>
+          </div>
+          <div class="right-group">
+            <span v-if="item.state.speed !== undefined"
+              >{{ item.state.speed.toFixed(1) }} kts</span
+            >
+            <span
+              v-if="item.state.speed !== undefined && item.state.course !== undefined"
+              class="sep"
+              >·</span
+            >
+            <span v-if="item.state.course !== undefined"
+              >{{ item.state.course.toFixed(0) }}°</span
+            >
+          </div>
+        </div>
+        <div class="row sub-row">
+          <div class="left-group destination">
+            {{ item.state.destination || "No destination" }}
+          </div>
+          <div class="right-group"></div>
+        </div>
+      </div>
+
+      <div v-if="isExpanded(item.id)" class="details-body" @click.stop>
+        <div class="details-header">
+          <span v-if="item.state.mmsi_info?.flag">
+            {{ item.state.mmsi_info.flag }}
+            {{ item.state.mmsi_info.country }}
+          </span>
+          <span v-if="item.state.status" class="status-chip">{{
+            item.state.status
+          }}</span>
+        </div>
+
+        <table class="details-table">
+          <tr v-if="item.state.callsign">
+            <td class="label">Callsign:</td>
+            <td>{{ item.state.callsign }}</td>
+          </tr>
+          <tr v-if="item.state.imo">
+            <td class="label">IMO:</td>
+            <td>{{ item.state.imo }}</td>
+          </tr>
+          <tr v-if="getDimensions(item.state)">
+            <td class="label">Dimensions:</td>
+            <td>{{ getDimensions(item.state) }} m</td>
+          </tr>
+          <tr v-if="item.state.draught">
+            <td class="label">Draught:</td>
+            <td>{{ item.state.draught }} m</td>
+          </tr>
+        </table>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, inject, reactive, watch } from "vue";
+import type { TangramApi } from "@open-aviation/tangram-core/api";
+import type { Ship162Vessel } from ".";
+
+const tangramApi = inject<TangramApi>("tangramApi");
+if (!tangramApi) {
+  throw new Error("assert: tangram api not provided");
+}
+
+const expandedIds = reactive(new Set<string>());
+
+const shipList = computed(() => {
+  const list = [];
+  for (const [id, entity] of tangramApi.state.activeEntities.value) {
+    if (entity.type === "ship162_ship") {
+      list.push({ id, state: entity.state as Ship162Vessel });
+    }
+  }
+  return list.sort((a, b) => a.id.localeCompare(b.id));
+});
+
+const isExpanded = (id: string) => {
+  return shipList.value.length === 1 || expandedIds.has(id);
+};
+
+const toggleExpand = (id: string) => {
+  if (shipList.value.length === 1) return;
+  if (expandedIds.has(id)) {
+    expandedIds.delete(id);
+  } else {
+    expandedIds.add(id);
+  }
+};
+
+const getDimensions = (state: Ship162Vessel) => {
+  const { to_bow, to_stern, to_port, to_starboard } = state;
+  if (to_bow != null && to_stern != null && to_port != null && to_starboard != null) {
+    const length = to_bow + to_stern;
+    const width = to_port + to_starboard;
+    if (length > 0 || width > 0) {
+      return `${length} x ${width}`;
+    }
+  }
+  return null;
+};
+
+watch(
+  () => shipList.value.length,
+  (newLen, oldLen) => {
+    if (oldLen === 1 && newLen === 2) {
+      expandedIds.clear();
+    }
+  }
+);
+</script>
+
+<style scoped>
+.ship-list {
+  display: flex;
+  flex-direction: column;
+  max-height: calc(100vh - 150px);
+  overflow-y: auto;
+}
+
+.list-item {
+  border-bottom: 1px solid #eee;
+  cursor: pointer;
+  background-color: white;
+}
+
+.list-item:hover .header {
+  background-color: #f5f5f5;
+}
+
+.header {
+  padding: 4px 8px;
+}
+
+.expanded .header {
+  border-bottom: 1px solid #eee;
+  background-color: #f0f7ff;
+}
+
+.details-body {
+  padding: 10px;
+  cursor: default;
+}
+
+.row {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  line-height: 1.4;
+}
+
+.main-row {
+  margin-bottom: 2px;
+}
+
+.left-group {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+
+.right-group {
+  text-align: right;
+  display: flex;
+  gap: 4px;
+  font-family: "B612", monospace;
+  font-size: 0.9em;
+  color: #333;
+  white-space: nowrap;
+}
+
+.ship-name {
+  font-size: 1.1em;
+  font-weight: bold;
+}
+
+.no-data {
+  color: #888;
+  font-style: italic;
+  font-size: 1em;
+}
+
+.destination {
+  font-size: 0.9em;
+  color: #666;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  max-width: 200px;
+}
+
+.chip {
+  border-radius: 5px;
+  padding: 0px 5px;
+  font-family: "Inconsolata", monospace;
+  font-size: 1em;
+  white-space: nowrap;
+}
+
+.chip.blue {
+  background-color: #4c78a8;
+  color: white;
+  border: 1px solid #4c78a8;
+}
+
+.chip.yellow {
+  background-color: #f2cf5b;
+  color: black;
+  border: 1px solid #e0c050;
+}
+
+.sub-row .right-group {
+  color: #666;
+}
+
+.sep {
+  color: #aaa;
+  font-weight: normal;
+}
+
+/* details */
+.details-header {
+  margin-bottom: 10px;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.status-chip {
+  background-color: #eee;
+  padding: 2px 6px;
+  border-radius: 10px;
+  font-size: 0.9em;
+  color: #555;
+}
+
+.details-table {
+  border-collapse: collapse;
+  width: 100%;
+}
+
+.details-table td {
+  padding: 1px 0;
+  border: none;
+}
+
+.details-table .label {
+  text-align: right;
+  font-weight: bold;
+  padding-right: 10px;
+  white-space: nowrap;
+  width: 1%;
+  color: #555;
+}
+</style>

tangram_ship162/ShipLayer.vue

@@ -0,0 +1,458 @@
+<template>
+  <div
+    v-if="tooltip.object"
+    class="deck-tooltip"
+    :style="{ left: `${tooltip.x}px`, top: `${tooltip.y}px` }"
+  >
+    <div class="tooltip-grid">
+      <div class="ship-name">
+        {{ tooltip.object.state.mmsi_info?.flag }}
+        {{ tooltip.object.state.ship_name || "N/A" }}
+      </div>
+      <div></div>
+
+      <div class="ship-type">{{ tooltip.object.state.ship_type }}</div>
+      <div class="mmsi">{{ tooltip.object.state.mmsi }}</div>
+      <div v-if="tooltip.object.state.speed" class="speed">
+        {{ tooltip.object.state.speed.toFixed(1) }} kts
+      </div>
+      <div v-if="tooltip.object.state.course" class="course">
+        {{ tooltip.object.state.course.toFixed(0) }}°
+      </div>
+      <div v-if="tooltip.object.state.destination" class="destination">
+        {{ tooltip.object.state.destination }}
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, inject, onUnmounted, ref, watch, reactive, type Ref } from "vue";
+import { IconLayer, PolygonLayer } from "@deck.gl/layers";
+import type { TangramApi, Entity, Disposable } from "@open-aviation/tangram-core/api";
+import { oklchToDeckGLColor } from "@open-aviation/tangram-core/colour";
+import type { Ship162Vessel } from ".";
+import type { PickingInfo } from "@deck.gl/core";
+
+// Type alias to match internal use
+type ShipState = Ship162Vessel;
+
+const tangramApi = inject<TangramApi>("tangramApi");
+if (!tangramApi) {
+  throw new Error("assert: tangram api not provided");
+}
+
+const shipEntities = computed(
+  () => tangramApi.state.getEntitiesByType<ShipState>("ship162_ship").value
+);
+const activeEntities = computed(() => tangramApi.state.activeEntities.value);
+const layerDisposable: Ref<Disposable | null> = ref(null);
+const hullLayerDisposable: Ref<Disposable | null> = ref(null);
+const zoom = computed(() => tangramApi.map.zoom.value);
+
+const tooltip = reactive<{
+  x: number;
+  y: number;
+  object: Entity<ShipState> | null;
+}>({ x: 0, y: 0, object: null });
+
+const colors = {
+  passenger: oklchToDeckGLColor(0.65, 0.2, 260, 180), // blue
+  cargo: oklchToDeckGLColor(0.65, 0.15, 140, 180), // green
+  tanker: oklchToDeckGLColor(0.65, 0.2, 40, 180), // red-orange
+  high_speed: oklchToDeckGLColor(0.9, 0.25, 90, 180), // yellow
+  pleasure: oklchToDeckGLColor(0.65, 0.2, 330, 180), // magenta
+  fishing: oklchToDeckGLColor(0.7, 0.2, 200, 180), // cyan
+  special: oklchToDeckGLColor(0.75, 0.18, 70, 180), // orange
+  aton: oklchToDeckGLColor(0.9, 0.25, 90, 180), // yellow
+  sar: oklchToDeckGLColor(0.7, 0.25, 50, 180), // orange
+  default: oklchToDeckGLColor(0.6, 0, 0, 180), // grey
+  selected: oklchToDeckGLColor(0.7, 0.25, 20, 220) // bright red
+};
+
+const isStationary = (state: ShipState): boolean => {
+  if (state.speed !== undefined && state.speed < 1.0) return true;
+  if (
+    state.status === "At anchor" ||
+    state.status === "Moored" ||
+    state.status === "Aground"
+  )
+    return true;
+  return false;
+};
+
+const getIconColor = (
+  state: ShipState | undefined
+): [number, number, number, number] => {
+  if (!state) return colors.default;
+
+  switch (state.ship_type) {
+    case "Passenger":
+      return colors.passenger;
+    case "Cargo":
+      return colors.cargo;
+    case "Tanker":
+      return colors.tanker;
+    case "High Speed Craft":
+      return colors.high_speed;
+    case "Pleasure craft":
+    case "Sailing":
+      return colors.pleasure;
+    case "Fishing":
+      return colors.fishing;
+    case "Tug":
+    case "Towing":
+    case "Towing, large":
+    case "Pilot Vessel":
+    case "Search and Rescue":
+    case "Port Tender":
+    case "Dredging or underwater operations":
+    case "Diving operations":
+    case "Military operations":
+    case "Law Enforcement":
+    case "Anti-Pollution Equipment":
+      return colors.special;
+  }
+
+  if (state.mmsi_info) {
+    switch (state.ship_type) {
+      case "SAR Aircraft":
+        return colors.sar;
+      case "AIS AtoN":
+        return colors.aton;
+    }
+  }
+
+  return colors.default;
+};
+
+const pointySvg = (color: string) =>
+  `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="-12 -12 24 24" fill="${color}" stroke="black" stroke-width="0.5"><path d="M 0 -10 L 4 8 L 0 5 L -4 8 Z"/></svg>`;
+const circleSvg = (color: string) =>
+  `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="-12 -12 24 24" fill="${color}" stroke="black" stroke-width="0.5"><circle cx="0" cy="0" r="4"/></svg>`;
+const diamondSvg = (color: string) =>
+  `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="-12 -12 24 24" fill="${color}" stroke="black" stroke-width="0.5"><path d="M 0 -8 L 8 0 L 0 8 L -8 0 Z"/></svg>`;
+
+const iconCache = new Map<string, string>();
+
+const rgbToHex = (r: number, g: number, b: number) =>
+  "#" +
+  [r, g, b]
+    .map(x => {
+      const hex = x.toString(16);
+      return hex.length === 1 ? "0" + hex : hex;
+    })
+    .join("");
+
+const getShipIcon = (
+  state: ShipState,
+  isSelected: boolean
+): { url: string; id: string } => {
+  const stationary = isStationary(state);
+  const isAton = state.ship_type === "AIS AtoN";
+  const colorArray = isSelected ? colors.selected : getIconColor(state);
+  const color = rgbToHex(colorArray[0], colorArray[1], colorArray[2]);
+  const cacheKey = `${color}-${stationary}-${isAton}`;
+
+  if (iconCache.has(cacheKey)) {
+    return { url: iconCache.get(cacheKey)!, id: cacheKey };
+  }
+
+  let svg;
+  if (isAton) {
+    svg = diamondSvg(color);
+  } else if (stationary) {
+    svg = circleSvg(color);
+  } else {
+    svg = pointySvg(color);
+  }
+
+  const dataUrl = `data:image/svg+xml;base64,${btoa(svg)}`;
+  iconCache.set(cacheKey, dataUrl);
+  return { url: dataUrl, id: cacheKey };
+};
+
+/**
+ * Calculate ship hull polygon coordinates based on AIS dimensions.
+ * Returns a polygon in [lon, lat] format relative to ship's position.
+ * This implementation matches the algorithm in AISCatcher's script.js.
+ */
+const getShipHullPolygon = (state: ShipState): number[][] | null => {
+  const {
+    to_bow,
+    to_stern,
+    to_port,
+    to_starboard,
+    latitude,
+    longitude,
+    course,
+    heading
+  } = state;
+
+  // Check if we have all required dimension data
+  if (!to_bow || !to_stern || !to_port || !to_starboard) {
+    return null;
+  }
+
+  // Use heading if available, otherwise course
+  let finalHeading = heading;
+
+  if (finalHeading === null || finalHeading === undefined) {
+    if (course != null && state.speed && state.speed > 1) {
+      finalHeading = course;
+    } else {
+      // No valid heading - can't draw oriented shape
+      return null;
+    }
+  }
+
+  const coordinate = [longitude, latitude];
+
+  // Calculate offset for 1 meter in lat/lon at this position
+  // This matches aiscatcher.js's calcOffset1M
+  // const R = 6378137; // Earth radius in meters (WGS84)
+  const cos100R = 0.9999999998770914; // cos(100m / R)
+  const sin100R = 1.567855942823164e-5; // sin(100m / R)
+  const rad = Math.PI / 180;
+  const radInv = 180 / Math.PI;
+
+  const lat = coordinate[1] * rad;
+  const rheading = ((finalHeading + 360) % 360) * rad;
+  const sinLat = Math.sin(lat);
+  const cosLat = Math.cos(lat);
+
+  const sinLat2 = sinLat * cos100R + cosLat * sin100R * Math.cos(rheading);
+  const lat2 = Math.asin(sinLat2);
+  const deltaLon = Math.atan2(
+    Math.sin(rheading) * sin100R * cosLat,
+    cos100R - sinLat * sinLat2
+  );
+
+  // deltaNorth: [deltaLat, deltaLon] for 1m north
+  // deltaEast: [deltaLat, deltaLon] for 1m east (perpendicular to north)
+  const deltaNorth = [(lat2 * radInv - coordinate[1]) / 100, (deltaLon * radInv) / 100];
+  // Perpendicular vector for east (rotate by +90deg)
+  const rheadingEast = ((finalHeading + 90 + 360) % 360) * rad;
+  const sinLat2East = sinLat * cos100R + cosLat * sin100R * Math.cos(rheadingEast);
+  const lat2East = Math.asin(sinLat2East);
+  const deltaLonEast = Math.atan2(
+    Math.sin(rheadingEast) * sin100R * cosLat,
+    cos100R - sinLat * sinLat2East
+  );
+  const deltaEast = [
+    (lat2East * radInv - coordinate[1]) / 100,
+    (deltaLonEast * radInv) / 100
+  ];
+
+  // Move function: [lon + delta[1] * distance, lat + delta[0] * distance]
+  const calcMove = (coord: number[], delta: number[], distance: number): number[] => {
+    return [coord[0] + delta[1] * distance, coord[1] + delta[0] * distance];
+  };
+
+  // Ship outline points (AISCatcher logic)
+  // const bow = calcMove(coordinate, deltaNorth, to_bow);
+  const stern = calcMove(coordinate, deltaNorth, -to_stern);
+
+  const A = calcMove(stern, deltaEast, to_starboard);
+  const B = calcMove(stern, deltaEast, -to_port);
+  const C = calcMove(B, deltaNorth, 0.8 * (to_bow + to_stern));
+  const Dmid = calcMove(C, deltaEast, 0.5 * (to_starboard + to_port));
+  const D = calcMove(Dmid, deltaNorth, 0.2 * (to_bow + to_stern));
+  const E = calcMove(C, deltaEast, to_starboard + to_port);
+
+  // Return ship outline as closed polygon
+  return [A, B, C, D, E, A];
+};
+
+const onClick = (
+  info: PickingInfo<Entity<ShipState>>,
+  event: { srcEvent: { originalEvent: MouseEvent } }
+) => {
+  if (!info.object) return;
+  const srcEvent = event.srcEvent.originalEvent;
+  const exclusive = !srcEvent.ctrlKey && !srcEvent.altKey && !srcEvent.metaKey;
+
+  if (exclusive) {
+    tangramApi.state.selectEntity(info.object, true);
+  } else {
+    if (tangramApi.state.activeEntities.value.has(info.object.id)) {
+      tangramApi.state.deselectEntity(info.object.id);
+    } else {
+      tangramApi.state.selectEntity(info.object, false);
+    }
+  }
+};
+
+watch(
+  [shipEntities, activeEntities, () => tangramApi.map.isReady.value, zoom],
+  ([entities, currentActiveEntities, isMapReady, currentZoom]) => {
+    if (!entities || !isMapReady) return;
+
+    if (layerDisposable.value) layerDisposable.value.dispose();
+    if (hullLayerDisposable.value) {
+      hullLayerDisposable.value.dispose();
+      hullLayerDisposable.value = null;
+    }
+
+    // added a 0.9 factor because it looked slightly too large
+    const sizeScale = 0.9 * Math.min(Math.max(0.5, Math.pow(2, currentZoom - 10)), 2);
+    const showHulls = currentZoom >= 12;
+    const selectedIds = new Set(currentActiveEntities.keys());
+
+    // Ship hull layer (only visible at high zoom)
+    const baseData: Entity<ShipState>[] = [];
+    const selectedData: Entity<ShipState>[] = [];
+    for (const d of entities.values()) {
+      if (selectedIds.has(d.id)) {
+        selectedData.push(d);
+      } else {
+        baseData.push(d);
+      }
+    }
+    const allData = baseData.concat(selectedData);
+
+    if (showHulls) {
+      const hullData = allData
+        .map(entity => ({
+          entity,
+          polygon: getShipHullPolygon(entity.state)
+        }))
+        .filter(({ polygon }) => polygon !== null);
+
+      const hullLayer = new PolygonLayer<{
+        entity: Entity<ShipState>;
+        polygon: number[][];
+      }>({
+        id: "ship-hull-layer",
+        data: hullData,
+        pickable: true,
+        stroked: true,
+        filled: true,
+        wireframe: false,
+        lineWidthMinPixels: 1,
+        getPolygon: d => d.polygon,
+        getFillColor: d => {
+          return selectedIds.has(d.entity.id)
+            ? colors.selected
+            : getIconColor(d.entity.state);
+        },
+        getLineColor: d => {
+          return selectedIds.has(d.entity.id)
+            ? colors.selected
+            : getIconColor(d.entity.state);
+        },
+        getLineWidth: 0.5,
+        onClick: (info: PickingInfo, event: MjolnirEvent) => {
+          if (!info.object) return;
+          const entity = (info.object as any).entity;
+          const mockInfo = { ...info, object: entity } as PickingInfo<
+            Entity<ShipState>
+          >;
+          onClick(mockInfo, event);
+        },
+        updateTriggers: {
+          getFillColor: [currentActiveEntities]
+        }
+      });
+
+      const hullDisposable = tangramApi.map.setLayer(hullLayer);
+      if (!hullLayerDisposable.value) {
+        hullLayerDisposable.value = hullDisposable;
+      }
+    }
+
+    // Icon layer (always visible, but smaller when hulls are shown)
+    const shipLayer = new IconLayer<Entity<ShipState>>({
+      id: "ship-layer",
+      data: allData,
+      pickable: true,
+      billboard: false,
+      getIcon: d => {
+        const { url, id } = getShipIcon(d.state, selectedIds.has(d.id));
+        return {
+          url,
+          id,
+          width: 24,
+          height: 24,
+          anchorY: 12,
+          mask: false
+        };
+      },
+      sizeScale: showHulls ? sizeScale * 0.5 : sizeScale,
+      getPosition: d => [d.state.longitude!, d.state.latitude!],
+      getSize: 24,
+      getAngle: d => {
+        if (isStationary(d.state)) return 0;
+        return -(d.state.course || d.state.heading || 0);
+      },
+      onClick: onClick,
+      onHover: info => {
+        if (info.object) {
+          tooltip.object = info.object;
+          tooltip.x = info.x;
+          tooltip.y = info.y;
+        } else {
+          tooltip.object = null;
+        }
+      },
+      updateTriggers: {
+        getIcon: Array.from(currentActiveEntities.keys()).sort().join(","),
+        sizeScale: [showHulls]
+      },
+      // required for globe: https://github.com/visgl/deck.gl/issues/9777#issuecomment-3628393899
+      parameters: {
+        cullMode: "none"
+      }
+    });
+
+    layerDisposable.value = tangramApi.map.setLayer(shipLayer);
+  },
+  { immediate: true }
+);
+
+onUnmounted(() => {
+  layerDisposable.value?.dispose();
+  hullLayerDisposable.value?.dispose();
+});
+</script>
+
+<style>
+.deck-tooltip {
+  position: absolute;
+  background: white;
+  color: black;
+  padding: 4px 8px;
+  border-radius: 4px;
+  font-size: 11px;
+  font-family: "B612", sans-serif;
+  pointer-events: none;
+  transform: translate(10px, -20px);
+  z-index: 10;
+  min-width: 120px;
+}
+.tooltip-grid {
+  display: grid;
+  grid-template-columns: auto auto;
+  align-items: baseline;
+  column-gap: 0.5rem;
+}
+.ship-name {
+  font-weight: bold;
+  grid-column: 1 / 2;
+}
+.mmsi {
+  text-align: right;
+  grid-column: 2 / 3;
+}
+.speed {
+  grid-column: 1 / 2;
+}
+.course {
+  text-align: right;
+  grid-column: 2 / 3;
+}
+.destination {
+  grid-column: 1 / -1;
+  margin-top: 2px;
+}
+</style>

tangram_ship162/ShipTrailLayer.vue

@@ -0,0 +1,48 @@
+<script setup lang="ts">
+import { inject, onUnmounted, ref, watch, type Ref } from "vue";
+import { PathLayer } from "@deck.gl/layers";
+import type { TangramApi, Disposable } from "@open-aviation/tangram-core/api";
+import { shipStore } from "./store";
+import type { Layer } from "@deck.gl/core";
+
+const tangramApi = inject<TangramApi>("tangramApi");
+if (!tangramApi) throw new Error("assert: tangram api not provided");
+
+const layerDisposable: Ref<Disposable | null> = ref(null);
+
+const updateLayer = () => {
+  if (layerDisposable.value) {
+    layerDisposable.value.dispose();
+    layerDisposable.value = null;
+  }
+
+  const allPaths = Array.from(shipStore.selected.entries())
+    .filter(([, data]) => data.trajectory.length > 1)
+    .map(([id, data]) => ({
+      id,
+      path: data.trajectory
+        .filter(p => p.latitude != null && p.longitude != null)
+        .map(p => [p.longitude, p.latitude])
+    }));
+
+  if (allPaths.length > 0) {
+    const trailLayer = new PathLayer({
+      id: `ship-trails`,
+      data: allPaths,
+      pickable: false,
+      widthScale: 1,
+      widthMinPixels: 2,
+      getPath: d => d.path,
+      getColor: [128, 0, 128, 255],
+      getWidth: 2
+    }) as Layer;
+    layerDisposable.value = tangramApi.map.addLayer(trailLayer);
+  }
+};
+
+watch(() => shipStore.version, updateLayer);
+
+onUnmounted(() => {
+  layerDisposable.value?.dispose();
+});
+</script>

tangram_ship162/__init__.py

@@ -0,0 +1,133 @@
+from dataclasses import dataclass
+from typing import Any
+
+import tangram_core
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import Response
+from pydantic import TypeAdapter
+
+try:
+    import polars as pl
+
+    _HISTORY_AVAILABLE = True
+except ImportError:
+    _HISTORY_AVAILABLE = False
+
+
+router = APIRouter(
+    prefix="/ship162",
+    tags=["ship162"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@router.get("/data/{mmsi}")
+async def get_trajectory_data(
+    mmsi: int, backend_state: tangram_core.InjectBackendState
+) -> list[dict[str, Any]]:
+    """Get the full trajectory for a given ship MMSI."""
+    if not _HISTORY_AVAILABLE:
+        raise HTTPException(
+            status_code=501,
+            detail="History feature is not installed. "
+            "Install with `pip install 'tangram_ship162[history]'`",
+        )
+
+    redis_key = "tangram:history:table_uri:ship162"
+    table_uri_bytes = await backend_state.redis_client.get(redis_key)
+
+    if not table_uri_bytes:
+        raise HTTPException(
+            status_code=404,
+            detail=(
+                "Table 'ship162' not found.\nhelp: is the history service running?"
+            ),
+        )
+    table_uri = table_uri_bytes.decode("utf-8")
+
+    try:
+        df = (
+            pl.scan_delta(table_uri)
+            .filter(pl.col("mmsi") == mmsi)
+            .with_columns(pl.col("timestamp").dt.epoch(time_unit="s"))
+            .sort("timestamp")
+            .collect()
+        )
+        return Response(df.write_json(), media_type="application/json")
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to query trajectory data: {e}"
+        )
+
+
+@dataclass(frozen=True)
+class ShipsConfig(
+    tangram_core.config.HasTopbarUiConfig, tangram_core.config.HasSidebarUiConfig
+):
+    ship162_channel: str = "ship162"
+    history_table_name: str = "ship162"
+    history_control_channel: str = "history:control"
+    state_vector_expire: int = 600  # 10 minutes
+    stream_interval_secs: float = 1.0
+    log_level: str = "INFO"
+    history_buffer_size: int = 100_000
+    history_flush_interval_secs: int = 5
+    history_optimize_interval_secs: int = 120
+    history_optimize_target_file_size: int = 134217728
+    history_vacuum_interval_secs: int = 120
+    history_vacuum_retention_period_secs: int | None = 120
+    topbar_order: int = 100
+    sidebar_order: int = 100
+
+
+@dataclass(frozen=True)
+class FrontendShipsConfig(
+    tangram_core.config.HasTopbarUiConfig, tangram_core.config.HasSidebarUiConfig
+):
+    topbar_order: int
+    sidebar_order: int
+
+
+def transform_config(config_dict: dict[str, Any]) -> FrontendShipsConfig:
+    config = TypeAdapter(ShipsConfig).validate_python(config_dict)
+    return FrontendShipsConfig(
+        topbar_order=config.topbar_order,
+        sidebar_order=config.sidebar_order,
+    )
+
+
+plugin = tangram_core.Plugin(
+    frontend_path="dist-frontend",
+    routers=[router],
+    into_frontend_config_function=transform_config,
+)
+
+
+@plugin.register_service()
+async def run_ships(backend_state: tangram_core.BackendState) -> None:
+    from . import _ships
+
+    plugin_config = backend_state.config.plugins.get("tangram_ship162", {})
+    config_ships = TypeAdapter(ShipsConfig).validate_python(plugin_config)
+
+    default_log_level = plugin_config.get(
+        "log_level", backend_state.config.core.log_level
+    )
+
+    _ships.init_tracing_stderr(default_log_level)
+
+    rust_config = _ships.ShipsConfig(
+        redis_url=backend_state.config.core.redis_url,
+        ship162_channel=config_ships.ship162_channel,
+        history_control_channel=config_ships.history_control_channel,
+        state_vector_expire=config_ships.state_vector_expire,
+        stream_interval_secs=config_ships.stream_interval_secs,
+        history_table_name=config_ships.history_table_name,
+        history_buffer_size=config_ships.history_buffer_size,
+        history_flush_interval_secs=config_ships.history_flush_interval_secs,
+        history_optimize_interval_secs=config_ships.history_optimize_interval_secs,
+        history_optimize_target_file_size=config_ships.history_optimize_target_file_size,
+        history_vacuum_interval_secs=config_ships.history_vacuum_interval_secs,
+        history_vacuum_retention_period_secs=config_ships.history_vacuum_retention_period_secs,
+    )
+    await _ships.run_ships(rust_config)

tangram_ship162/_ships.pyi

@@ -0,0 +1,62 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import builtins
+import typing
+
+@typing.final
+class ShipsConfig:
+    @property
+    def redis_url(self) -> builtins.str: ...
+    @redis_url.setter
+    def redis_url(self, value: builtins.str) -> None: ...
+    @property
+    def ship162_channel(self) -> builtins.str: ...
+    @ship162_channel.setter
+    def ship162_channel(self, value: builtins.str) -> None: ...
+    @property
+    def history_control_channel(self) -> builtins.str: ...
+    @history_control_channel.setter
+    def history_control_channel(self, value: builtins.str) -> None: ...
+    @property
+    def state_vector_expire(self) -> builtins.int: ...
+    @state_vector_expire.setter
+    def state_vector_expire(self, value: builtins.int) -> None: ...
+    @property
+    def stream_interval_secs(self) -> builtins.float: ...
+    @stream_interval_secs.setter
+    def stream_interval_secs(self, value: builtins.float) -> None: ...
+    @property
+    def history_table_name(self) -> builtins.str: ...
+    @history_table_name.setter
+    def history_table_name(self, value: builtins.str) -> None: ...
+    @property
+    def history_buffer_size(self) -> builtins.int: ...
+    @history_buffer_size.setter
+    def history_buffer_size(self, value: builtins.int) -> None: ...
+    @property
+    def history_flush_interval_secs(self) -> builtins.int: ...
+    @history_flush_interval_secs.setter
+    def history_flush_interval_secs(self, value: builtins.int) -> None: ...
+    @property
+    def history_optimize_interval_secs(self) -> builtins.int: ...
+    @history_optimize_interval_secs.setter
+    def history_optimize_interval_secs(self, value: builtins.int) -> None: ...
+    @property
+    def history_optimize_target_file_size(self) -> builtins.int: ...
+    @history_optimize_target_file_size.setter
+    def history_optimize_target_file_size(self, value: builtins.int) -> None: ...
+    @property
+    def history_vacuum_interval_secs(self) -> builtins.int: ...
+    @history_vacuum_interval_secs.setter
+    def history_vacuum_interval_secs(self, value: builtins.int) -> None: ...
+    @property
+    def history_vacuum_retention_period_secs(self) -> typing.Optional[builtins.int]: ...
+    @history_vacuum_retention_period_secs.setter
+    def history_vacuum_retention_period_secs(self, value: typing.Optional[builtins.int]) -> None: ...
+    def __new__(cls, redis_url: builtins.str, ship162_channel: builtins.str, history_control_channel: builtins.str, state_vector_expire: builtins.int, stream_interval_secs: builtins.float, history_table_name: builtins.str, history_buffer_size: builtins.int, history_flush_interval_secs: builtins.int, history_optimize_interval_secs: builtins.int, history_optimize_target_file_size: builtins.int, history_vacuum_interval_secs: builtins.int, history_vacuum_retention_period_secs: typing.Optional[builtins.int]) -> ShipsConfig: ...
+
+def init_tracing_stderr(filter_str: builtins.str) -> None: ...
+
+def run_ships(config: ShipsConfig) -> typing.Any: ...
+

tangram_ship162/index.ts

@@ -0,0 +1,172 @@
+import { watch } from "vue";
+import type { TangramApi, Entity } from "@open-aviation/tangram-core/api";
+import ShipLayer from "./ShipLayer.vue";
+import ShipCountWidget from "./ShipCountWidget.vue";
+import ShipInfoWidget from "./ShipInfoWidget.vue";
+import ShipTrailLayer from "./ShipTrailLayer.vue";
+import { shipStore, type ShipSelectionData } from "./store";
+
+const ENTITY_TYPE = "ship162_ship";
+
+interface Ship162FrontendConfig {
+  topbar_order: number;
+  sidebar_order: number;
+}
+
+export interface MmsiInfo {
+  country: string;
+  flag: string;
+  "iso-3166-1": string;
+}
+
+export interface Ship162Vessel {
+  mmsi: string;
+  timestamp: number;
+  latitude?: number;
+  longitude?: number;
+  ship_name?: string;
+  course?: number;
+  speed?: number;
+  destination?: string;
+  mmsi_info?: MmsiInfo;
+  ship_type?: string;
+  status?: string;
+  callsign?: string;
+  heading?: number;
+  imo?: number;
+  draught?: number;
+  to_bow?: number;
+  to_stern?: number;
+  to_port?: number;
+  to_starboard?: number;
+  turn?: number;
+}
+
+export function install(api: TangramApi, config?: Ship162FrontendConfig) {
+  api.ui.registerWidget("ship162-count-widget", "TopBar", ShipCountWidget, {
+    priority: config?.topbar_order
+  });
+  api.ui.registerWidget("ship162-info-widget", "SideBar", ShipInfoWidget, {
+    priority: config?.sidebar_order,
+    title: "Ship Details",
+    relevantFor: ENTITY_TYPE
+  });
+  api.ui.registerWidget("ship162-ship-layer", "MapOverlay", ShipLayer);
+  api.ui.registerWidget("ship162-trail-layer", "MapOverlay", ShipTrailLayer);
+  api.state.registerEntityType(ENTITY_TYPE);
+
+  (async () => {
+    try {
+      const connectionId = await api.realtime.ensureConnected();
+      await subscribeToShipData(api, connectionId);
+    } catch (e) {
+      console.error("failed initializing ship162 realtime subscription", e);
+    }
+  })();
+
+  watch(
+    () => api.state.activeEntities.value,
+    async newEntities => {
+      const currentIds = new Set<string>();
+      for (const [id, entity] of newEntities) {
+        if (entity.type === ENTITY_TYPE) {
+          currentIds.add(id);
+        }
+      }
+
+      for (const id of shipStore.selected.keys()) {
+        if (!currentIds.has(id)) {
+          shipStore.selected.delete(id);
+        }
+      }
+
+      for (const id of currentIds) {
+        if (!shipStore.selected.has(id)) {
+          const selectionData: ShipSelectionData = {
+            trajectory: [],
+            loading: true,
+            error: null
+          };
+          shipStore.selected.set(id, selectionData);
+          fetchTrajectory(id);
+        }
+      }
+      shipStore.version++;
+    }
+  );
+}
+
+async function fetchTrajectory(mmsi: string) {
+  const data = shipStore.selected.get(mmsi);
+  if (!data) return;
+
+  try {
+    const response = await fetch(`/ship162/data/${mmsi}`);
+    if (!response.ok) throw new Error("Failed to fetch trajectory");
+    const trajData = await response.json();
+
+    if (shipStore.selected.has(mmsi)) {
+      const currentData = shipStore.selected.get(mmsi)!;
+      currentData.trajectory = [...trajData, ...currentData.trajectory];
+      shipStore.version++;
+    }
+  } catch (err: unknown) {
+    if (shipStore.selected.has(mmsi)) {
+      shipStore.selected.get(mmsi)!.error = (err as Error).message;
+    }
+  } finally {
+    if (shipStore.selected.has(mmsi)) {
+      shipStore.selected.get(mmsi)!.loading = false;
+    }
+  }
+}
+
+async function subscribeToShipData(api: TangramApi, connectionId: string) {
+  const topic = `streaming-${connectionId}:new-ship162-data`;
+  try {
+    await api.realtime.subscribe<{ ship: Ship162Vessel[]; count: number }>(
+      topic,
+      payload => {
+        const entities: Entity[] = payload.ship.map(ship => ({
+          id: ship.mmsi.toString(),
+          type: ENTITY_TYPE,
+          state: ship
+        }));
+        api.state.replaceAllEntitiesByType(ENTITY_TYPE, entities);
+        api.state.setTotalCount(ENTITY_TYPE, payload.count);
+
+        let hasUpdates = false;
+        for (const [id, data] of shipStore.selected) {
+          const entityMap =
+            api.state.getEntitiesByType<Ship162Vessel>(ENTITY_TYPE).value;
+          const entity = entityMap.get(id);
+
+          if (
+            entity &&
+            entity.state &&
+            entity.state.latitude &&
+            entity.state.longitude
+          ) {
+            const updated = entity.state;
+            const last = data.trajectory[data.trajectory.length - 1];
+            const timestamp = updated.timestamp;
+
+            if (!last || Math.abs(last.timestamp - timestamp) > 0.5) {
+              data.trajectory.push({
+                ...updated,
+                timestamp: timestamp
+              });
+              hasUpdates = true;
+            }
+          }
+        }
+        if (hasUpdates) {
+          shipStore.version++;
+        }
+      }
+    );
+    await api.realtime.publish("system:join-streaming", { connectionId });
+  } catch (e) {
+    console.error(`failed to subscribe to ${topic}`, e);
+  }
+}

tangram_ship162/store.ts

@@ -0,0 +1,13 @@
+import { reactive } from "vue";
+import type { Ship162Vessel } from ".";
+
+export interface ShipSelectionData {
+  trajectory: Ship162Vessel[];
+  loading: boolean;
+  error: string | null;
+}
+
+export const shipStore = reactive({
+  selected: new Map<string, ShipSelectionData>(),
+  version: 0
+});

tangram_ship162-0.2.1.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: tangram_ship162
+Version: 0.2.1
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Dist: tangram-core>=0.2.0
+Requires-Dist: polars[deltalake] ; extra == 'history'
+Provides-Extra: history
+Summary: AIS maritime data integration plugin for tangram
+Home-Page: https://mode-s.org/tangram/
+Author-email: Abraham Cheung <abraham@ylcheung.com>
+License-Expression: AGPL-3.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# tangram_ship162
+
+The `tangram_ship162` plugin integrates AIS data from a `ship162` instance, enabling real-time visualization and historical analysis of maritime traffic.
+
+It provides:
+
+- A background service to ingest AIS messages.
+- A REST API endpoint to fetch ship trajectories.
+- Frontend widgets for visualizing ships on the map.
+
+## About Tangram
+
+`tangram_ship162` is a plugin for `tangram`, an open framework for modular, real-time air traffic management research.
+
+- Documentation: <https://mode-s.org/tangram/>
+- Repository: <https://github.com/open-aviation/tangram>
+
+Installation:
+
+```sh
+# cli via uv
+uv tool install --with tangram-ship162 tangram-core
+# with pip
+pip install tangram-core tangram-ship162
+```
+

tangram_ship162-0.2.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+tangram_ship162-0.2.1.dist-info/METADATA,sha256=9A0fh7-jA4fSSUffD4Wj1155VyhcqVj3nuGnnFZcoSE,1742
+tangram_ship162-0.2.1.dist-info/WHEEL,sha256=vUkIH7fhISEPmN8u5QEHgBl-TWt1VoFccM0v25sskao,109
+tangram_ship162-0.2.1.dist-info/entry_points.txt,sha256=WyeOkUVEEot9oDqXQUIDv2f0I_XlMXxHApHcqzwFcxc,62
+tangram_ship162.libs/libgcc_s-39080030.so.1,sha256=fIO6GHOh8Ft9CR0Geu7wSUb9Xnl122iTtrxQQ9TAkTQ,789673
+tangram_ship162/ShipCountWidget.vue,sha256=ycGhbPoR445W4kQUh93i-JDh_zdfHaIwDw2BYEAzEIU,1103
+tangram_ship162/ShipInfoWidget.vue,sha256=sdgr6GTXMnBI3S1dZccs2-EZW57tIhZNWyI9ArQ8xiY,6063
+tangram_ship162/ShipLayer.vue,sha256=LUGmXuECON37bojVQebVE__mWh51Svd88WYdqHXVeBU,14085
+tangram_ship162/ShipTrailLayer.vue,sha256=xiw9rbgflyV5-UHqTcaDripCg8en3jOF_9UFlDAUs-c,1386
+tangram_ship162/__init__.py,sha256=aRMjqrGRvzby7g67q2oTnnkiSuJQPkEKznGZ64g4mik,4385
+tangram_ship162/_ships.cpython-314-aarch64-linux-musl.so,sha256=RyKhPHzcLBbxEunPagPUc3AD_dFeR04PeMrBuWyt0U0,7212481
+tangram_ship162/_ships.pyi,sha256=LZ3YDHMJpx_i7XOkW0yp_-C2za39B8WgDgG7gHOKobU,3008
+tangram_ship162/index.ts,sha256=IZF1aq4lhmCyP4ZpbJ5CA4ZXTirr2ye__b6jtLbJc1c,4962
+tangram_ship162/store.ts,sha256=iFFqGo03xa--uUPgZnWSMsfCxWtoT8xTHGmvo8vwV6Q,291
+tangram_ship162-0.2.1.dist-info/RECORD,,

tangram_ship162-0.2.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.10.2)
+Root-Is-Purelib: false
+Tag: cp314-cp314-musllinux_1_1_aarch64

tangram_ship162-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[tangram_core.plugins]
+tangram_ship162=tangram_ship162:plugin