iobroker.proscenic 0.1.0

package/build/domain/live-map.js

@@ -0,0 +1,829 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var live_map_exports = {};
+__export(live_map_exports, {
+  countLiveMapAreas20002: () => countLiveMapAreas20002,
+  extractLiveMapCoordinateMetadata20002: () => extractLiveMapCoordinateMetadata20002,
+  extractRobotPose20001: () => extractRobotPose20001,
+  mergeLiveMapCoordinateMetadata20002: () => mergeLiveMapCoordinateMetadata20002,
+  mergeLiveMapCoordinateMetadataCache: () => mergeLiveMapCoordinateMetadataCache,
+  renderLiveMapImage20002: () => renderLiveMapImage20002
+});
+module.exports = __toCommonJS(live_map_exports);
+var import_node_zlib = require("node:zlib");
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+const CRC_TABLE = createCrcTable();
+const MAX_LIVE_MAP_PIXELS = 512 * 512;
+const MAX_LIVE_MAP_DATA_URL_BYTES = 256 * 1024;
+const COLOR_UNKNOWN = [184, 204, 216];
+const COLOR_ROOM = [255, 255, 255];
+const COLOR_WALL = [56, 130, 188];
+const COLOR_OBSTACLE = [82, 82, 82];
+const COLOR_FORBIDDEN_AREA = [209, 106, 133];
+const COLOR_FORBIDDEN_OUTLINE = [175, 68, 103];
+const FORBIDDEN_AREA_ALPHA = 0.45;
+const COLOR_ROOM_AREA = [112, 125, 236];
+const COLOR_ROOM_AREA_OUTLINE = [68, 84, 210];
+const ROOM_AREA_ALPHA = 0.3;
+const COLOR_DOCK = [92, 92, 92];
+const COLOR_ROBOT = [39, 139, 61];
+const COLOR_PATH = [126, 216, 96];
+const COLOR_HEADING = [20, 20, 20];
+const MIN_PATH_SEGMENT_DISTANCE_SQUARED = 1.5 ** 2;
+const MAX_PATH_SEGMENT_DISTANCE_SQUARED = 90 ** 2;
+const ROUTED_PATH_PADDING_PIXELS = 24;
+const MAX_ROUTED_PATH_CELLS = 2e4;
+const PATH_LINE_RADIUS = 1;
+function extractRobotPose20001(data) {
+  const record = getRecord(data);
+  const pos = parsePoint(record == null ? void 0 : record.pos);
+  if (!pos) {
+    return void 0;
+  }
+  return {
+    pos,
+    phi: typeof (record == null ? void 0 : record.phi) === "number" ? record.phi : void 0
+  };
+}
+function renderLiveMapImage20002(data, poses = []) {
+  const sample = parseMapSample(data);
+  if (!sample) {
+    return void 0;
+  }
+  const compressed = decodeMapPayload(sample.encoded);
+  const occupancy = decompressLz4Block(compressed, sample.width * sample.height);
+  if (occupancy.length !== sample.width * sample.height) {
+    return void 0;
+  }
+  const pixels = renderOccupancy(sample.width, sample.height, occupancy);
+  const coordinateMetadata = drawCoordinateMetadata(sample, pixels);
+  const runtime = drawRobotRuntime(sample, occupancy, pixels, poses);
+  const png = encodeRgbPng(sample.width, sample.height, pixels);
+  const dataUrl = `data:image/png;base64,${png.toString("base64")}`;
+  if (Buffer.byteLength(dataUrl, "utf8") > MAX_LIVE_MAP_DATA_URL_BYTES) {
+    return void 0;
+  }
+  return {
+    dataUrl,
+    width: sample.width,
+    height: sample.height,
+    areas: summarizeRenderedAreas(sample),
+    poseCount: runtime.projectedPoseCount,
+    rawPoseCount: poses.length,
+    pathLineSegments: runtime.pathLineSegments,
+    skippedPathSegments: runtime.skippedPathSegments,
+    renderedForbiddenAreaCount: coordinateMetadata.renderedForbiddenAreaCount,
+    renderedRoomAreaCount: coordinateMetadata.renderedRoomAreaCount,
+    orientation: "flip-y",
+    decompressedBytes: occupancy.length
+  };
+}
+function extractLiveMapCoordinateMetadata20002(data) {
+  const record = getRecord(data);
+  if (!record) {
+    return void 0;
+  }
+  const metadata = {};
+  if (typeof record.mapId === "number") {
+    metadata.mapId = record.mapId;
+  }
+  const areas = normalizeMapAreaMetadata(record.area);
+  if (areas.length > 0) {
+    metadata.area = areas;
+  }
+  const chargeHandlePos = parsePoint(record.chargeHandlePos);
+  if (chargeHandlePos) {
+    metadata.chargeHandlePos = chargeHandlePos;
+  }
+  return metadata.mapId !== void 0 || metadata.area !== void 0 || metadata.chargeHandlePos !== void 0 ? metadata : void 0;
+}
+function mergeLiveMapCoordinateMetadata20002(data, metadata) {
+  const record = getRecord(data);
+  if (!record || !metadata) {
+    return data;
+  }
+  if (metadata.mapId !== void 0 && typeof record.mapId === "number" && metadata.mapId !== record.mapId) {
+    return data;
+  }
+  const merged = { ...record };
+  if (metadata.area && metadata.area.length > 0) {
+    merged.area = metadata.area.map((area) => ({
+      ...area.source,
+      __proscenicKind: area.kind
+    }));
+  }
+  if (metadata.chargeHandlePos && !parsePoint(record.chargeHandlePos)) {
+    merged.chargeHandlePos = metadata.chargeHandlePos;
+  }
+  return merged;
+}
+function countLiveMapAreas20002(data) {
+  const record = getRecord(data);
+  return Array.isArray(record == null ? void 0 : record.area) ? record.area.length : 0;
+}
+function mergeLiveMapCoordinateMetadataCache(previous, next) {
+  var _a, _b, _c, _d;
+  const sameMap = (previous == null ? void 0 : previous.mapId) === void 0 || next.mapId === void 0 || previous.mapId === next.mapId;
+  const previousAreas = sameMap ? (_a = previous == null ? void 0 : previous.area) != null ? _a : [] : [];
+  return {
+    mapId: (_b = next.mapId) != null ? _b : previous == null ? void 0 : previous.mapId,
+    area: mergeAreaMetadata(previousAreas, (_c = next.area) != null ? _c : []),
+    chargeHandlePos: (_d = next.chargeHandlePos) != null ? _d : sameMap ? previous == null ? void 0 : previous.chargeHandlePos : void 0
+  };
+}
+function parseMapSample(data) {
+  const record = getRecord(data);
+  if (!record) {
+    return void 0;
+  }
+  const encoded = record.map;
+  const width = record.width;
+  const height = record.height;
+  if (typeof encoded !== "string" || typeof width !== "number" || typeof height !== "number") {
+    return void 0;
+  }
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0) {
+    return void 0;
+  }
+  if (width * height > MAX_LIVE_MAP_PIXELS) {
+    return void 0;
+  }
+  return {
+    encoded,
+    width,
+    height,
+    resolution: typeof record.resolution === "number" ? record.resolution : void 0,
+    xMin: typeof record.x_min === "number" ? record.x_min : void 0,
+    yMin: typeof record.y_min === "number" ? record.y_min : void 0,
+    areas: parseMapAreas(record.area),
+    chargeHandlePos: parsePoint(record.chargeHandlePos)
+  };
+}
+function renderOccupancy(width, height, occupancy) {
+  const pixels = Buffer.alloc(width * height * 3);
+  for (let index = 0; index < occupancy.length; index++) {
+    const sourceX = index % width;
+    const sourceY = Math.floor(index / width);
+    const targetY = height - 1 - sourceY;
+    const value = occupancy[index];
+    if (value === 0) {
+      setPixel(pixels, width, height, sourceX, targetY, COLOR_WALL);
+    } else if (value === 127) {
+      setPixel(pixels, width, height, sourceX, targetY, COLOR_ROOM);
+    } else if (value === 255) {
+      setPixel(pixels, width, height, sourceX, targetY, COLOR_UNKNOWN);
+    } else {
+      setPixel(pixels, width, height, sourceX, targetY, value < 127 ? COLOR_OBSTACLE : COLOR_ROOM);
+    }
+  }
+  return pixels;
+}
+function drawCoordinateMetadata(sample, pixels) {
+  let renderedForbiddenAreaCount = 0;
+  let renderedRoomAreaCount = 0;
+  for (const area of sample.areas) {
+    const projected = area.vertices.map((vertex) => projectRobotCoordinate(sample, vertex)).filter((vertex) => vertex !== void 0);
+    if (projected.length >= 3) {
+      if (area.kind === "room") {
+        fillPolygon(pixels, sample.width, sample.height, projected, COLOR_ROOM_AREA, ROOM_AREA_ALPHA);
+        drawPolygon(pixels, sample.width, sample.height, projected, COLOR_ROOM_AREA_OUTLINE);
+        renderedRoomAreaCount += 1;
+      } else {
+        fillPolygon(pixels, sample.width, sample.height, projected, COLOR_FORBIDDEN_AREA, FORBIDDEN_AREA_ALPHA);
+        drawPolygon(pixels, sample.width, sample.height, projected, COLOR_FORBIDDEN_OUTLINE);
+        renderedForbiddenAreaCount += 1;
+      }
+    }
+  }
+  if (sample.chargeHandlePos) {
+    const charge = projectRobotCoordinate(sample, sample.chargeHandlePos);
+    if (charge) {
+      plotMarker(pixels, sample.width, sample.height, charge[0], charge[1], 5, COLOR_DOCK);
+    }
+  }
+  return { renderedForbiddenAreaCount, renderedRoomAreaCount };
+}
+function drawRobotRuntime(sample, occupancy, pixels, poses) {
+  const projected = poses.map((pose) => ({
+    point: projectRobotCoordinate(sample, pose.pos),
+    phi: pose.phi
+  })).filter((pose) => pose.point !== void 0);
+  let pathLineSegments = 0;
+  let skippedPathSegments = 0;
+  for (let index = 1; index < projected.length; index++) {
+    const previous = projected[index - 1].point;
+    const current = projected[index].point;
+    const segmentDistanceSquared = distanceSquared(previous, current);
+    if (segmentDistanceSquared >= MIN_PATH_SEGMENT_DISTANCE_SQUARED && segmentDistanceSquared <= MAX_PATH_SEGMENT_DISTANCE_SQUARED) {
+      const routedPath = findDrawablePath(sample, occupancy, previous, current);
+      if (routedPath) {
+        drawAdaptivePathPolyline(sample, occupancy, pixels, sample.width, sample.height, routedPath);
+        pathLineSegments += 1;
+      } else {
+        skippedPathSegments += 1;
+      }
+    } else {
+      skippedPathSegments += 1;
+    }
+  }
+  const latest = projected.at(-1);
+  if (!latest) {
+    return {
+      projectedPoseCount: 0,
+      pathLineSegments,
+      skippedPathSegments
+    };
+  }
+  plotMarker(pixels, sample.width, sample.height, latest.point[0], latest.point[1], 5, COLOR_ROBOT);
+  if (latest.phi !== void 0) {
+    const angle = latest.phi / 1e3;
+    const headingLength = 10;
+    const endX = Math.round(latest.point[0] + Math.cos(angle) * headingLength);
+    const endY = Math.round(latest.point[1] - Math.sin(angle) * headingLength);
+    drawLine(pixels, sample.width, sample.height, latest.point[0], latest.point[1], endX, endY, COLOR_HEADING);
+  }
+  return {
+    projectedPoseCount: projected.length,
+    pathLineSegments,
+    skippedPathSegments
+  };
+}
+function drawAdaptivePathLine(pixels, width, height, x1, y1, x2, y2, canDraw) {
+  drawLineWithPixelColor(
+    pixels,
+    width,
+    height,
+    x1,
+    y1,
+    x2,
+    y2,
+    (x, y) => canDraw && !canDraw(x, y) ? void 0 : COLOR_PATH
+  );
+  drawLineNeighbors(pixels, width, height, x1, y1, x2, y2, canDraw);
+}
+function drawAdaptivePathPolyline(sample, occupancy, pixels, width, height, points) {
+  const canDraw = (x, y) => isTraversableMapPixel(sample, occupancy, x, y);
+  for (let index = 1; index < points.length; index++) {
+    const [x1, y1] = points[index - 1];
+    const [x2, y2] = points[index];
+    drawAdaptivePathLine(pixels, width, height, x1, y1, x2, y2, canDraw);
+  }
+}
+function findDrawablePath(sample, occupancy, start, end) {
+  if (isDirectPathTraversable(sample, occupancy, start, end)) {
+    return [start, end];
+  }
+  return findRoutedPath(sample, occupancy, start, end);
+}
+function isDirectPathTraversable(sample, occupancy, start, end) {
+  let traversedCells = 0;
+  let blockedCells = 0;
+  forEachLinePoint(start[0], start[1], end[0], end[1], (x, y) => {
+    traversedCells += 1;
+    if (!isTraversableMapPixel(sample, occupancy, x, y)) {
+      blockedCells += 1;
+    }
+  });
+  return traversedCells > 0 && blockedCells === 0;
+}
+function findRoutedPath(sample, occupancy, start, end) {
+  var _a, _b;
+  const routeStart = nearestTraversablePoint(sample, occupancy, start);
+  const routeEnd = nearestTraversablePoint(sample, occupancy, end);
+  if (!routeStart || !routeEnd) {
+    return void 0;
+  }
+  const minX = Math.max(0, Math.min(routeStart[0], routeEnd[0]) - ROUTED_PATH_PADDING_PIXELS);
+  const maxX = Math.min(sample.width - 1, Math.max(routeStart[0], routeEnd[0]) + ROUTED_PATH_PADDING_PIXELS);
+  const minY = Math.max(0, Math.min(routeStart[1], routeEnd[1]) - ROUTED_PATH_PADDING_PIXELS);
+  const maxY = Math.min(sample.height - 1, Math.max(routeStart[1], routeEnd[1]) + ROUTED_PATH_PADDING_PIXELS);
+  const searchWidth = maxX - minX + 1;
+  const searchHeight = maxY - minY + 1;
+  if (searchWidth * searchHeight > MAX_ROUTED_PATH_CELLS) {
+    return void 0;
+  }
+  const distance = /* @__PURE__ */ new Map();
+  const previous = /* @__PURE__ */ new Map();
+  const queue = [];
+  const startKey = localPointKey(routeStart[0], routeStart[1], minX, minY, searchWidth);
+  const endKey = localPointKey(routeEnd[0], routeEnd[1], minX, minY, searchWidth);
+  distance.set(startKey, 0);
+  queue.push({ key: startKey, score: heuristic(routeStart, routeEnd) });
+  while (queue.length > 0) {
+    queue.sort((left, right) => left.score - right.score);
+    const current = queue.shift();
+    if (!current) {
+      break;
+    }
+    if (current.key === endKey) {
+      return restoreRoutedPath(previous, current.key, minX, minY, searchWidth);
+    }
+    const [currentX, currentY] = pointFromLocalKey(current.key, minX, minY, searchWidth);
+    const currentDistance = (_a = distance.get(current.key)) != null ? _a : Number.POSITIVE_INFINITY;
+    for (let dy = -1; dy <= 1; dy++) {
+      for (let dx = -1; dx <= 1; dx++) {
+        if (dx === 0 && dy === 0) {
+          continue;
+        }
+        const nextX = currentX + dx;
+        const nextY = currentY + dy;
+        if (nextX < minX || nextX > maxX || nextY < minY || nextY > maxY || !isTraversableMapPixel(sample, occupancy, nextX, nextY)) {
+          continue;
+        }
+        const nextKey = localPointKey(nextX, nextY, minX, minY, searchWidth);
+        const nextDistance = currentDistance + (dx !== 0 && dy !== 0 ? Math.SQRT2 : 1);
+        if (nextDistance >= ((_b = distance.get(nextKey)) != null ? _b : Number.POSITIVE_INFINITY)) {
+          continue;
+        }
+        distance.set(nextKey, nextDistance);
+        previous.set(nextKey, current.key);
+        queue.push({ key: nextKey, score: nextDistance + heuristic([nextX, nextY], routeEnd) });
+      }
+    }
+  }
+  return void 0;
+}
+function restoreRoutedPath(previous, endKey, minX, minY, width) {
+  var _a;
+  const keys = [endKey];
+  let current = endKey;
+  while (previous.has(current)) {
+    current = (_a = previous.get(current)) != null ? _a : current;
+    keys.push(current);
+  }
+  return simplifyPath(keys.reverse().map((key) => pointFromLocalKey(key, minX, minY, width)));
+}
+function simplifyPath(points) {
+  var _a;
+  if (points.length <= 2) {
+    return points;
+  }
+  const simplified = [points[0]];
+  let previousDirection;
+  for (let index = 1; index < points.length; index++) {
+    const direction = [
+      Math.sign(points[index][0] - points[index - 1][0]),
+      Math.sign(points[index][1] - points[index - 1][1])
+    ];
+    if (previousDirection && (direction[0] !== previousDirection[0] || direction[1] !== previousDirection[1])) {
+      simplified.push(points[index - 1]);
+    }
+    previousDirection = direction;
+  }
+  simplified.push((_a = points.at(-1)) != null ? _a : points[0]);
+  return simplified;
+}
+function nearestTraversablePoint(sample, occupancy, point) {
+  if (isTraversableMapPixel(sample, occupancy, point[0], point[1])) {
+    return point;
+  }
+  for (let radius = 1; radius <= 3; radius++) {
+    for (let y = point[1] - radius; y <= point[1] + radius; y++) {
+      for (let x = point[0] - radius; x <= point[0] + radius; x++) {
+        if (isTraversableMapPixel(sample, occupancy, x, y)) {
+          return [x, y];
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function isTraversableMapPixel(sample, occupancy, x, y) {
+  if (x < 0 || x >= sample.width || y < 0 || y >= sample.height) {
+    return false;
+  }
+  const sourceY = sample.height - 1 - y;
+  const value = occupancy[sourceY * sample.width + x];
+  return value >= 127;
+}
+function localPointKey(x, y, minX, minY, width) {
+  return (y - minY) * width + (x - minX);
+}
+function pointFromLocalKey(key, minX, minY, width) {
+  return [minX + key % width, minY + Math.floor(key / width)];
+}
+function heuristic(left, right) {
+  return Math.hypot(left[0] - right[0], left[1] - right[1]);
+}
+function drawLineNeighbors(pixels, width, height, x1, y1, x2, y2, canDraw) {
+  for (let dy = -PATH_LINE_RADIUS; dy <= PATH_LINE_RADIUS; dy++) {
+    for (let dx = -PATH_LINE_RADIUS; dx <= PATH_LINE_RADIUS; dx++) {
+      if (dx === 0 && dy === 0 || dx * dx + dy * dy > PATH_LINE_RADIUS * PATH_LINE_RADIUS) {
+        continue;
+      }
+      drawLineWithPixelColor(
+        pixels,
+        width,
+        height,
+        x1 + dx,
+        y1 + dy,
+        x2 + dx,
+        y2 + dy,
+        (x, y) => canDraw && !canDraw(x, y) ? void 0 : COLOR_PATH
+      );
+    }
+  }
+}
+function projectRobotCoordinate(sample, point) {
+  if (sample.resolution === void 0 || sample.xMin === void 0 || sample.yMin === void 0) {
+    return void 0;
+  }
+  const xMeters = point[0] / 1e3;
+  const yMeters = point[1] / 1e3;
+  const x = Math.round((xMeters - sample.xMin) / sample.resolution);
+  const y = sample.height - 1 - Math.round((yMeters - sample.yMin) / sample.resolution);
+  if (x < 0 || x >= sample.width || y < 0 || y >= sample.height) {
+    return void 0;
+  }
+  return [x, y];
+}
+function parseMapAreas(value) {
+  return normalizeMapAreaMetadata(value).map((area) => ({
+    key: area.key,
+    vertices: parseVertices(area.source.vertexs),
+    kind: area.kind,
+    source: area.source
+  }));
+}
+function summarizeRenderedAreas(sample) {
+  return sample.areas.map((area) => {
+    const projected = area.vertices.map((point) => projectRobotCoordinate(sample, point)).filter((point) => point !== void 0);
+    const id = typeof area.source.id === "number" || typeof area.source.id === "string" ? area.source.id : void 0;
+    const label = firstUsefulLabel(area.source.tag, area.source.name);
+    return {
+      key: area.key,
+      kind: area.kind,
+      ...id !== void 0 ? { id } : {},
+      ...label !== void 0 ? { label } : {},
+      ...projected.length > 0 ? { bounds: boundsFor(projected) } : {}
+    };
+  });
+}
+function firstUsefulLabel(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function boundsFor(points) {
+  const xs = points.map(([x]) => x);
+  const ys = points.map(([, y]) => y);
+  return {
+    minX: Math.min(...xs),
+    minY: Math.min(...ys),
+    maxX: Math.max(...xs),
+    maxY: Math.max(...ys)
+  };
+}
+function normalizeMapAreaMetadata(value) {
+  var _a, _b, _c;
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const candidates = value.map((entry) => {
+    const record = getRecord(entry);
+    if (!record) {
+      return void 0;
+    }
+    const vertices = parseVertices(record.vertexs);
+    if (vertices.length < 3) {
+      return void 0;
+    }
+    const key = mapAreaKey(record, vertices);
+    const explicitKind = parseAreaKind(record.__proscenicKind);
+    return {
+      key,
+      explicitKind,
+      source: record
+    };
+  }).filter(
+    (entry) => entry !== void 0
+  );
+  const counts = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    counts.set(candidate.key, ((_a = counts.get(candidate.key)) != null ? _a : 0) + 1);
+  }
+  const normalized = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const kind = (_c = candidate.explicitKind) != null ? _c : counts.get(candidate.key) !== void 0 && ((_b = counts.get(candidate.key)) != null ? _b : 0) > 1 ? "forbidden" : candidates.length === 1 ? "forbidden" : "room";
+    const existing = normalized.get(candidate.key);
+    const next = {
+      key: candidate.key,
+      kind,
+      source: withoutInternalAreaMetadata(candidate.source)
+    };
+    normalized.set(candidate.key, existing ? mergeAreaMetadataEntry(existing, next) : next);
+  }
+  return [...normalized.values()];
+}
+function mergeAreaMetadata(previous, next) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const area of [...previous, ...next]) {
+    const existing = merged.get(area.key);
+    merged.set(area.key, existing ? mergeAreaMetadataEntry(existing, area) : area);
+  }
+  return [...merged.values()];
+}
+function mergeAreaMetadataEntry(left, right) {
+  return {
+    key: right.key,
+    kind: strongestAreaKind(left.kind, right.kind),
+    source: right.source
+  };
+}
+function strongestAreaKind(left, right) {
+  if (left === "forbidden" || right === "forbidden") {
+    return "forbidden";
+  }
+  if (left === "room" || right === "room") {
+    return "room";
+  }
+  return "unknown";
+}
+function parseAreaKind(value) {
+  return value === "forbidden" || value === "room" || value === "unknown" ? value : void 0;
+}
+function withoutInternalAreaMetadata(record) {
+  const clone = { ...record };
+  delete clone.__proscenicKind;
+  return clone;
+}
+function parseVertices(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((vertex) => parsePoint(vertex)).filter((vertex) => vertex !== void 0);
+}
+function mapAreaKey(record, vertices) {
+  const id = record.id;
+  if (typeof id === "number" || typeof id === "string") {
+    return `id:${String(id)}`;
+  }
+  const xs = vertices.map(([x]) => x);
+  const ys = vertices.map(([, y]) => y);
+  return `shape:${vertices.length}:${Math.min(...xs)}:${Math.min(...ys)}:${Math.max(...xs)}:${Math.max(...ys)}`;
+}
+function parsePoint(value) {
+  if (Array.isArray(value) && value.length >= 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+    return [value[0], value[1]];
+  }
+  return void 0;
+}
+function getRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function decodeMapPayload(encodedMap) {
+  return Buffer.from(encodedMap.replace(/\s/gu, "+"), "base64");
+}
+function decompressLz4Block(input, maxOutputBytes) {
+  const output = Buffer.alloc(maxOutputBytes);
+  let inputOffset = 0;
+  let outputOffset = 0;
+  while (inputOffset < input.length) {
+    const token = input[inputOffset++];
+    let literalLength = token >> 4;
+    if (literalLength === 15) {
+      let next;
+      do {
+        if (inputOffset >= input.length) {
+          throw new Error("literal length overflow");
+        }
+        next = input[inputOffset++];
+        literalLength += next;
+      } while (next === 255);
+    }
+    if (inputOffset + literalLength > input.length || outputOffset + literalLength > output.length) {
+      throw new Error("literal overrun");
+    }
+    input.copy(output, outputOffset, inputOffset, inputOffset + literalLength);
+    inputOffset += literalLength;
+    outputOffset += literalLength;
+    if (inputOffset >= input.length) {
+      break;
+    }
+    if (inputOffset + 2 > input.length) {
+      throw new Error("offset overrun");
+    }
+    const matchOffset = input[inputOffset] | input[inputOffset + 1] << 8;
+    inputOffset += 2;
+    if (matchOffset === 0 || matchOffset > outputOffset) {
+      throw new Error("bad match offset");
+    }
+    let matchLength = token & 15;
+    if (matchLength === 15) {
+      let next;
+      do {
+        if (inputOffset >= input.length) {
+          throw new Error("match length overflow");
+        }
+        next = input[inputOffset++];
+        matchLength += next;
+      } while (next === 255);
+    }
+    matchLength += 4;
+    if (outputOffset + matchLength > output.length) {
+      throw new Error("match overrun");
+    }
+    for (let index = 0; index < matchLength; index++) {
+      output[outputOffset + index] = output[outputOffset - matchOffset + index];
+    }
+    outputOffset += matchLength;
+  }
+  return output.subarray(0, outputOffset);
+}
+function fillPolygon(pixels, width, height, polygon, color, alpha = 1) {
+  const minY = Math.max(0, Math.min(...polygon.map(([, y]) => y)));
+  const maxY = Math.min(height - 1, Math.max(...polygon.map(([, y]) => y)));
+  for (let y = minY; y <= maxY; y++) {
+    const intersections = [];
+    for (let index = 0; index < polygon.length; index++) {
+      const [x1, y1] = polygon[index];
+      const [x2, y2] = polygon[(index + 1) % polygon.length];
+      if (y1 <= y && y2 > y || y2 <= y && y1 > y) {
+        const x = x1 + (y - y1) * (x2 - x1) / (y2 - y1);
+        intersections.push(Math.round(x));
+      }
+    }
+    intersections.sort((left, right) => left - right);
+    for (let index = 0; index + 1 < intersections.length; index += 2) {
+      const start = Math.max(0, intersections[index]);
+      const end = Math.min(width - 1, intersections[index + 1]);
+      for (let x = start; x <= end; x++) {
+        blendPixel(pixels, width, height, x, y, color, alpha);
+      }
+    }
+  }
+}
+function drawPolygon(pixels, width, height, polygon, color) {
+  for (let index = 0; index < polygon.length; index++) {
+    const [x1, y1] = polygon[index];
+    const [x2, y2] = polygon[(index + 1) % polygon.length];
+    drawLine(pixels, width, height, x1, y1, x2, y2, color);
+  }
+}
+function drawLine(pixels, width, height, x1, y1, x2, y2, color) {
+  drawLineWithPixelColor(pixels, width, height, x1, y1, x2, y2, () => color);
+}
+function forEachLinePoint(x1, y1, x2, y2, callback) {
+  const dx = Math.abs(x2 - x1);
+  const sx = x1 < x2 ? 1 : -1;
+  const dy = -Math.abs(y2 - y1);
+  const sy = y1 < y2 ? 1 : -1;
+  let error = dx + dy;
+  let x = x1;
+  let y = y1;
+  while (true) {
+    callback(x, y);
+    if (x === x2 && y === y2) {
+      break;
+    }
+    const error2 = 2 * error;
+    if (error2 >= dy) {
+      error += dy;
+      x += sx;
+    }
+    if (error2 <= dx) {
+      error += dx;
+      y += sy;
+    }
+  }
+}
+function drawLineWithPixelColor(pixels, width, height, x1, y1, x2, y2, pickColor) {
+  const dx = Math.abs(x2 - x1);
+  const sx = x1 < x2 ? 1 : -1;
+  const dy = -Math.abs(y2 - y1);
+  const sy = y1 < y2 ? 1 : -1;
+  let error = dx + dy;
+  let x = x1;
+  let y = y1;
+  while (true) {
+    if (x >= 0 && x < width && y >= 0 && y < height) {
+      const color = pickColor(x, y);
+      if (color) {
+        setPixel(pixels, width, height, x, y, color);
+      }
+    }
+    if (x === x2 && y === y2) {
+      break;
+    }
+    const error2 = 2 * error;
+    if (error2 >= dy) {
+      error += dy;
+      x += sx;
+    }
+    if (error2 <= dx) {
+      error += dx;
+      y += sy;
+    }
+  }
+}
+function plotMarker(pixels, width, height, x, y, radius, color) {
+  for (let dy = -radius; dy <= radius; dy++) {
+    for (let dx = -radius; dx <= radius; dx++) {
+      const px = x + dx;
+      const py = y + dy;
+      if (px >= 0 && px < width && py >= 0 && py < height && dx * dx + dy * dy <= radius * radius) {
+        setPixel(pixels, width, height, px, py, color);
+      }
+    }
+  }
+}
+function setPixel(pixels, width, height, x, y, color) {
+  if (x < 0 || x >= width || y < 0 || y >= height) {
+    return;
+  }
+  const offset = (y * width + x) * 3;
+  pixels[offset] = color[0];
+  pixels[offset + 1] = color[1];
+  pixels[offset + 2] = color[2];
+}
+function blendPixel(pixels, width, height, x, y, color, alpha) {
+  if (alpha >= 1) {
+    setPixel(pixels, width, height, x, y, color);
+    return;
+  }
+  if (x < 0 || x >= width || y < 0 || y >= height) {
+    return;
+  }
+  const offset = (y * width + x) * 3;
+  pixels[offset] = Math.round(pixels[offset] * (1 - alpha) + color[0] * alpha);
+  pixels[offset + 1] = Math.round(pixels[offset + 1] * (1 - alpha) + color[1] * alpha);
+  pixels[offset + 2] = Math.round(pixels[offset + 2] * (1 - alpha) + color[2] * alpha);
+}
+function distanceSquared(left, right) {
+  return (left[0] - right[0]) ** 2 + (left[1] - right[1]) ** 2;
+}
+function encodeRgbPng(width, height, pixels) {
+  if (pixels.length !== width * height * 3) {
+    throw new Error(`Expected ${width * height * 3} RGB pixels but received ${pixels.length}`);
+  }
+  const header = Buffer.alloc(13);
+  header.writeUInt32BE(width, 0);
+  header.writeUInt32BE(height, 4);
+  header[8] = 8;
+  header[9] = 2;
+  const rowBytes = width * 3;
+  const scanlines = Buffer.alloc((rowBytes + 1) * height);
+  for (let y = 0; y < height; y++) {
+    scanlines[y * (rowBytes + 1)] = 0;
+    pixels.copy(scanlines, y * (rowBytes + 1) + 1, y * rowBytes, (y + 1) * rowBytes);
+  }
+  return Buffer.concat([
+    PNG_SIGNATURE,
+    pngChunk("IHDR", header),
+    pngChunk("IDAT", (0, import_node_zlib.deflateSync)(scanlines)),
+    pngChunk("IEND", Buffer.alloc(0))
+  ]);
+}
+function pngChunk(type, data) {
+  const typeBuffer = Buffer.from(type, "ascii");
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length, 0);
+  const checksum = Buffer.alloc(4);
+  checksum.writeUInt32BE(crc32(Buffer.concat([typeBuffer, data])), 0);
+  return Buffer.concat([length, typeBuffer, data, checksum]);
+}
+function crc32(data) {
+  let crc = 4294967295;
+  for (const byte of data) {
+    crc = CRC_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function createCrcTable() {
+  return Array.from({ length: 256 }, (_, index) => {
+    let value = index;
+    for (let bit = 0; bit < 8; bit++) {
+      value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+    }
+    return value >>> 0;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  countLiveMapAreas20002,
+  extractLiveMapCoordinateMetadata20002,
+  extractRobotPose20001,
+  mergeLiveMapCoordinateMetadata20002,
+  mergeLiveMapCoordinateMetadataCache,
+  renderLiveMapImage20002
+});
+//# sourceMappingURL=live-map.js.map