分享根据需求下开发cesium、leaflet的自己写的一些公共方法

1. 公共处理geojson，单面转为多面 (可以适当调整修改优化)

export function handleToMultiGeo(data) {
    let paramsData;
    if (typeof data !== 'object') {
        try{
            data = JSON.parse(data)
            if (data.type === "Feature") {
                paramsData = {
                    type: "FeatureCollection",
                    features:[{...data}]
                }
            }
            return paramsData
        }catch(error) {
            return error
        }
    }
    return paramsData
}

2. 公共处理geosjon （后端数据问题）转为标准格式(多面)

    export function handleToParseGeo(data) {
        let parData,type,style
        if (typeof data === "string") data = JSON.parse(data)
        if (typeof data === "object" && !data.geometry) {
            if (data.type === "FeatureCollection") return perData = data
            type = data.type
            if (type.includes("ineString")) {
                //加入线段的默认样式
                style = {
                    materialType:"Color",
                    color:"#ff0000"
                }
            }
            perData = {
                type:"FeatureCollection",
                features:[{
                    geometry:data,
                    properties:{
                        style,
                        type:type.includes("olygon") ? "polygon" : "polyline"
                    },//需求只有线和面 不存在点的情况  可适当修改
                    type:"Feature"
                }]
            }
        }
        return parData || data
    }

3. 使用turf计算两条线的夹角角度

export function handleToAngle(data,points){
    //data为能获取到graphic的容器 或者直接为graphic根据实际情况修改
    //points为绘制的点的集合 画一条线段或者一个面的时候返回的所有的点
    let startAngle,endAngle,index，type;//开始线段的方位角，结束线段的方位角
    //index 为当前线在线段或者面中的索引 type为graphic的类型
    if (index === 0 && type === "polygon") {
        let points1 = [points[0].lng,points[0].lat]
        let points2 = [points[1].lng,points[1].lat]
        let points3 = [points[points.length-1].lng,points[points.length-1].lat]
        startAngle = turf.rhumbBearing(points1,points3)
        endAngle = turf.rhumbBearing(points1,points2)
    } else if (index === 0 && type === "polyline") {
        let points1 = [points[index].lng,points[index].lat]
        let points2 = [points[index+1].lng,points[index+1].lat]
        let points3 = [points[index+2].lng,points[index+2].lat]
        startAngle = turf.rhumbBearing(points2,points1)
        endAngle = turf.rhumbBearing(points2,points3)
    } else {
        let points1 = [points[points.length - 2].lng,points[points.length - 2].lat]
        let points2 = [points[points.length-3].lng,points[points.length-3].lat]
        let points3 = [points[points.length-1].lng,points[points.length-1].lat]
        startAngle = turf.rhumbBearing(points1,points2)
        endAngle = turf.rhumbBearing(points1,points3)
    } 
    return {
        startAngle,
        endAngle
    }
    
}


export function handleToLastAngle (startAngle,endAngle) {
//把上面获取到的两个角度传进来进行第二次判断  //根据实际情况优化
    let angle_180 = new Number()
    if (startAngle < 0 && endAngle < 0) {
        if (startAngle < endAngle) angle_180 = (-endAngle) - (-startAngle);
        if (startAngle > endAngle) angle_180 = (-startAngle) - (-endAngle);
    } else if (startAngle > 0 && endAngle < 0) {
        angle_180 = startAngle + (-endAngle);
    } else if (endAngle > 0 && startAngle < 0 ) {
        angle_180 = endAngle +  (-startAngle);
    } else if (endAngle > 0 && startAngle > 0) {
        if (startAngle < endAngle) angle_180 = startAngle - endAngle;
        if (startAngle > endAngle) angle_180 = endAngle - startAngle;
    }
    if (angle_180 > 180) angle_180 = 360 - angle_180;
    if (angle_180 < 0) angle_180 = -angle_180;
    return angle_180;
}

4.根据中心点生成长指定长宽的矩形

export function generateRectangle(type="90*45",latlng=null) {
    //根据需求修改格式判断
    if (latlng.split(",")[2]) return "输入的经纬度格式错误，请检查格式";
    let lng = Number(latlng.split(",")[0]);
    let lat = Number(latlng.split(",")[1]);
    if (isNaN(lat) || isNaN(lng)) return "输入的经纬度格式错误，请检查格式";
    //可以判断是否在某个地区  指定经纬度不能大于或小于多少就行
    
    let cePoint = {},position=[];
    let point = turf.point([lng,lat])
    let width = type.split("*")[0] / 1000
    let height = type.split("*")[1] / 1000
    cePoint.rightP = turf.rhumbDestination(point, width/2, 90);
    cePoint.leftP = turf.rhumbDestination(point, width/2, 270);
    cePoint.leftTopP = turf.rhumbDestination(turf.point(cePoint.leftP.geometry.coordinates), height/2, 0);
    cePoint.rightTopP = turf.rhumbDestination(turf.point(cePoint.leftP.geometry.coordinates), height/2, 0);
    cePoint.leftBottomP = turf.rhumbDestination(turf.point(cePoint.leftP.geometry.coordinates), height/2, 180);
    cePoint.rightBottomP = turf.rhumbDestination(turf.point(cePoint.leftP.geometry.coordinates), height/2, 180);
    
    delete cePoint.leftP
    delete cePoint.rightP
    Object.Keys(cePoint).forEach(el=>{
        position.push([cePoint[e].geometry.coordinates[0],cePoint[e].geometry.coordinates[1],0])//高度默认为0
    })
    position.push(position[0]) //如需封闭面 就加上
}


//我用的基本都是turf里面的方法  有兴趣的话可以去看看turf.js中文网

5.面的旋转

export function (graphicGeojson,center,angle) {
    //center 为面的中心点
    const rotatePoly = turf.transforRotate(graphiocGeojson,angle,{
        pivot:center
    })
    //根据面与多面修改 指向  这里就不扁平化了
    let cor = rotatePoly.geometry.coordinates[0].map(se=>{
        return{
            lng:se[0],
            lat:se[1]
        }
    })
    
    return cor
}

6.面的移动

export getTranslate(geojson,start,end){
    //start为面的中心点  end为你需要移动到的位置
    //转为标准格式
    start = turf.point([start.lng,start.lat])
    end = turf.point([end.lng,end.lat])
    // 计算两点方位角  和 距离
    const angle = turf.bearing(start,end);
    const distance = turf.rhumbDistance(start,end)
    const cloneGeom = turf.transformTranslate(geojson,distance,angle);
    let cor = cloneGeom.geometry.coordinates[0].map(se=>{
        return{
            lng:se[0],
            lat:se[1]
        }
    })
    
    return cor
}