Merge remote-tracking branch 'origin/master'

Junjie

2024-03-19 ec2e79e0d510568d51714a7121e4a32c026e6d44

 zy-asrs-flow/src/pages/map/utils.js

@@ -1,4 +1,11 @@
import * as PIXI from 'pixi.js';
import * as TWEEDLE from 'tweedle.js';
import Http from '@/utils/http';
import { message } from 'antd';
import { API_TIMEOUT } from '@/config/setting'
import agv from '/public/img/map/agv.svg'
import shelf from '/public/img/map/shelf.png'
import point from '/public/img/map/point.svg'

let app = null;
let mapContainer = null;
@@ -21,8 +28,9 @@
})

export const SENSOR_TYPE = Object.freeze({
    AGV: "AGV",
    SHELF: "SHELF",
    POINT: "POINT",
    AGV: "AGV",
})

export const getRealPosition = (x, y, mapContainer) => {
@@ -43,6 +51,21 @@
    };
}

// show sprite feature from sprite click event
export const viewFeature = (sprite, setCurSPrite) => {
    sprite.off('pointerup');
    sprite.off('pointermove');
    sprite.off('pointerdown');
    sprite.off('click');

    sprite.on("click", onClick);

    function onClick(event) {
        setCurSPrite(sprite);
    }

}

// sprite be movable from sprite click event
export const beMovable = (sprite, setDidClickSprite) => {
    sprite.off('pointerup');
@@ -54,13 +77,15 @@

    let dragTarget;
    function onDragStart(event) {
        setDidClickSprite(true);
        dragTarget = event.currentTarget;
        mapContainer.parent.off('pointermove');
        mapContainer.parent.on('pointermove', onDragMove, dragTarget);
        if (event.button === 0) {
            setDidClickSprite(true);
            dragTarget = event.currentTarget;
            mapContainer.parent.off('pointermove');
            mapContainer.parent.on('pointermove', onDragMove, dragTarget);

        mapContainer.parent.off('pointerup');
        mapContainer.parent.on('pointerup', onDragEnd.bind(mapContainer));
            mapContainer.parent.off('pointerup');
            mapContainer.parent.on('pointerup', onDragEnd.bind(mapContainer));
        }
    }

    function onDragMove(event) {
@@ -248,4 +273,169 @@
    } else {
        return '';
    }
}

export const rotationToNum = (rotation) => {
    let res = rotation * 180 / Math.PI;
    if (res < 0) {
        res += 360;
    } else if (res > 360) {
        res -= 360;
    }
    return res;
}

export const rotationParseNum = (num) => {
    return num * Math.PI / 180;
}

export const findSpriteByUuid = (uuid) => {
    return mapContainer?.children?.find(child => child?.data?.uuid === uuid);
}

export const sensorTypeSelectOptions = (intl) => {
    let options = [];
    Object.entries(SENSOR_TYPE).forEach(([key, value]) => {
        switch (key) {
            case SENSOR_TYPE.SHELF:
                options.push({
                    value: value,
                    label: intl.formatMessage({ id: 'map.sensor.type.shelf', defaultMessage: '货架' })
                })
                break;
            case SENSOR_TYPE.AGV:
                options.push({
                    value: value,
                    label: intl.formatMessage({ id: 'map.sensor.type.agv', defaultMessage: '无人小车' })
                })
                break;
            case SENSOR_TYPE.POINT:
                options.push({
                    value: value,
                    label: intl.formatMessage({ id: 'map.sensor.type.point', defaultMessage: '定位点' })
                })
                break;
            default:
                break;
        }

    })
    return options;
}

export const fetchMapData = async (intl) => {
    clearMapData();
    await Http.doPostPromise('api/map/list', {}, (res) => {
        const mapItemList = res.data.itemList;
        mapItemList.forEach(item => {
            let sprite;
            switch (item.type) {
                case SENSOR_TYPE.SHELF:
                    sprite = PIXI.Sprite.from(shelf);
                    break;
                case SENSOR_TYPE.AGV:
                    sprite = PIXI.Sprite.from(agv);
                    break;
                case SENSOR_TYPE.POINT:
                    sprite = PIXI.Sprite.from(point);
                    break;
                default:
                    break;
            }
            if (sprite) {
                initSprite(sprite, item.type);
                // data
                sprite.data.uuid = item.uuid;
                sprite.data.no = item.no;

                // graph
                sprite.position.set(item.positionX, item.positionY);
                sprite.scale.set(item.scaleX, item.scaleY);
                sprite.rotation = rotationParseNum(item.rotation);
                mapContainer.addChild(sprite);
            }
        })

    }).catch((error) => {
        console.error(error);
    })

}

export const saveMapData = async (intl) => {
    if (!mapContainer) {
        return;
    }

    let mapItemList = [];
    mapContainer?.children.forEach(child => {
        if (child.data?.uuid) {
            mapItemList.push({
                // data
                type: child.data.type,
                uuid: child.data.uuid,
                no: child.data.no,

                // graph
                positionX: child.position.x,
                positionY: child.position.y,
                scaleX: child.scale.x,
                scaleY: child.scale.y,
                rotation: rotationToNum(child.rotation)
            })
        }
    })

    const closeLoading = message.loading({ content: intl.formatMessage({ id: 'common.loading.api.message', defaultMessage: '等待服务器......' }), duration: API_TIMEOUT });
    await Http.doPostPromise('api/map/save', { itemList: mapItemList }, (res) => {
        closeLoading();
    }).catch((error) => {
        closeLoading();
        console.error(error);
    })
}

export const clearMapData = (intl) => {
    if (!mapContainer) {
        return;
    }
    let childList = [];
    mapContainer.children.forEach(child => {
        if (child.data?.uuid) {
            childList.push(child);
        }
    })
    if (childList.length > 0) {
        childList.forEach(child => {
            mapContainer.removeChild(child);
            child.destroy({ children: true, texture: false, baseTexture: false });
        })
        childList.forEach((child, index) => {
            childList[index] = null;
        });
        childList = [];
    }
}

export const beCenter = (sprite) => {
    if (!sprite || !app || !mapContainer) {
        return;
    }

    mapContainer.scale.set(1);
    mapContainer.position.set(0, 0);

    let bounds = sprite.getBounds();
    let centerPoint = {
        x: bounds.x + bounds.width / 2,
        y: bounds.y + bounds.height / 2
    };

    let targetPos = {
        x: app.renderer.width / 3 - centerPoint.x * mapContainer.scale.x,
        y: app.renderer.height / 3 - centerPoint.y * mapContainer.scale.y
    };

    new TWEEDLE.Tween(mapContainer.position).easing(TWEEDLE.Easing.Quadratic.Out)
        .to(targetPos, 500).start();
}