@jetta/blocks-allocator 0.0.0-stage → 0.1.0-0

package/src/Allocation_Optimization/tie_ratio/loose_on_block/loose_on_block_slot_state.js

@@ -0,0 +1,88 @@
+/**
+ * @returns {{ occupied_slots: Map<string, Set<number>>, pending_footprints: object[] }}
+ */
+function create_loose_on_block_slot_state()
+{
+    return {
+        occupied_slots: new Map(),
+        pending_footprints: []
+    }
+}
+
+function layer_state_key(group_id, placement_y)
+{
+    return `${group_id}:${placement_y}`
+}
+
+function get_occupied_slot_set(slot_state, group_id, placement_y)
+{
+    const key = layer_state_key(group_id, placement_y)
+    if (!slot_state.occupied_slots.has(key))
+    {
+        slot_state.occupied_slots.set(key, new Set())
+    }
+    return slot_state.occupied_slots.get(key)
+}
+
+/**
+ * @param {object} slot_state
+ * @param {string|number} group_id
+ * @param {number} placement_y
+ * @param {number} slot_index
+ * @returns {void}
+ */
+function mark_slot_occupied(slot_state, group_id, placement_y, slot_index)
+{
+    get_occupied_slot_set(slot_state, group_id, placement_y).add(slot_index)
+}
+
+/**
+ * @param {object} slot_state
+ * @param {string|number} group_id
+ * @param {number} placement_y
+ * @param {number} slot_index
+ * @returns {boolean}
+ */
+function is_slot_marked_occupied(slot_state, group_id, placement_y, slot_index)
+{
+    const key = layer_state_key(group_id, placement_y)
+    return slot_state.occupied_slots.get(key)?.has(slot_index) === true
+}
+
+/**
+ * @param {object} slot_state
+ * @param {number} placement_y
+ * @param {number} origin_x
+ * @param {number} origin_z
+ * @param {number} item_width
+ * @param {number} item_length
+ * @param {number} item_height
+ * @returns {void}
+ */
+function register_pending_footprint(
+    slot_state,
+    placement_y,
+    origin_x,
+    origin_z,
+    item_width,
+    item_length,
+    item_height
+)
+{
+    slot_state.pending_footprints.push({
+        placement_y,
+        origin_x,
+        origin_z,
+        item_width,
+        item_length,
+        item_height
+    })
+}
+
+module.exports = {
+    create_loose_on_block_slot_state,
+    mark_slot_occupied,
+    is_slot_marked_occupied,
+    register_pending_footprint,
+    allocated_item_blocks_slot: require('./slot_footprint_collision').allocated_item_blocks_slot
+}

package/src/Allocation_Optimization/tie_ratio/loose_on_block/placement_coords_fit_inside_container.js

@@ -0,0 +1,34 @@
+const box_fits_inside_container = require('./box_fits_inside_container')
+
+/**
+ * @param {object} container
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} item_width
+ * @param {number} item_height
+ * @param {number} item_length
+ * @returns {boolean}
+ */
+function placement_coords_fit_inside_container(
+    container,
+    origin_x,
+    origin_y,
+    origin_z,
+    item_width,
+    item_height,
+    item_length
+)
+{
+    return box_fits_inside_container(
+        container,
+        origin_x,
+        origin_y,
+        origin_z,
+        item_width,
+        item_height,
+        item_length
+    )
+}
+
+module.exports = placement_coords_fit_inside_container

package/src/Allocation_Optimization/tie_ratio/loose_on_block/read_empilhar_area_igual_from_allocation_item.js

@@ -0,0 +1,12 @@
+/**
+ * @param {object} allocation_item
+ * @returns {boolean}
+ */
+function read_empilhar_area_igual_from_allocation_item(allocation_item)
+{
+    const json = allocation_item.get_json?.() ?? allocation_item
+    const restrictions = json.restricoes ?? json.restrictions ?? {}
+    return restrictions.empilharAreaIgual === true
+}
+
+module.exports = read_empilhar_area_igual_from_allocation_item

package/src/Allocation_Optimization/tie_ratio/loose_on_block/realigned_loose_geometry_gates.js

@@ -0,0 +1,25 @@
+const loose_item_fits_inside_container = require('./loose_item_fits_inside_container')
+const loose_item_has_geometric_support = require('./loose_item_has_geometric_support')
+const allocated_item_penetrates_any = require('./allocated_item_penetrates_any')
+
+/**
+ * @param {object} container
+ * @param {object} container_view
+ * @param {object} allocated_item
+ * @returns {boolean}
+ */
+function realigned_loose_passes_geometry_gates(container, container_view, allocated_item)
+{
+    if (!loose_item_fits_inside_container(container, allocated_item))
+    {
+        return false
+    }
+    const occupants = container_view.get_allocated_items?.() ?? []
+    if (allocated_item_penetrates_any(allocated_item, occupants))
+    {
+        return false
+    }
+    return loose_item_has_geometric_support(container_view, allocated_item)
+}
+
+module.exports = realigned_loose_passes_geometry_gates

package/src/Allocation_Optimization/tie_ratio/loose_on_block/resolve_loose_on_generic_supporter.js

@@ -0,0 +1,65 @@
+const find_supporter_directly_below = require('./find_supporter_directly_below')
+const loose_footprint_region_from_options = require('./loose_footprint_region_from_options')
+const item_fits_supporter_slot = require('./item_fits_supporter_slot')
+const build_placement_on_generic_supporter = require('./build_placement_on_generic_supporter')
+const find_best_generic_supporter_placement = require('./find_best_generic_supporter_placement')
+
+/**
+ * @param {object} container_view
+ * @param {object} loose_item
+ * @param {object|undefined} slot_state
+ * @param {object} placement_options
+ * @param {object|undefined} container
+ * @returns {{ x: number, y: number, z: number }|undefined}
+ */
+function resolve_loose_on_generic_supporter(
+    container_view,
+    loose_item,
+    slot_state,
+    placement_options,
+    container
+)
+{
+    const candidates = container_view.get_allocated_items?.() ?? []
+    const footprint = loose_footprint_region_from_options(loose_item, placement_options)
+    const direct_supporter = find_supporter_directly_below(
+        loose_item,
+        candidates,
+        placement_options
+    )
+    if (direct_supporter !== undefined)
+    {
+        if (!item_fits_supporter_slot(
+            direct_supporter,
+            placement_options.item_width,
+            placement_options.item_length,
+            placement_options.require_same_area === true
+        ))
+        {
+            return find_best_generic_supporter_placement(
+                candidates,
+                footprint,
+                slot_state,
+                placement_options,
+                container
+            )
+        }
+        return build_placement_on_generic_supporter(
+            candidates,
+            direct_supporter,
+            slot_state,
+            placement_options,
+            container
+        )
+    }
+
+    return find_best_generic_supporter_placement(
+        candidates,
+        footprint,
+        slot_state,
+        placement_options,
+        container
+    )
+}
+
+module.exports = resolve_loose_on_generic_supporter

package/src/Allocation_Optimization/tie_ratio/loose_on_block/resolve_loose_placement_position.js

@@ -0,0 +1,68 @@
+const Cargo_Profile = require('../../../models/Cargo_Profile')
+const find_tie_ratio_supporter_cluster = require('./find_tie_ratio_supporter_cluster')
+const build_slot_grid_from_cluster = require('./build_slot_grid_from_cluster')
+const resolve_placement_y_at_slot = require('./resolve_placement_y_at_slot')
+const select_tie_ratio_slot_placement = require('./select_tie_ratio_slot_placement')
+
+/**
+ * Resolves aligned placement for a loose item above a tie-ratio compound block.
+ * @param {object} container
+ * @param {object} empty_space
+ * @param {object} slot_state
+ * @param {import('../supporters_by_top_y_index').Supporters_By_Top_Y_Index|undefined} supporters_by_top_y_index
+ * @param {{ item_width?: number, item_length?: number, require_same_area?: boolean }|undefined} placement_options
+ * @param {number|undefined} placement_bottom_y
+ * @param {{ group_id: string|number, orientation: '3_2'|'2_3', items: object[] }|undefined} known_cluster
+ * @returns {{ x: number, y: number, z: number, slot_index: number, group_id: string|number }|undefined}
+ */
+function resolve_loose_placement_position(
+    container,
+    empty_space,
+    slot_state,
+    supporters_by_top_y_index,
+    placement_options,
+    placement_bottom_y,
+    known_cluster
+)
+{
+    if (!Cargo_Profile.stack_loose_on_tie_ratio_blocks())
+    {
+        return undefined
+    }
+
+    const cluster = known_cluster ?? find_tie_ratio_supporter_cluster(
+        container,
+        empty_space,
+        supporters_by_top_y_index,
+        placement_bottom_y,
+        placement_options
+    )
+    if (cluster === undefined)
+    {
+        return undefined
+    }
+
+    const slot_grid = build_slot_grid_from_cluster(cluster.items)
+    const allocated_items = container.get_allocated_items?.() ?? []
+
+    const slot_placements = slot_grid.map(slot => ({
+        slot,
+        placement_y: resolve_placement_y_at_slot(
+            allocated_items,
+            slot,
+            slot_state
+        )
+    }))
+    const minimum_resolved_y = Math.min(...slot_placements.map(entry => entry.placement_y))
+
+    return select_tie_ratio_slot_placement(
+        container,
+        slot_placements,
+        minimum_resolved_y,
+        slot_state,
+        cluster,
+        placement_options
+    )
+}
+
+module.exports = resolve_loose_placement_position

package/src/Allocation_Optimization/tie_ratio/loose_on_block/resolve_placement_y_at_slot.js

@@ -0,0 +1,45 @@
+const math = require('@jetta/number-compare')
+
+function item_matches_slot_origin(item_x, item_z, slot)
+{
+    return math.eq(item_x, slot.x) && math.eq(item_z, slot.z)
+}
+
+/**
+ * Resolves vertical placement on top of items that occupy this slot origin.
+ * @param {object[]} allocated_items
+ * @param {object} slot
+ * @param {object|undefined} slot_state
+ * @returns {number}
+ */
+function resolve_placement_y_at_slot(allocated_items, slot, slot_state)
+{
+    let placement_y = slot.supporter_item.get_y() + slot.supporter_item.get_height()
+    for (const item of allocated_items)
+    {
+        if (typeof item.get_height !== 'function')
+        {
+            continue
+        }
+        if (!item_matches_slot_origin(item.get_x(), item.get_z(), slot))
+        {
+            continue
+        }
+        placement_y = Math.max(placement_y, item.get_y() + item.get_height())
+    }
+    if (slot_state === undefined)
+    {
+        return placement_y
+    }
+    for (const footprint of slot_state.pending_footprints)
+    {
+        if (!item_matches_slot_origin(footprint.origin_x, footprint.origin_z, slot))
+        {
+            continue
+        }
+        placement_y = Math.max(placement_y, footprint.placement_y + footprint.item_height)
+    }
+    return placement_y
+}
+
+module.exports = resolve_placement_y_at_slot

package/src/Allocation_Optimization/tie_ratio/loose_on_block/resolve_without_tie_ratio_cluster.js

@@ -0,0 +1,79 @@
+const math = require('@jetta/number-compare')
+const empty_space_is_on_floor = require('./empty_space_is_on_floor')
+const loose_item_fits_inside_container = require('./loose_item_fits_inside_container')
+const resolve_loose_on_generic_supporter = require('./resolve_loose_on_generic_supporter')
+const read_empilhar_area_igual_from_allocation_item = require('./read_empilhar_area_igual_from_allocation_item')
+const build_allocated_item_at_placement = require('./build_allocated_item_at_placement')
+const realigned_loose_passes_geometry_gates = require('./realigned_loose_geometry_gates')
+
+function finalize_placement_coords(
+    container,
+    container_view,
+    allocation_item,
+    placement
+)
+{
+    const realigned_item = build_allocated_item_at_placement(allocation_item, placement)
+    if (!realigned_loose_passes_geometry_gates(container, container_view, realigned_item))
+    {
+        return undefined
+    }
+    return realigned_item
+}
+
+/**
+ * @param {object} allocated_item
+ * @param {object} container
+ * @param {object} container_view
+ * @param {object} empty_space
+ * @param {object|undefined} slot_state
+ * @param {object} placement_options
+ * @param {object} allocation_item
+ * @returns {object|undefined}
+ */
+function resolve_without_tie_ratio_cluster(
+    allocated_item,
+    container,
+    container_view,
+    empty_space,
+    slot_state,
+    placement_options,
+    allocation_item
+)
+{
+    const on_container_floor = empty_space_is_on_floor(empty_space)
+        && math.le(allocated_item.get_y(), 0)
+    if (on_container_floor)
+    {
+        if (!loose_item_fits_inside_container(container, allocated_item))
+        {
+            return undefined
+        }
+        return allocated_item
+    }
+    const placement = resolve_loose_on_generic_supporter(
+        container_view,
+        allocated_item,
+        slot_state,
+        {
+            ...placement_options,
+            require_same_area: read_empilhar_area_igual_from_allocation_item(allocation_item)
+        },
+        container
+    )
+    if (placement === undefined)
+    {
+        return undefined
+    }
+    return finalize_placement_coords(
+        container,
+        container_view,
+        allocation_item,
+        placement
+    )
+}
+
+module.exports = {
+    resolve_without_tie_ratio_cluster,
+    finalize_placement_coords
+}

package/src/Allocation_Optimization/tie_ratio/loose_on_block/select_tie_ratio_slot_placement.js

@@ -0,0 +1,84 @@
+const math = require('@jetta/number-compare')
+const try_tie_ratio_slot_placement = require('./try_tie_ratio_slot_placement')
+
+/**
+ * @param {object} container
+ * @param {object[]} slot_placements
+ * @param {object} slot_state
+ * @param {object} cluster
+ * @param {object|undefined} placement_options
+ * @param {(entry: { slot: object, placement_y: number }) => boolean} layer_filter
+ * @returns {object|undefined}
+ */
+function pick_placement_from_slot_layers(
+    container,
+    slot_placements,
+    slot_state,
+    cluster,
+    placement_options,
+    layer_filter
+)
+{
+    for (const { slot, placement_y } of slot_placements)
+    {
+        if (!layer_filter({ slot, placement_y }))
+        {
+            continue
+        }
+        const placement = try_tie_ratio_slot_placement(
+            container,
+            slot,
+            placement_y,
+            slot_state,
+            cluster,
+            placement_options
+        )
+        if (placement !== undefined)
+        {
+            return placement
+        }
+    }
+    return undefined
+}
+
+/**
+ * @param {object} container
+ * @param {object[]} slot_placements
+ * @param {number} minimum_resolved_y
+ * @param {object} slot_state
+ * @param {object} cluster
+ * @param {object|undefined} placement_options
+ * @returns {object|undefined}
+ */
+function select_tie_ratio_slot_placement(
+    container,
+    slot_placements,
+    minimum_resolved_y,
+    slot_state,
+    cluster,
+    placement_options
+)
+{
+    const at_minimum = pick_placement_from_slot_layers(
+        container,
+        slot_placements,
+        slot_state,
+        cluster,
+        placement_options,
+        ({ placement_y }) => math.eq(placement_y, minimum_resolved_y)
+    )
+    if (at_minimum !== undefined)
+    {
+        return at_minimum
+    }
+    return pick_placement_from_slot_layers(
+        container,
+        slot_placements,
+        slot_state,
+        cluster,
+        placement_options,
+        ({ placement_y }) => math.gt(placement_y, minimum_resolved_y)
+    )
+}
+
+module.exports = select_tie_ratio_slot_placement

package/src/Allocation_Optimization/tie_ratio/loose_on_block/slot_footprint_collision.js

@@ -0,0 +1,105 @@
+const math = require('@jetta/number-compare')
+
+function ranges_overlap(start_a, end_a, start_b, end_b)
+{
+    return start_a < end_b && start_b < end_a
+}
+
+/**
+ * @param {object} footprint_like
+ * @param {object} slot
+ * @param {number} placement_y
+ * @param {number} item_width
+ * @param {number} item_length
+ * @returns {boolean}
+ */
+function allocated_item_blocks_slot(
+    footprint_like,
+    slot,
+    placement_y,
+    item_width,
+    item_length
+)
+{
+    const origin_y = typeof footprint_like.get_y === 'function'
+        ? footprint_like.get_y()
+        : footprint_like.placement_y
+    if (!math.eq(origin_y, placement_y))
+    {
+        return false
+    }
+    const origin_x = typeof footprint_like.get_x === 'function'
+        ? footprint_like.get_x()
+        : footprint_like.origin_x
+    const origin_z = typeof footprint_like.get_z === 'function'
+        ? footprint_like.get_z()
+        : footprint_like.origin_z
+    const footprint_width = typeof footprint_like.get_width === 'function'
+        ? footprint_like.get_width()
+        : footprint_like.item_width
+    const footprint_length = typeof footprint_like.get_length === 'function'
+        ? footprint_like.get_length()
+        : footprint_like.item_length
+    return ranges_overlap(
+        slot.x,
+        slot.x + item_width,
+        origin_x,
+        origin_x + footprint_width
+    ) && ranges_overlap(
+        slot.z,
+        slot.z + item_length,
+        origin_z,
+        origin_z + footprint_length
+    )
+}
+
+/**
+ * @param {object} allocated_item
+ * @param {object} slot
+ * @param {number} placement_y
+ * @returns {boolean}
+ */
+function allocated_item_occupies_slot(allocated_item, slot, placement_y)
+{
+    return allocated_item_blocks_slot(
+        allocated_item,
+        slot,
+        placement_y,
+        allocated_item.get_width(),
+        allocated_item.get_length()
+    )
+}
+
+/**
+ * @param {object} slot_state
+ * @param {object} slot
+ * @param {number} placement_y
+ * @param {number} item_width
+ * @param {number} item_length
+ * @returns {boolean}
+ */
+function pending_footprint_blocks_slot(
+    slot_state,
+    slot,
+    placement_y,
+    item_width,
+    item_length
+)
+{
+    return slot_state.pending_footprints.some(footprint =>
+        math.eq(footprint.placement_y, placement_y)
+        && allocated_item_blocks_slot(
+            footprint,
+            slot,
+            placement_y,
+            item_width,
+            item_length
+        )
+    )
+}
+
+module.exports = {
+    allocated_item_blocks_slot,
+    allocated_item_occupies_slot,
+    pending_footprint_blocks_slot
+}