@parkflow/shared-types 1.0.1

package/src/decorators/is-base64-or-na/is-base64-or-na.validation.decorator.spec.ts

@@ -0,0 +1,60 @@
+import { Validate, validateSync } from 'class-validator';
+import { IsBase64OrNA } from './is-base64-or-na-validation.decorator';
+
+describe('IsBase64OrNA', () => {
+    const validator = new IsBase64OrNA();
+
+    describe('validate', () => {
+        describe(`not base 64 or 'n.a.'`, () => {
+            it('should return false', () => {
+                const text = 'not?base!&64';
+                expect(validator.validate(text, undefined)).toBe(false);
+            });
+        });
+
+        describe(`'n.a.'`, () => {
+            it('should return true', () => {
+                const text = 'n.a.';
+                expect(validator.validate(text, undefined)).toBe(true);
+            });
+        });
+
+        describe('base64', () => {
+            it('should return true', () => {
+                const text = 'SGVsbG8sIFdvcmxkLg=='; // "Hello, World."
+                expect(validator.validate(text, undefined)).toBe(true);
+            });
+        });
+    });
+
+    describe('in use', () => {
+        class A {
+            @Validate(IsBase64OrNA)
+            text: string;
+        }
+
+        describe('invalid', () => {
+            it('should return an error', () => {
+                const a = new A();
+                a.text = 'not!base!64!&';
+                expect(validateSync(a)).toHaveLength(1);
+            });
+        });
+
+        describe('base64', () => {
+            it('should not return any errors', () => {
+                const a = new A();
+                a.text = 'SGVsbG8sIFdvcmxkLg==';
+                expect(validateSync(a)).toHaveLength(0);
+            });
+        });
+
+        describe(`'n.a.'`, () => {
+            it('should not return any errors', () => {
+                const a = new A();
+                a.text = 'n.a.';
+                expect(validateSync(a)).toHaveLength(0);
+            });
+        });
+    });
+});

package/src/index.ts

@@ -0,0 +1 @@
+export * from './types';

package/src/types/adaptive/einar/event.dto.ts

@@ -0,0 +1,77 @@
+export class AdaptiveEventDto {
+    DetectorVersion: number;
+    DetectorID: string;
+    DetectorClassID: number;
+    DetectorClass: string;
+    EventTime: string; // timestamp (windows)
+    EventTriggerTime: string; // ditto
+    State: string;
+    EventCode: 114;
+    EventInfo: EventInfo;
+    EventID: string;
+    DetectorEventType: string;
+    Config: DetectorConfig;
+    Device?: DeviceInfo;
+}
+
+export class EventInfo {
+    Text: string;
+    Confidence: number;
+    Country: string; // 'USA/LA'
+    CountryCode: number;
+    Coords: number[]; // of found lpn
+    BackgroundColor: string;
+    DedicatedAreaColor: string;
+    TextColor: string;
+    CharacterSize: number;
+    Direction: 'Approaching' | 'Moving away' | 'Unknown';
+    TriggerSource: TriggerSource;
+    MMR: MMR;
+}
+
+export class TriggerSource {
+    Name: string;
+    Source: string;
+    Timestamp: string;
+}
+
+export class MMR {
+    Category: string;
+    Make: string;
+    Model: string;
+    Color: string;
+    CategoryConfidence: number;
+    MakeAndModelConfidence: number;
+    ColorConfidence: number;
+}
+
+export class DetectorConfig {
+    Class: string;
+    DetectorClass: string;
+    Version: number;
+    DetectorClassID: number;
+    BuiltIn: boolean;
+    DetectorID: string;
+    DisplayName: string;
+    Description: string;
+    ViolationTimeMs: number;
+    RestoreDelayMs: number;
+    FpsLimit: number;
+    Enabled: boolean;
+    Mode: string;
+    Filter: string;
+    Whitelist: boolean;
+    Masks: object;
+}
+
+export class DeviceInfo {
+    Name: string;
+    Description: string;
+    Location: {
+        GPS: {
+            Latitude: number;
+            Longitude: number;
+        };
+    };
+    Serial: string;
+}

package/src/types/adaptive/einar/index.ts

@@ -0,0 +1,2 @@
+export * from './event.dto';
+export * from './job.dto';

package/src/types/adaptive/einar/job.dto.ts

@@ -0,0 +1,9 @@
+import { AdaptiveEventDto } from './event.dto';
+
+export class AdaptiveJob extends AdaptiveEventDto {
+    type: 'adaptive';
+    payloadTimestamp: number;
+    vehicleImageUrl: string;
+    plateImageUrl: string;
+    event_timestamp: string;
+}

package/src/types/adaptive/index.ts

@@ -0,0 +1,4 @@
+export * from './einar';
+export * from './vidar';
+export * from './vidar-new';
+export * from './micro';

package/src/types/adaptive/micro/README.md

@@ -0,0 +1,32 @@
+# Micro Cam
+
+The Micro Cam is almost identical in it's interface to the Vidar, and also in it's configuration. The JSON template file can be found in the `vidar-new` folder, and the filename template file is in `vidar`.
+
+
+## GPS
+
+This is specific to Micro Cams, so it's the most important to be documented here. The Peplink routers that we use have an open socket at port `60660` that continuously produces GPS data. You can try `telnet 192.168.50.1 60660` in your bash shell to verify (assuming the router is at that IP --- it usually is). If the output does not contian lat/long, make sure the antenna is properly connected and able to receive GPS signal. You must be aboveground to receive GPS data.
+In the camera, go to `http://{CAMERA_IP}/#plainconfig`. There you will set the following settings:
+
+```
+/default/cff/gps/enabled = 1
+
+/default/cfs/gps/type = 5
+/default/cfs/gps/destination = tcp://192.168.50.1:60660
+```
+
+You can then trigger an event using the software trigger and expect to the see the GPS data in the event upload. For fast feedback when testing, you can edit the line editor of the camera by appending the following: `GPS: $A, $O` to see it in the black bar at the bottom of each image.
+
+If you don't see the GPS data right away, give it a few minutes, sometimes it takes a little while for the camera to integrate the data flow. If it's still not working, give Adaptive a call.
+
+## Architecture
+
+The Micro Cam is under the umbrella of `VidarNew`, because 
+the Micro Cam is the same as the Vidar. The new way to process Vidar uploads was developed when integrating the Micro Cam (see `../vidar-new/README.md` for more details).
+
+In general, the Camera will upload a result file containing the pertinent data points and the images, encoded in base64 format. The controller will grab the file and pass it to the service, which will in turn upload the images to the S3 bucket and pass the event data to the message queue. The images will be converted from base64 to binary once in the bucket by a connected Lambda function.
+
+## Camera Configuration
+
+Upload `../vidar-new/vidar.json.tmpl` to the camera and set it as the result upload file format. Set `../vidar/filenames.tmpl` as the filename template. Point the camera to `https://lpr.vanguardparking.co/vidar/micro?source={CAMERA_NAME}`. De-select plate image for the upload, so only "Result Upload" should be checked.
+Additionally, you want to make sure that connection attempts is set between 3-5, and connection timeout to `5000ms`. That's something we are currently experimenting with.

package/src/types/adaptive/micro/index.ts

@@ -0,0 +1 @@
+export * from './micro-job.dto';

package/src/types/adaptive/micro/micro-job.dto.ts

@@ -0,0 +1,5 @@
+import { VidarNewJobBase } from '../vidar-new';
+
+export class MicroJob extends VidarNewJobBase {
+    type: 'micro';
+}

package/src/types/adaptive/vidar/event.dto.ts

@@ -0,0 +1,23 @@
+import { IsIn, IsNumberString, IsString, Length } from 'class-validator';
+import { VidarDirection } from './vidar-direction.enum';
+
+export class VidarEventDto {
+    @IsString()
+    cameraId: string;
+
+    @IsNumberString()
+    vidarEventId: string;
+
+    @IsNumberString()
+    eventTimestamp: string;
+
+    @IsString()
+    @Length(0, 3)
+    state: string;
+
+    @IsString()
+    text: string;
+
+    @IsIn(['0', '1', '2'])
+    direction: VidarDirection;
+}

package/src/types/adaptive/vidar/filenames.tmpl

@@ -0,0 +1 @@
+$(cameraid);-$(ID);

package/src/types/adaptive/vidar/index.ts

@@ -0,0 +1,3 @@
+export * from './vidar-direction.enum';
+export * from './event.dto';
+export * from './job.dto';

package/src/types/adaptive/vidar/job.dto.ts

@@ -0,0 +1,9 @@
+import { VidarEventDto } from './event.dto';
+
+export class VidarJob extends VidarEventDto {
+    type: 'vidar';
+    eventId: string;
+    payloadTimestamp: number;
+    vehicleImageUrl: string;
+    plateImageUrl: string;
+}

package/src/types/adaptive/vidar/vidar-direction.enum.ts

@@ -0,0 +1,5 @@
+export const enum VidarDirection {
+    UNKOWN = '0',
+    APPROACHING = '1',
+    LEAVING = '2',
+}

package/src/types/adaptive/vidar/vidar.json.tmpl

@@ -0,0 +1,8 @@
+{
+    "cameraId": "$(cameraid);",
+    "vidarEventId": "$(ID);",
+    "eventTimestamp": "$(FRAMETIMEMS);",
+    "state": "$(STATE_SHORT);",
+    "text": "$DB2JSON($(ANPR_TEXT));",
+    "direction": "$(TRIGGER_DIRECTION);"
+}

package/src/types/adaptive/vidar-new/README.md

@@ -0,0 +1,23 @@
+# Vidar New
+
+This is the updated version of the vidar uploads. As of the time of this writing (3/5/24), the newer method has not yet been deployed on the existing vidars. It will be soon. It is currently live on the Micro Cams. 
+
+The main advantage of this method is twofold: 
+
+1. All the data comes in one request: JSON and images
+2. The images are compressed using base64
+
+Because all the data comes in one request, we have a greater guarantee of catching everything. If we got the JSON, we can be reasonably certain that we got the images. We are having issues with the current method, in which the JSON and two images each come in separately, so that's 3 separate requests per event, and we were dropping some images, but getting the events. Furthermore, the compressed payload size should help improve general performance.
+
+## Important
+
+In the Vidar settings, go to `{VIDAR_IP}/#plainconfig` and set `/default/cfs/uplm/http/content` to 4. By unchecking the boxes titled `Image` and `Plate Image` in the result upload page, that should do the trick, but make sure anyways, because it once happened that it didn't. The image was being sent to the server and not handled properly throwing an error. 
+
+## Architecture
+
+The data file comes in and is parsed. The base64 images get sent up to the cloud, where they are converted and compressed, and the event data is passed on to the message queue. That's it.
+
+## Camera Configuration
+
+Upload `../vidar-new/vidar.json.tmpl` to the camera and set it as the result upload file format. Set `../vidar/filenames.tmpl` as the filename template. Point the camera to `https://lpr.vanguardparking.co/vidar/micro?source={CAMERA_NAME}`. De-select plate image for the upload, so only "Result Upload" should be checked.
+Additionally, you want to make sure that connection attempts is set between 3-5, and connection timeout to `5000ms`. That's something we are currently experimenting with.

package/src/types/adaptive/vidar-new/index.ts

@@ -0,0 +1,4 @@
+export * from './vidar-new-job.dto';
+export * from './vidar-new-job-base.dto';
+export * from './vidar-new.event.dto';
+export * from './vidar-new-job.type';

package/src/types/adaptive/vidar-new/vidar-new-job-base.dto.ts

@@ -0,0 +1,19 @@
+import { VidarDirection } from '../vidar/vidar-direction.enum';
+
+export class VidarNewJobBase {
+    cameraId: string;
+    vidarEventId: string;
+    eventTimestamp: string;
+    state: string;
+    text: string;
+    direction: VidarDirection;
+    latitude: string;
+    longitude: string;
+    // // everything up until here is in VidarNewEventDto,
+    // // needed to copy because want it to be a class, but can't omit base64 images
+
+    eventId: string;
+    payloadTimestamp: number;
+    vehicleImageUrl: string;
+    plateImageUrl: string;
+}

package/src/types/adaptive/vidar-new/vidar-new-job.dto.ts

@@ -0,0 +1,5 @@
+import { VidarNewJobBase } from './vidar-new-job-base.dto';
+
+export class VidarNewJob extends VidarNewJobBase {
+    type: 'vidar';
+}

package/src/types/adaptive/vidar-new/vidar-new-job.type.ts

@@ -0,0 +1,4 @@
+import { MicroJob } from '../micro/micro-job.dto';
+import { VidarNewJob } from './vidar-new-job.dto';
+
+export type VidarNewJobType = VidarNewJob | MicroJob;

package/src/types/adaptive/vidar-new/vidar-new.event.dto.ts

@@ -0,0 +1,40 @@
+import { IsBase64, IsIn, IsLatitude, IsLongitude, IsNumberString, IsString, Length, Validate } from 'class-validator';
+import { VidarDirection } from '../vidar/vidar-direction.enum';
+import { IsBase64OrNA } from '../../../decorators';
+
+export class VidarNewEventDto {
+    @IsString()
+    cameraId: string;
+
+    @IsNumberString()
+    vidarEventId: string;
+
+    @IsNumberString()
+    eventTimestamp: string;
+
+    @IsString()
+    @Length(0, 3)
+    state: string;
+
+    @IsString()
+    text: string;
+
+    @IsIn(['0', '1', '2'])
+    direction: VidarDirection;
+
+    /**
+     * Plate Image
+     * If Vidar is sending a motion capture - i.e. plate text = 'n.a.' - plateImage will be 'n.a.' as well
+     */
+    @Validate(IsBase64OrNA)
+    plateImage: string;
+
+    @IsBase64()
+    vehicleImage: string;
+
+    @IsLatitude()
+    latitude: string;
+
+    @IsLongitude()
+    longitude: string;
+}

package/src/types/adaptive/vidar-new/vidar-new.json.tmpl

@@ -0,0 +1,12 @@
+{
+	"cameraId": "$(cameraid);",
+	"vidarEventId": "$(ID);",
+	"eventTimestamp": "$(FRAMETIMEMS);",
+	"state": "$(STATE_SHORT);",
+	"text": "$DB2JSON($(ANPR_TEXT));",
+	"direction": "$(TRIGGER_DIRECTION);",
+	"plateImage": "$(lp_img);",
+	"vehicleImage": "$(normal_img);",
+	"latitude": "$(MISC_GPS_LAT);",
+	"longitude": "$(MISC_GPS_LON);"
+}

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from './adaptive';
+export * from './platesmart';
+export * from './rekor';
+export * from './lpr';

package/src/types/lpr/camera-type.ts

@@ -0,0 +1 @@
+export type CameraType = 'einar' | 'vidar' | 'rekor';

package/src/types/lpr/index.ts

@@ -0,0 +1,4 @@
+export * from './lpr-job.type';
+export * from './camera-type';
+export * from './lpr-job.interface';
+export * from './lpr-direction.enum';

package/src/types/lpr/lpr-direction.enum.ts

@@ -0,0 +1,5 @@
+export enum LprDirectionEnum {
+    APPROACHING = 1,
+    MOVING_AWAY = -1,
+    UNKNOWN = 0,
+}

package/src/types/lpr/lpr-job.interface.ts

@@ -0,0 +1,29 @@
+import { Orientation } from '../platesmart';
+import { CameraType } from './camera-type';
+import { LprDirectionEnum } from './lpr-direction.enum';
+
+export interface ILprJob {
+    type: CameraType;
+    lpn: string;
+    eventId: string;
+    orientation?: Orientation;
+    direction?: LprDirectionEnum;
+    cameraId: string;
+    twoLetterState: string;
+    eventTimestamp: number | Date;
+    payloadTimestamp: number | Date;
+    plateRegion: string;
+    vehicleImageURL: string;
+    plateImageURL: string;
+    confidence: number;
+    /**
+     * Informal identifying information
+     */
+    labels?: {
+        /**
+         * 'source' query param
+         */
+        reqSource?: string;
+        cameraName?: string;
+    };
+}

package/src/types/lpr/lpr-job.type.ts

@@ -0,0 +1,4 @@
+import { AdaptiveJob, VidarJob } from '../adaptive';
+import { RekorJob } from '../rekor';
+
+export type LprJob = AdaptiveJob | VidarJob | RekorJob;

package/src/types/platesmart/event.dto.ts

@@ -0,0 +1,58 @@
+export class PlatesmartEventDto {
+    image: Image;
+    plate: Plate;
+    source: Source;
+    vehicle?: Vehicle;
+    id: string;
+    timestamp: number;
+    type: string;
+    version: string;
+}
+
+export class Image {
+    height: number;
+    id: string;
+    width: number;
+}
+
+export class Plate {
+    code?: string;
+    region: Region;
+    tag: string;
+}
+
+export class Region {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+}
+
+export class Source {
+    id: string;
+    name: string;
+    type: string;
+}
+
+export class Vehicle {
+    color?: Color;
+    make?: Make;
+    orientation?: Orientation;
+    type?: Make;
+    bearing?: number;
+    occlusion?: number;
+}
+
+export class Color {
+    code: string;
+}
+
+export class Make {
+    code: string;
+    name: string;
+}
+
+export class Orientation {
+    code: 'rear' | 'front' | 'side';
+    name: 'Rear' | 'Front' | 'Side';
+}

package/src/types/platesmart/index.ts

@@ -0,0 +1,3 @@
+export * from './event.dto';
+export * from './job';
+// export * from './orientation.enum';

package/src/types/platesmart/job.ts

@@ -0,0 +1,11 @@
+import { PlatesmartEventDto } from './event.dto';
+
+class PlatesmartJobForQueue extends PlatesmartEventDto {
+    payloadTimestamp: number;
+}
+
+export class PlatesmartJob extends PlatesmartJobForQueue {
+    saved: boolean;
+    plateImageURL: string;
+    vehicleImageURL: string;
+}

package/src/types/platesmart/orientation.enum.ts

@@ -0,0 +1,5 @@
+// export enum Orientation {
+//     Front = 'front',
+//     Rear = 'rear',
+//     Side = 'side'
+// };

package/src/types/rekor/event.dto.ts

@@ -0,0 +1,108 @@
+// made using quicktype.io on a rekor webhook test
+
+export interface RekorEvent {
+    data_type: string;
+    version: number;
+    epoch_start: number;
+    epoch_end: number;
+    frame_start: number;
+    frame_end: number;
+    company_id: string;
+    agent_uid: string;
+    agent_version: string;
+    agent_type: string;
+    camera_id: number;
+    gps_latitude: number;
+    gps_longitude: number;
+    country: string;
+    uuids: string[];
+    vehicle_path: EPath[];
+    plate_indexes: number[];
+    candidates: Candidate[];
+    best_plate: BestPlate;
+    best_confidence: number;
+    best_plate_number: string;
+    best_region: string;
+    best_region_confidence: number;
+    matches_template: boolean;
+    plate_path: EPath[];
+    vehicle_crop_jpeg: string;
+    overview_jpeg: string;
+    best_uuid: string;
+    best_uuid_epoch_ms: number;
+    best_image_width: number;
+    best_image_height: number;
+    travel_direction: number;
+    is_parked: boolean;
+    is_preview: boolean;
+    vehicle_signature: string;
+    vehicle: RekorVehicleType;
+    web_server_config: WebServerConfig;
+    direction_of_travel_id: number;
+    custom_data: string;
+}
+
+export interface BestPlate {
+    plate: string;
+    confidence: number;
+    matches_template: number;
+    plate_index: number;
+    region: string;
+    region_confidence: number;
+    processing_time_ms: number;
+    requested_topn: number;
+    coordinates: Coordinate[];
+    plate_crop_jpeg: string;
+    vehicle_region: VehicleRegion;
+    vehicle_detected: boolean;
+    candidates: Candidate[];
+}
+
+export interface Candidate {
+    plate: string;
+    confidence: number;
+    matches_template: number;
+}
+
+export interface Coordinate {
+    x: number;
+    y: number;
+}
+
+export interface VehicleRegion {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export interface EPath {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    t: number;
+    f: number;
+}
+
+// name conflict w/ Platesmart
+export interface RekorVehicleType {
+    color: BodyType[];
+    make: BodyType[];
+    make_model: BodyType[];
+    body_type: BodyType[];
+    year: BodyType[];
+    orientation: BodyType[];
+    missing_plate: BodyType[];
+    is_vehicle: BodyType[];
+}
+
+export interface BodyType {
+    name: string;
+    confidence: number;
+}
+
+export interface WebServerConfig {
+    camera_label: string;
+    agent_label: string;
+}

package/src/types/rekor/index.ts

@@ -0,0 +1,2 @@
+export * from './event.dto';
+export * from './job';

package/src/types/rekor/job.ts

@@ -0,0 +1,13 @@
+export class RekorJob {
+    type: 'rekor';
+    uuid: string;
+    lpn: string;
+    state: string;
+    cameraId: string;
+    timestamp: number;
+    payloadTimestamp: number;
+    plateImageURL: string;
+    vehicleImageURL: string;
+    travelDirection: number;
+    directionOfTravelId: number;
+}

package/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+    "extends": "./tsconfig.json",
+    "exclude": [
+        "node_modules",
+        "dist",
+        "**/*spec.ts"
+    ]
+}