@jetta/axle-load-calculator 0.1.3

package/src/core/orchestration/axle_weight_physics.ts

@@ -0,0 +1,37 @@
+import { CmAxleWeightService } from '../physics/services/cm_axle_weight_service.js'
+import { CenterOfMass } from '../physics/items/center_of_mass.js'
+import { build_connector_payload } from './connector_payload_builder.js'
+import { mass_center_by_grouper_from_env } from './java_mass_center.js'
+
+/**
+ * Calculates loaded weights per vehicle axle (in-process, no HTTP).
+ * @param env_vehicle - Single env from weight_by_axis payload.
+ * @returns Loaded cargo weight per axle index.
+ */
+export function calculate_loaded_weights_for_env(
+    env_vehicle: Record<string, unknown>
+): number[]
+{
+    const center_of_mass_by_grouper = mass_center_by_grouper_from_env(env_vehicle)
+    const wire_center_of_mass = map_center_of_mass_wire(center_of_mass_by_grouper)
+    const payload = build_connector_payload(env_vehicle, wire_center_of_mass)
+    return new CmAxleWeightService().calculate(payload)
+}
+
+/**
+ * @param center_of_mass_by_grouper - CM objects keyed by grouper.
+ * @returns Plain mass/z map for wire builder.
+ */
+function map_center_of_mass_wire(
+    center_of_mass_by_grouper: Record<number, CenterOfMass>
+): Record<number, { mass: number, z: number }>
+{
+    const wire: Record<number, { mass: number, z: number }> = {}
+    for (const grouper of Object.keys(center_of_mass_by_grouper))
+    {
+        const id = Number(grouper)
+        const entry = center_of_mass_by_grouper[id]
+        wire[id] = { mass: entry.mass, z: entry.z }
+    }
+    return wire
+}

package/src/core/orchestration/collision_checker.ts

@@ -0,0 +1,86 @@
+/**
+ * Validates allocated items do not overlap (Java CollisionChecker parity for tests).
+ * @param env_vehicle - Env vehicle with containers and items.
+ */
+export function check_cargo_collision(env_vehicle: Record<string, unknown>): void
+{
+    const key = env_vehicle.conteiners ? 'conteiners' : 'containers'
+    const containers = env_vehicle[key] as Record<string, unknown>[] | undefined
+    if (!containers)
+    {
+        return
+    }
+    for (const container of containers)
+    {
+        check_container_items(container)
+    }
+}
+
+/**
+ * @param container - Container with items.
+ */
+function check_container_items(container: Record<string, unknown>): void
+{
+    const items = container.items as Record<string, unknown>[] | undefined
+    if (!items || items.length <= 1)
+    {
+        return
+    }
+    for (let i = 0; i < items.length - 1; i++)
+    {
+        for (let j = i + 1; j < items.length; j++)
+        {
+            if (items_intersect(items[i], items[j]))
+            {
+                throw new Error('Item overlap error')
+            }
+        }
+    }
+}
+
+/**
+ * @param left - First item.
+ * @param right - Second item.
+ * @returns True when 3D boxes overlap (Java Item.intersect axes swap).
+ */
+function items_intersect(left: Record<string, unknown>, right: Record<string, unknown>): boolean
+{
+    const left_box = item_intervals(left)
+    const right_box = item_intervals(right)
+    return intervals_overlap(left_box.x, right_box.x)
+        && intervals_overlap(left_box.y, right_box.y)
+        && intervals_overlap(left_box.z, right_box.z)
+}
+
+/**
+ * @param item - Item JSON.
+ * @returns Axis intervals using Java coordinate mapping.
+ */
+function item_intervals(item: Record<string, unknown>): {
+    x: [number, number]
+    y: [number, number]
+    z: [number, number]
+}
+{
+    const x0 = Number(item.x ?? 0)
+    const width = Number(item.largura ?? item.width ?? 0)
+    const json_y = Number(item.y ?? 0)
+    const json_z = Number(item.z ?? 0)
+    const length = Number(item.comprimento ?? item.length ?? 0)
+    const height = Number(item.altura ?? item.height ?? 0)
+    return {
+        x: [x0, x0 + width],
+        y: [json_z, json_z + height],
+        z: [json_y, json_y + length]
+    }
+}
+
+/**
+ * @param left - Interval.
+ * @param right - Interval.
+ * @returns True when open intervals overlap.
+ */
+function intervals_overlap(left: [number, number], right: [number, number]): boolean
+{
+    return left[0] < right[1] && right[0] < left[1]
+}

package/src/core/orchestration/connector_payload_builder.ts

@@ -0,0 +1,81 @@
+import { WIRE_FLAGS } from '../contracts/wire_flags.js'
+
+/**
+ * Builds axle-weight service payload from a prepared env vehicle (Java AxleWeightConnector).
+ * @param env_vehicle - Vehicle object inside envs[].
+ * @param center_of_mass_by_grouper - CM per grouper for CM service flag.
+ * @returns Transport record for CmAxleWeightService.
+ */
+export function build_connector_payload(
+    env_vehicle: Record<string, unknown>,
+    center_of_mass_by_grouper: Record<number, { mass: number, z: number }>
+): Record<string, unknown>
+{
+    const center_of_mass = map_center_of_mass_wire(center_of_mass_by_grouper)
+    return {
+        [WIRE_FLAGS.CONTAINERS]: build_containers(env_vehicle),
+        [WIRE_FLAGS.AXLE_LIST]: build_axles(env_vehicle),
+        [WIRE_FLAGS.TRANSPORT_ID]: env_vehicle._id,
+        [WIRE_FLAGS.AMOUNT]: 1,
+        [WIRE_FLAGS.SUPPORTED_WEIGHT]: env_vehicle.pesoDeCarga,
+        [WIRE_FLAGS.FIRST_AXLE_DISTANCE]: env_vehicle.primeiroEixo,
+        [WIRE_FLAGS.VEHICLE_TYPE]: env_vehicle.tipoVeiculo,
+        [WIRE_FLAGS.VEHICLE_VERSION]: env_vehicle.tipoVersao,
+        [WIRE_FLAGS.SUSPENSION_TYPE]: env_vehicle.tipoSuspensao,
+        [WIRE_FLAGS.CM_SERVICE_CENTER_OF_MASS]: center_of_mass
+    }
+}
+
+/**
+ * @param center_of_mass_by_grouper - CM per grouper from Java MassCenter.
+ * @returns Wire map for CM service.
+ */
+function map_center_of_mass_wire(
+    center_of_mass_by_grouper: Record<number, { mass: number, z: number }>
+): Record<string, { mass: number, z_position: number }>
+{
+    const center_of_mass: Record<string, { mass: number, z_position: number }> = {}
+    for (const grouper_key of Object.keys(center_of_mass_by_grouper))
+    {
+        const entry = center_of_mass_by_grouper[Number(grouper_key)]
+        center_of_mass[grouper_key] = {
+            mass: entry.mass,
+            [WIRE_FLAGS.CM_SERVICE_Z]: entry.z
+        }
+    }
+    return center_of_mass
+}
+
+/**
+ * @param env_vehicle - Env vehicle JSON.
+ * @returns Container wire list without items.
+ */
+function build_containers(env_vehicle: Record<string, unknown>): Record<string, unknown>[]
+{
+    const list = env_vehicle.containers as Record<string, unknown>[]
+    return list.map((container) => ({
+        [WIRE_FLAGS.LENGTH]: container.comprimento,
+        [WIRE_FLAGS.WIDTH]: container.largura,
+        [WIRE_FLAGS.HEIGHT]: container.altura,
+        [WIRE_FLAGS.SEQUENCE]: container.sequencia,
+        [WIRE_FLAGS.MAIN_PIN_DISTANCE]: container.distPinoRei,
+        [WIRE_FLAGS.CONTAINER_DISTANCE_AHEAD]: container.containerDistanceAhead,
+        [WIRE_FLAGS.GROUPER]: container.grouper
+    }))
+}
+
+/**
+ * @param env_vehicle - Env vehicle JSON.
+ * @returns Axle wire list.
+ */
+function build_axles(env_vehicle: Record<string, unknown>): Record<string, unknown>[]
+{
+    const list = env_vehicle.eixos as Record<string, unknown>[]
+    return list.map((axle) => ({
+        [WIRE_FLAGS.DISTANCE_FROM_ORIGIN]: axle.distanciaOrigem,
+        [WIRE_FLAGS.MAX_SUPPORTED_WEIGHT]: axle.pesoMaxSuportado,
+        [WIRE_FLAGS.SEQUENCE_CONTAINER]: axle.sequenciaContainer,
+        [WIRE_FLAGS.DNIT_WEIGHT]: axle.pesoDnit ?? axle.pesoMaxSuportado,
+        [WIRE_FLAGS.TARE]: axle.tara
+    }))
+}

package/src/core/orchestration/java_mass_center.ts

@@ -0,0 +1,98 @@
+import { CenterOfMass } from '../physics/items/center_of_mass.js'
+
+/**
+ * Computes mass center per grouper using ms-faixas Java Item / MassCenter rules.
+ * Longitudinal position uses JSON `y` (maps to Ponto3D.z in Java CubeRepresentation).
+ * @param env_vehicle - Single env vehicle object from weight_by_axis payload.
+ * @returns Map of grouper id to center of mass.
+ */
+export function mass_center_by_grouper_from_env(
+    env_vehicle: Record<string, unknown>
+): Record<number, CenterOfMass>
+{
+    const result: Record<number, CenterOfMass> = {}
+    const containers = env_vehicle.containers as Record<string, unknown>[] | undefined
+    if (!containers)
+    {
+        return result
+    }
+    for (const container of containers)
+    {
+        const grouper = Number(container.grouper)
+        // Java AxleWeightConnector overwrites per container in loop order (last wins).
+        result[grouper] = compute_container_mass_center(container)
+    }
+    return result
+}
+
+/**
+ * @param container - Container object with items array.
+ * @returns Center of mass for container items.
+ */
+function compute_container_mass_center(container: Record<string, unknown>): CenterOfMass
+{
+    const center_of_mass = new CenterOfMass()
+    const items = container.items as Record<string, unknown>[] | undefined
+    if (!items || items.length === 0)
+    {
+        center_of_mass.mass = 0
+        center_of_mass.z = 0
+        return center_of_mass
+    }
+    const container_offset = read_container_longitudinal_offset(container)
+    let accumulated = 0
+    let mass = 0
+    for (const item of items)
+    {
+        const weight = read_item_weight(item)
+        const position = container_offset + read_item_longitudinal_position(item)
+        accumulated += weight * position
+        mass += weight
+    }
+    center_of_mass.mass = mass
+    center_of_mass.z = mass === 0 ? 0 : accumulated / mass
+    return center_of_mass
+}
+
+/**
+ * @param container - Container JSON.
+ * @returns Longitudinal offset of container body (first faixa z1 when present).
+ */
+function read_container_longitudinal_offset(container: Record<string, unknown>): number
+{
+    const bands = container.faixas as Record<string, unknown>[] | undefined
+    if (!bands || bands.length === 0)
+    {
+        return 0
+    }
+    return Number(bands[0].z1 ?? 0)
+}
+
+/**
+ * @param item - Ms-faixas item JSON.
+ * @returns Item weight.
+ */
+function read_item_weight(item: Record<string, unknown>): number
+{
+    if (item.peso !== undefined)
+    {
+        return Number(item.peso)
+    }
+    return Number(item.weight ?? 0)
+}
+
+/**
+ * @param item - Ms-faixas item JSON.
+ * @returns Longitudinal position for equilibrium (Java getZ on pontoDeInicio).
+ */
+function read_item_longitudinal_position(item: Record<string, unknown>): number
+{
+    const origin_y = Number(item.y ?? 0)
+    const custom = item.centerOfGravity as Record<string, unknown> | undefined
+    if (custom && custom.z !== undefined)
+    {
+        return origin_y + Number(custom.z)
+    }
+    const length = Number(item.comprimento ?? item.length ?? 0)
+    return origin_y + length / 2
+}

package/src/core/orchestration/output_builder.ts

@@ -0,0 +1,18 @@
+/**
+ * @param envs - Output env list.
+ * @returns Success JSON string.
+ */
+export function build_success_output(envs: Record<string, unknown>[]): string
+{
+    return JSON.stringify({ envs })
+}
+
+/**
+ * @param error - Thrown error.
+ * @returns Error JSON string matching ms-faixas format.
+ */
+export function build_error_output(error: unknown): string
+{
+    const message = error instanceof Error ? error.message : String(error)
+    return JSON.stringify({ msg: message, apiError: message })
+}

package/src/core/orchestration/request_schema.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod'
+
+const env_schema = z.object({
+    _id: z.union([z.string(), z.number()]).optional(),
+    eixos: z.array(z.record(z.unknown())).min(1),
+    conteiners: z.array(z.record(z.unknown())).optional(),
+    containers: z.array(z.record(z.unknown())).optional()
+}).passthrough()
+
+const request_schema = z.object({
+    envs: z.array(env_schema).min(1),
+    config: z.record(z.unknown()).optional()
+}).passthrough()
+
+export type WeightByAxisRequest = z.infer<typeof request_schema>
+
+/**
+ * Parses and validates weight-by-axis JSON at the library boundary.
+ * @param json_data - Raw request string.
+ * @returns Parsed request object.
+ */
+export function parse_weight_by_axis_request(json_data: string): WeightByAxisRequest
+{
+    const parsed: unknown = JSON.parse(json_data)
+    return request_schema.parse(parsed)
+}

package/src/core/orchestration/weight_by_axis_task.ts

@@ -0,0 +1,140 @@
+import { calculate_loaded_weights_for_env } from './axle_weight_physics.js'
+import { build_success_output, build_error_output } from './output_builder.js'
+import { check_cargo_collision } from './collision_checker.js'
+import { parse_weight_by_axis_request } from './request_schema.js'
+
+/**
+ * Runs weight-by-axis for ms-faixas JSON input (WeightByAxisTask.run contract).
+ * @param json_data - Raw request JSON string.
+ * @returns Response JSON string.
+ */
+export function run_weight_by_axis_task(json_data: string): string
+{
+    try
+    {
+        const request = parse_weight_by_axis_request(json_data)
+        const envs = request.envs as Record<string, unknown>[]
+        const output_envs = []
+        for (const env of envs)
+        {
+            const loaded_weights = calculate_loaded_weights_for_env(env)
+            apply_loaded_weights_to_env(env, loaded_weights)
+            check_cargo_collision(env)
+            output_envs.push(strip_items_and_bands(env))
+        }
+        return build_success_output(output_envs)
+    }
+    catch (error)
+    {
+        return build_error_output(error)
+    }
+}
+
+/**
+ * @param env - Env vehicle object.
+ * @param loaded_weights - Forces per axle.
+ */
+function apply_loaded_weights_to_env(
+    env: Record<string, unknown>,
+    loaded_weights: number[]
+): void
+{
+    const axles = env.eixos as Record<string, unknown>[]
+    for (let index = 0; index < loaded_weights.length; index++)
+    {
+        const cargo = loaded_weights[index]
+        const axle = axles[index]
+        const tare = Number(axle.tara ?? 0)
+        axle.pesoCarregado = cargo
+        axle.pesoCarregadoFinal = tare + cargo
+    }
+    const containers = env.conteiners ?? env.containers
+    if (!Array.isArray(containers))
+    {
+        return
+    }
+    apply_to_containers(containers as Record<string, unknown>[], loaded_weights, axles)
+}
+
+/**
+ * @param containers - Container list on env.
+ * @param loaded_weights - Per-axle cargo load.
+ * @param axles - Vehicle axles list.
+ */
+function apply_to_containers(
+    containers: Record<string, unknown>[],
+    loaded_weights: number[],
+    axles: Record<string, unknown>[]
+): void
+{
+    for (const container of containers)
+    {
+        const peso_eixos = build_peso_eixos_for_container(container, loaded_weights, axles)
+        container.pesoEixos = peso_eixos
+    }
+}
+
+/**
+ * @param container - Container on env.
+ * @param loaded_weights - All axle loads.
+ * @param axles - Vehicle axles.
+ * @returns pesoEixos array for container.
+ */
+function build_peso_eixos_for_container(
+    container: Record<string, unknown>,
+    loaded_weights: number[],
+    axles: Record<string, unknown>[]
+): Record<string, unknown>[]
+{
+    const sequence = Number(container.sequencia)
+    const result: Record<string, unknown>[] = []
+    for (let index = 0; index < axles.length; index++)
+    {
+        if (Number(axles[index].sequenciaContainer) !== sequence)
+        {
+            continue
+        }
+        result.push(build_peso_eixo_entry(axles[index], loaded_weights[index]))
+    }
+    return result
+}
+
+/**
+ * @param axle - Axle record on env.
+ * @param cargo - Loaded cargo on axle.
+ * @returns Single pesoEixos entry.
+ */
+function build_peso_eixo_entry(
+    axle: Record<string, unknown>,
+    cargo: number
+): Record<string, unknown>
+{
+    const tare = Number(axle.tara ?? 0)
+    return {
+        distanciaOrigem: axle.distanciaOrigem,
+        pesoMax: Number(axle.pesoMaxSuportado) - tare,
+        pesoMaxFinal: axle.pesoMaxSuportado,
+        tara: tare,
+        pesoCarregado: cargo,
+        pesoCarregadoFinal: tare + cargo,
+        distanciaOrigemSemPrimeiroEixo: axle.distanciaOrigemSemPrimeiroEixo ?? 0
+    }
+}
+
+/**
+ * @param env - Env with updated axle data.
+ * @returns Env copy without items/faixas on containers.
+ */
+function strip_items_and_bands(env: Record<string, unknown>): Record<string, unknown>
+{
+    const clone = JSON.parse(JSON.stringify(env)) as Record<string, unknown>
+    const key = clone.conteiners ? 'conteiners' : 'containers'
+    const containers = clone[key] as Record<string, unknown>[]
+    for (const container of containers)
+    {
+        container.items = []
+        container.faixas = []
+    }
+    clone.idCaminhao = clone._id
+    return clone
+}

package/src/core/physics/items/allocated_item.ts

@@ -0,0 +1,41 @@
+import type { RotationCode } from '../../contracts/rotation_enum.js'
+import { ROTATION } from '../../contracts/rotation_enum.js'
+import type { ItemTemplates } from './item_templates.js'
+
+/**
+ * Allocated cargo item with position in container coordinates.
+ */
+export class AllocatedItem
+{
+    xi = 0
+    yi = 0
+    zi = 0
+    rotation: RotationCode = ROTATION.POS1
+    readonly template_index: number
+    readonly templates: ItemTemplates
+
+    /**
+     * @param templates - Shared templates.
+     * @param template_index - Template index.
+     */
+    constructor(templates: ItemTemplates, template_index: number)
+    {
+        this.templates = templates
+        this.template_index = template_index
+    }
+
+    get weight(): number
+    {
+        return this.templates.weights[this.template_index]
+    }
+
+    get length(): number
+    {
+        return this.templates.get_length(this.template_index, this.rotation)
+    }
+
+    get center_of_gravity_z(): number
+    {
+        return this.zi + this.length / 2
+    }
+}

package/src/core/physics/items/allocated_item_manager.ts

@@ -0,0 +1,50 @@
+import { AllocatedItem } from './allocated_item.js'
+import type { ItemTemplates } from './item_templates.js'
+
+/**
+ * Items allocated inside one container sequence.
+ */
+export class AllocatedItemManager
+{
+    private items: AllocatedItem[] = []
+
+    /**
+     * @param templates - Item templates for this container.
+     */
+    constructor(readonly templates: ItemTemplates)
+    {
+    }
+
+    /**
+     * @param items - Items to add.
+     */
+    add_allocated_items(items: AllocatedItem[]): void
+    {
+        this.items.push(...items)
+    }
+
+    /**
+     * @returns Item count.
+     */
+    count_items(): number
+    {
+        return this.items.length
+    }
+
+    /**
+     * @returns Item indexes.
+     */
+    list_item_indexes(): number[]
+    {
+        return this.items.map((_item, index) => index)
+    }
+
+    /**
+     * @param item_index - Item index.
+     * @returns Item instance.
+     */
+    get_item(item_index: number): AllocatedItem
+    {
+        return this.items[item_index]
+    }
+}

package/src/core/physics/items/center_of_mass.ts

@@ -0,0 +1,31 @@
+import type { AllocatedItemManager } from './allocated_item_manager.js'
+
+/**
+ * Center of mass for a load grouper (longitudinal z in chassis coordinates).
+ */
+export class CenterOfMass
+{
+    mass = 0
+    z = 0
+
+    /**
+     * Computes center of mass from allocated items.
+     * @param allocated_items - Item manager for one grouper.
+     */
+    set_center_of_mass_with_allocated_items(allocated_items: AllocatedItemManager): void
+    {
+        let accumulated_weighted_positions = 0
+        this.mass = 0
+        for (const item_index of allocated_items.list_item_indexes())
+        {
+            const item = allocated_items.get_item(item_index)
+            accumulated_weighted_positions += item.center_of_gravity_z * item.weight
+            this.mass += item.weight
+        }
+        if (this.mass === 0)
+        {
+            return
+        }
+        this.z = accumulated_weighted_positions / this.mass
+    }
+}

package/src/core/physics/items/compute_grouper_center_of_mass.ts

@@ -0,0 +1,44 @@
+import type { Transport } from '../transports/transport.js'
+import { MergedContainers } from '../transports/merged_containers.js'
+import { CenterOfMass } from './center_of_mass.js'
+import type { MultiContainerAllocatedItems } from './multi_container_allocated_items.js'
+import type { ChassiForces } from '../models/chassi_forces.js'
+
+/**
+ * @param multi_items - Allocated items across containers.
+ * @param merged - Merged container layout.
+ * @returns Center of mass map keyed by grouper id.
+ */
+export function compute_center_of_mass_by_grouper(
+    multi_items: MultiContainerAllocatedItems,
+    merged: MergedContainers
+): Record<number, CenterOfMass>
+{
+    multi_items.merge_allocated_items(merged)
+    const result: Record<number, CenterOfMass> = {}
+    for (const grouper of merged.list_grouper_indexes())
+    {
+        const center_of_mass = new CenterOfMass()
+        center_of_mass.set_center_of_mass_with_allocated_items(
+            multi_items.get_allocated_items_by_grouper_index(grouper))
+        result[grouper] = center_of_mass
+    }
+    return result
+}
+
+/**
+ * @param transport - Parsed transport.
+ * @param multi_items - Allocated items.
+ * @param solve - Model solver from CM map.
+ * @returns Chassis forces.
+ */
+export function calculate_chassi_forces_from_multi(
+    transport: Transport,
+    multi_items: MultiContainerAllocatedItems,
+    solve: (center_of_mass_by_grouper: Record<number, CenterOfMass>) => ChassiForces
+): ChassiForces
+{
+    const merged = new MergedContainers(transport)
+    const center_of_mass_by_grouper = compute_center_of_mass_by_grouper(multi_items, merged)
+    return solve(center_of_mass_by_grouper)
+}