@tak-ps/node-cot 13.6.0 → 14.0.0

package/lib/parser/normalize_geojson.ts

@@ -0,0 +1,104 @@
+import Err from '@openaddresses/batch-error';
+import { v4 as randomUUID } from 'uuid';
+import type { Static } from '@sinclair/typebox';
+import { coordEach } from "@turf/meta";
+import TypeValidator from '../type.js';
+import { Feature } from '../types/feature.js';
+import PointOnFeature from '@turf/point-on-feature';
+import { GeoJSONFeature } from '../types/geojson.js';
+
+/**
+ * Given a generic GeoJSON Feature, convert it to a CoT Featurt
+ *
+ * @param {Object} feature GeoJSON Feature
+ *
+ * @return {CoT}
+ */
+export async function normalize_geojson(
+    feature: Static<typeof GeoJSONFeature>,
+): Promise<Static<typeof Feature>> {
+    try {
+        feature = await TypeValidator.type(GeoJSONFeature, feature);
+    } catch (err) {
+        throw new Err(400, null, `Validation Error: ${err}`);
+    }
+
+    if (!feature.id) {
+        feature.id = randomUUID();
+    }
+
+    const props = feature.properties;
+
+    feature.properties = {
+        metadata: props || {}
+    }
+
+    if (feature.geometry.type === 'Point') {
+        feature.properties.type = 'u-d-p';
+    } else if (feature.geometry.type === 'LineString') {
+        feature.properties.type = 'u-d-f';
+    } else if (feature.geometry.type === 'Polygon') {
+        feature.properties.type = 'u-d-f';
+    } else {
+        throw new Err(400, null, `Unsupported Geometry Type`);
+    }
+
+    for (const color of ['marker-color', 'stroke', 'fill']) {
+        if (
+            props[color]
+            && typeof props[color] === 'string'
+        ) {
+            feature.properties[color] = props[color];
+        }
+    }
+
+    for (const number of ['marker-opacity', 'stroke-opacity', 'stroke-width', 'fill-opacity']) {
+        if (
+            props[number]
+            && typeof props[number] === 'number'
+        ) {
+            feature.properties[number] = props[number];
+        }
+    }
+
+    // Callsign Options
+    for (const callsign of ['callsign', 'title', 'name']) {
+        if (props[callsign] && typeof props[callsign] === 'string') {
+            feature.properties.callsign = props[callsign];
+            break;
+        }
+    }
+
+    if (!feature.properties.callsign) {
+        feature.properties.callsign = 'New Feature';
+    }
+
+    // Remarks Options
+    for (const remarks of ['remarks', 'description']) {
+        if (props[remarks] && typeof props[remarks] === 'string') {
+            feature.properties.remarks = props[remarks];
+            break;
+        }
+    }
+
+    if (!feature.properties.remarks) {
+        feature.properties.remarks = '';
+    }
+
+    feature.properties.time = new Date().toISOString();
+    feature.properties.start = new Date().toISOString();
+
+    const stale = new Date();
+    stale.setHours(stale.getHours() + 1);
+    feature.properties.stale = stale;
+
+    feature.properties.center = PointOnFeature(feature).geometry.coordinates;
+
+    feature.properties.archived = feature.properties.archived || false;
+
+    coordEach(feature.geometry, (coord) => {
+        return coord.slice(0, 3);
+    });
+
+    return feature as Static<typeof Feature>;
+}

package/lib/parser/to_geojson.ts

@@ -0,0 +1,395 @@
+import Err from '@openaddresses/batch-error';
+import type { Static } from '@sinclair/typebox';
+import type {
+    Feature,
+    Polygon,
+    FeaturePropertyMission,
+    FeaturePropertyMissionLayer,
+} from '../types/feature.js';
+import type {
+    MartiDest,
+    MartiDestAttributes,
+    Link,
+    LinkAttributes,
+    ColorAttributes,
+} from '../types/types.js'
+import Ellipse from '@turf/ellipse';
+import Truncate from '@turf/truncate';
+import { destination } from '@turf/destination';
+import Color from '../utils/color.js';
+import JSONCoT from '../types/types.js'
+import CoT from '../cot.js';
+
+// GeoJSON Geospatial ops will truncate to the below
+const COORDINATE_PRECISION = 6;
+
+/**
+ * Return a GeoJSON Feature from an XML CoT message
+ */
+export async function to_geojson(cot: CoT): Promise<Static<typeof Feature>> {
+    const raw: Static<typeof JSONCoT> = JSON.parse(JSON.stringify(cot.raw));
+    if (!raw.event.detail) raw.event.detail = {};
+    if (!raw.event.detail.contact) raw.event.detail.contact = { _attributes: { callsign: 'UNKNOWN' } };
+    if (!raw.event.detail.contact._attributes) raw.event.detail.contact._attributes = { callsign: 'UNKNOWN' };
+
+    const feat: Static<typeof Feature> = {
+        id: raw.event._attributes.uid,
+        type: 'Feature',
+        properties: {
+            callsign: raw.event.detail.contact._attributes.callsign || 'UNKNOWN',
+            center: [ Number(raw.event.point._attributes.lon), Number(raw.event.point._attributes.lat), Number(raw.event.point._attributes.hae) ],
+            type: raw.event._attributes.type,
+            how: raw.event._attributes.how || '',
+            time: raw.event._attributes.time,
+            start: raw.event._attributes.start,
+            stale: raw.event._attributes.stale,
+        },
+        geometry: {
+            type: 'Point',
+            coordinates: [ Number(raw.event.point._attributes.lon), Number(raw.event.point._attributes.lat), Number(raw.event.point._attributes.hae) ]
+        }
+    };
+
+    const contact = JSON.parse(JSON.stringify(raw.event.detail.contact._attributes));
+    delete contact.callsign;
+    if (Object.keys(contact).length) {
+        feat.properties.contact = contact;
+    }
+
+    if (cot.creator()) {
+        feat.properties.creator = cot.creator();
+    }
+
+    if (raw.event.detail.remarks && raw.event.detail.remarks._text) {
+        feat.properties.remarks = raw.event.detail.remarks._text;
+    }
+
+    if (raw.event.detail.fileshare) {
+        feat.properties.fileshare = raw.event.detail.fileshare._attributes;
+        if (feat.properties.fileshare && typeof feat.properties.fileshare.sizeInBytes === 'string') {
+            feat.properties.fileshare.sizeInBytes = parseInt(feat.properties.fileshare.sizeInBytes)
+        }
+    }
+
+    if (raw.event.detail.__milsym) {
+        feat.properties.milsym = {
+            id: raw.event.detail.__milsym._attributes.id
+        }
+    }
+
+    if (raw.event.detail.sensor) {
+        feat.properties.sensor = raw.event.detail.sensor._attributes;
+    }
+
+    if (raw.event.detail.range) {
+        feat.properties.range = raw.event.detail.range._attributes.value;
+    }
+
+    if (raw.event.detail.bearing) {
+        feat.properties.bearing = raw.event.detail.bearing._attributes.value;
+    }
+
+    if (raw.event.detail.labels_on && raw.event.detail.labels_on._attributes && raw.event.detail.labels_on._attributes.value !== undefined) {
+        feat.properties.labels = raw.event.detail.labels_on._attributes.value;
+    }
+
+    if (raw.event.detail.__video && raw.event.detail.__video._attributes) {
+        feat.properties.video = raw.event.detail.__video._attributes;
+
+        if (raw.event.detail.__video.ConnectionEntry) {
+            feat.properties.video.connection = raw.event.detail.__video.ConnectionEntry._attributes;
+        }
+    }
+
+    if (raw.event.detail.__geofence) {
+        feat.properties.geofence = raw.event.detail.__geofence._attributes;
+    }
+
+    if (raw.event.detail.ackrequest) {
+        feat.properties.ackrequest = raw.event.detail.ackrequest._attributes;
+    }
+
+    if (raw.event.detail.attachment_list) {
+        feat.properties.attachments = JSON.parse(raw.event.detail.attachment_list._attributes.hashes);
+    }
+
+    if (raw.event.detail.link) {
+        if (!Array.isArray(raw.event.detail.link)) raw.event.detail.link = [raw.event.detail.link];
+
+        feat.properties.links = raw.event.detail.link.filter((link: Static<typeof Link>) => {
+            return !!link._attributes.url
+        }).map((link: Static<typeof Link>): Static<typeof LinkAttributes> => {
+            return link._attributes;
+        });
+
+        if (!feat.properties.links || !feat.properties.links.length) delete feat.properties.links;
+    }
+
+    if (raw.event.detail.archive) {
+        feat.properties.archived = true;
+    }
+
+    if (raw.event.detail.__chat) {
+        feat.properties.chat = {
+            ...raw.event.detail.__chat._attributes,
+            chatgrp: raw.event.detail.__chat.chatgrp
+        }
+    }
+
+    if (raw.event.detail.track && raw.event.detail.track._attributes) {
+        if (raw.event.detail.track._attributes.course) feat.properties.course = Number(raw.event.detail.track._attributes.course);
+        if (raw.event.detail.track._attributes.slope) feat.properties.slope = Number(raw.event.detail.track._attributes.slope);
+        if (raw.event.detail.track._attributes.course) feat.properties.speed = Number(raw.event.detail.track._attributes.speed);
+    }
+
+    if (raw.event.detail.marti && raw.event.detail.marti.dest) {
+        if (!Array.isArray(raw.event.detail.marti.dest)) raw.event.detail.marti.dest = [raw.event.detail.marti.dest];
+
+        const dest: Array<Static<typeof MartiDestAttributes>> = raw.event.detail.marti.dest.map((d: Static<typeof MartiDest>) => {
+            return { ...d._attributes };
+        });
+
+        feat.properties.dest = dest.length === 1 ? dest[0] : dest
+    }
+
+    if (raw.event.detail.usericon && raw.event.detail.usericon._attributes && raw.event.detail.usericon._attributes.iconsetpath) {
+        feat.properties.icon = raw.event.detail.usericon._attributes.iconsetpath;
+    }
+
+
+    if (raw.event.detail.uid && raw.event.detail.uid._attributes && raw.event.detail.uid._attributes.Droid) {
+        feat.properties.droid = raw.event.detail.uid._attributes.Droid;
+    }
+
+    if (raw.event.detail.takv && raw.event.detail.takv._attributes) {
+        feat.properties.takv = raw.event.detail.takv._attributes;
+    }
+
+    if (raw.event.detail.__group && raw.event.detail.__group._attributes) {
+        feat.properties.group = raw.event.detail.__group._attributes;
+    }
+
+    if (raw.event.detail['_flow-tags_'] && raw.event.detail['_flow-tags_']._attributes) {
+        feat.properties.flow = raw.event.detail['_flow-tags_']._attributes;
+    }
+
+    if (raw.event.detail.status && raw.event.detail.status._attributes) {
+        feat.properties.status = raw.event.detail.status._attributes;
+    }
+
+    if (raw.event.detail.mission && raw.event.detail.mission._attributes) {
+        const mission: Static<typeof FeaturePropertyMission> = {
+            ...raw.event.detail.mission._attributes
+        };
+
+        if (raw.event.detail.mission && raw.event.detail.mission.MissionChanges) {
+            const changes =
+                Array.isArray(raw.event.detail.mission.MissionChanges)
+                    ? raw.event.detail.mission.MissionChanges
+                    : [ raw.event.detail.mission.MissionChanges ]
+
+            mission.missionChanges = []
+            for (const change of changes) {
+                mission.missionChanges.push({
+                    contentUid: change.MissionChange.contentUid._text,
+                    creatorUid: change.MissionChange.creatorUid._text,
+                    isFederatedChange: change.MissionChange.isFederatedChange._text,
+                    missionName: change.MissionChange.missionName._text,
+                    timestamp: change.MissionChange.timestamp._text,
+                    type: change.MissionChange.type._text,
+                    details: {
+                        ...change.MissionChange.details._attributes,
+                        ...change.MissionChange.details.location
+                            ? change.MissionChange.details.location._attributes
+                            : {}
+                    }
+                })
+            }
+        }
+
+
+        if (raw.event.detail.mission && raw.event.detail.mission.missionLayer) {
+            const missionLayer: Static<typeof FeaturePropertyMissionLayer> = {};
+
+            if (raw.event.detail.mission.missionLayer.name && raw.event.detail.mission.missionLayer.name._text) {
+                missionLayer.name = raw.event.detail.mission.missionLayer.name._text;
+            }
+            if (raw.event.detail.mission.missionLayer.parentUid && raw.event.detail.mission.missionLayer.parentUid._text) {
+                missionLayer.parentUid = raw.event.detail.mission.missionLayer.parentUid._text;
+            }
+            if (raw.event.detail.mission.missionLayer.type && raw.event.detail.mission.missionLayer.type._text) {
+                missionLayer.type = raw.event.detail.mission.missionLayer.type._text;
+            }
+            if (raw.event.detail.mission.missionLayer.uid && raw.event.detail.mission.missionLayer.uid._text) {
+                missionLayer.uid = raw.event.detail.mission.missionLayer.uid._text;
+            }
+
+            mission.missionLayer = missionLayer;
+        }
+
+        feat.properties.mission = mission;
+    }
+
+    if (raw.event.detail.precisionlocation && raw.event.detail.precisionlocation._attributes) {
+        feat.properties.precisionlocation = raw.event.detail.precisionlocation._attributes;
+    }
+
+    if (raw.event.detail.strokeColor && raw.event.detail.strokeColor._attributes && raw.event.detail.strokeColor._attributes.value) {
+        const stroke = new Color(Number(raw.event.detail.strokeColor._attributes.value));
+        feat.properties.stroke = stroke.as_hex();
+        feat.properties['stroke-opacity'] = stroke.as_opacity() / 255;
+    }
+
+    if (raw.event.detail.strokeWeight && raw.event.detail.strokeWeight._attributes && raw.event.detail.strokeWeight._attributes.value) {
+        feat.properties['stroke-width'] = Number(raw.event.detail.strokeWeight._attributes.value);
+    }
+
+    if (raw.event.detail.strokeStyle && raw.event.detail.strokeStyle._attributes && raw.event.detail.strokeStyle._attributes.value) {
+        feat.properties['stroke-style'] = raw.event.detail.strokeStyle._attributes.value;
+    }
+
+    if (raw.event.detail.color) {
+        let color: Static<typeof ColorAttributes> | null = null;
+
+        if (Array.isArray(raw.event.detail.color) && raw.event.detail.color.length > 1) {
+            color = raw.event.detail.color[0];
+            if (!color._attributes) color._attributes = {};
+
+            for (let i = raw.event.detail.color.length - 1; i >= 1; i--) {
+                if (raw.event.detail.color[i]._attributes) {
+                    Object.assign(color._attributes, raw.event.detail.color[i]._attributes);
+                }
+            }
+        } else if (Array.isArray(raw.event.detail.color) && raw.event.detail.color.length === 1) {
+            color = raw.event.detail.color[0];
+        } else if (!Array.isArray(raw.event.detail.color)) {
+            color = raw.event.detail.color;
+        }
+
+        if (color && color._attributes && color._attributes.argb) {
+            const parsedColor = new Color(Number(color._attributes.argb));
+            feat.properties['marker-color'] = parsedColor.as_hex();
+            feat.properties['marker-opacity'] = parsedColor.as_opacity() / 255;
+        }
+    }
+
+    // Line, Polygon style types
+    if (['u-d-f', 'u-d-r', 'b-m-r', 'u-rb-a'].includes(raw.event._attributes.type) && Array.isArray(raw.event.detail.link)) {
+        const coordinates = [];
+
+        for (const l of raw.event.detail.link) {
+            if (!l._attributes.point) continue;
+            coordinates.push(l._attributes.point.split(',').map((p: string) => { return Number(p.trim()) }).splice(0, 2).reverse());
+        }
+
+        // Range & Bearing Line
+        if (raw.event._attributes.type === 'u-rb-a') {
+            const detail = cot.detail();
+
+            if (!detail.range) throw new Error('Range value not provided')
+            if (!detail.bearing) throw new Error('Bearing value not provided')
+
+            // TODO Support inclination
+            const dest = destination(
+                cot.position(),
+                detail.range._attributes.value / 1000,
+                detail.bearing._attributes.value
+            ).geometry.coordinates;
+
+            feat.geometry = {
+                type: 'LineString',
+                coordinates: [cot.position(), dest]
+            };
+        } else if (raw.event._attributes.type === 'u-d-r' || (coordinates[0][0] === coordinates[coordinates.length -1][0] && coordinates[0][1] === coordinates[coordinates.length -1][1])) {
+            if (raw.event._attributes.type === 'u-d-r') {
+                // CoT rectangles are only 4 points - GeoJSON needs to be closed
+                coordinates.push(coordinates[0])
+            }
+
+            feat.geometry = {
+                type: 'Polygon',
+                coordinates: [coordinates]
+            }
+
+            if (raw.event.detail.fillColor && raw.event.detail.fillColor._attributes && raw.event.detail.fillColor._attributes.value) {
+                const fill = new Color(Number(raw.event.detail.fillColor._attributes.value));
+                feat.properties['fill-opacity'] = fill.as_opacity() / 255;
+                feat.properties['fill'] = fill.as_hex();
+            }
+        } else {
+            feat.geometry = {
+                type: 'LineString',
+                coordinates
+            }
+        }
+    } else if (raw.event._attributes.type.startsWith('u-d-c-c') || raw.event._attributes.type.startsWith('u-r-b-c-c')) {
+        if (!raw.event.detail.shape) throw new Err(400, null, `${raw.event._attributes.type} (Circle) must define shape value`)
+        if (
+            !raw.event.detail.shape.ellipse
+            || !raw.event.detail.shape.ellipse._attributes
+        ) throw new Err(400, null, `${raw.event._attributes.type} (Circle) must define ellipse shape value`)
+
+        const ellipse = {
+            major: Number(raw.event.detail.shape.ellipse._attributes.major),
+            minor: Number(raw.event.detail.shape.ellipse._attributes.minor),
+            angle: Number(raw.event.detail.shape.ellipse._attributes.angle)
+        }
+
+        feat.geometry = Truncate(Ellipse(
+            feat.geometry.coordinates as number[],
+            Number(ellipse.major) / 1000,
+            Number(ellipse.minor) / 1000,
+            {
+                angle: ellipse.angle
+            }
+        ), {
+            precision: COORDINATE_PRECISION,
+            mutate: true
+        }).geometry as Static<typeof Polygon>;
+
+        feat.properties.shape = {};
+        feat.properties.shape.ellipse = ellipse;
+    } else if (raw.event._attributes.type.startsWith('b-m-p-s-p-i')) {
+        // TODO: Currently the "shape" tag is only parsed here - asking ARA for clarification if it is a general use tag
+        if (raw.event.detail.shape && raw.event.detail.shape.polyline && raw.event.detail.shape.polyline.vertex) {
+            const coordinates = [];
+
+            const vertices = Array.isArray(raw.event.detail.shape.polyline.vertex) ? raw.event.detail.shape.polyline.vertex : [raw.event.detail.shape.polyline.vertex];
+            for (const v of vertices) {
+                coordinates.push([Number(v._attributes.lon), Number(v._attributes.lat)]);
+            }
+
+            if (coordinates.length === 1) {
+                feat.geometry = { type: 'Point', coordinates: coordinates[0] }
+            } else if (raw.event.detail.shape.polyline._attributes && raw.event.detail.shape.polyline._attributes.closed === true) {
+                coordinates.push(coordinates[0]);
+                feat.geometry = { type: 'Polygon', coordinates: [coordinates] }
+            } else {
+                feat.geometry = { type: 'LineString', coordinates }
+            }
+        }
+
+        if (
+            raw.event.detail.shape
+            && raw.event.detail.shape.polyline
+            && raw.event.detail.shape.polyline._attributes
+        ) {
+            if (raw.event.detail.shape.polyline._attributes.fillColor) {
+                const fill = new Color(Number(raw.event.detail.shape.polyline._attributes.fillColor));
+                feat.properties['fill-opacity'] = fill.as_opacity() / 255;
+                feat.properties['fill'] = fill.as_hex();
+            }
+
+            if (raw.event.detail.shape.polyline._attributes.color) {
+                const stroke = new Color(Number(raw.event.detail.shape.polyline._attributes.color));
+                feat.properties.stroke = stroke.as_hex();
+                feat.properties['stroke-opacity'] = stroke.as_opacity() / 255;
+            }
+        }
+    }
+
+    feat.properties.metadata = cot.metadata;
+    feat.path = cot.path;
+
+    return feat;
+}