Files
zmkgC/internal/app/system/controller/qianqi_dxf.go

802 lines
24 KiB
Go
Raw Permalink Normal View History

2025-07-07 20:11:59 +08:00
// ==========================================================================
// GFast自动生成controller操作代码。
// 生成日期2023-07-31 11:20:54
// 生成路径: internal/app/system/controller/qianqi_fangzhen.go
// 生成人gfast
// desc:方阵
// company:云南奇讯科技有限公司
// ==========================================================================
package controller
import (
"context"
"encoding/json"
"errors"
"fmt"
"github.com/gogf/gf/v2/crypto/gmd5"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/frame/g"
"github.com/google/uuid"
"github.com/jinzhu/copier"
"github.com/tiger1103/gfast/v3/api/v1/common/shp"
tool2 "github.com/tiger1103/gfast/v3/api/v1/common/tool"
"github.com/tiger1103/gfast/v3/api/v1/system"
"github.com/tiger1103/gfast/v3/internal/app/system/dao"
ct "github.com/tiger1103/gfast/v3/internal/app/system/logic/context"
"github.com/tiger1103/gfast/v3/internal/app/system/model"
"github.com/tiger1103/gfast/v3/internal/app/system/model/do"
"github.com/tiger1103/gfast/v3/internal/app/system/model/entity"
"github.com/tiger1103/gfast/v3/internal/app/system/service"
"github.com/tiger1103/gfast/v3/library/liberr"
"github.com/tiger1103/gfast/v3/third/create"
tool "github.com/tiger1103/gfast/v3/utility/coryUtils"
"math/rand"
"os"
"os/exec"
"strconv"
"strings"
"time"
)
type qianqiDxfController struct {
BaseController
}
var QianqiDxf = new(qianqiDxfController)
func (c *qianqiDxfController) FzFunc(ctx context.Context, req *system.FzReq) (res *system.FzRes, err error) {
err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
err = g.Try(ctx, func(ctx context.Context) {
//1、获取数据
point := req.Point
plane := req.Plane
//2、合并名称
var listE []system.FacFeatureByPlane //面
for _, data := range plane {
adata := system.FacFeatureByPlane{}
for _, bdata := range data.Features {
copier.Copy(&adata, &bdata)
listE = append(listE, adata)
}
}
var listT []system.FacFeatureByPoint //点
for _, data := range point {
adata := system.FacFeatureByPoint{}
for _, bdata := range data.Features {
copier.Copy(&adata, &bdata)
listT = append(listT, adata)
}
}
var templateDataList []do.WorkStatus
//3、循环判断坐标是否在点内
for _, i := range listE {
var minVal float64
var fzName string
for num, j := range listT {
inPolygon := tool.FanWei(i.Geometry.Coordinates[0], j.Geometry.Coordinates)
//如果为true说明在多边形内
if inPolygon {
//直接确认数据
fzName = j.Properties.Text //名字
} else {
distance := tool.PointToPolygonDistance(i.Geometry.Coordinates[0], j.Geometry.Coordinates)
fmt.Printf("点到多边形的最短距离(单位米):%.2f m\n", distance)
if num == 0 {
if len(listT) == 1 { //只有一个情况下直接赋值
minVal = distance
fzName = j.Properties.Text //名字
break
}
minVal = distance
fzName = j.Properties.Text //名字
} else {
if distance < minVal {
minVal = distance
fzName = j.Properties.Text //名字
}
}
}
}
//得到详情数据(方阵)
points := []shp.Point{}
for _, jwd := range i.Geometry.Coordinates[0] {
points = append(points, shp.Point{
Lng: jwd[0],
Lat: jwd[1],
})
}
polygon := shp.Polygon{
Positions: points,
}
marshal, err := json.Marshal(polygon)
if err != nil {
liberr.ErrIsNil(ctx, err, "详情获取失败")
}
//分割名称
if fzName != "" {
fzName = strings.Split(fzName, " ")[0]
}
// 将方阵的名称 作为方阵的id
fangzhen, err := dao.QianqiFangzhen.Ctx(ctx).Insert(&do.QianqiFangzhen{
ProjectId: req.SubProjectId,
Name: fzName,
SourceId: tool2.GetUuid(),
CreateBy: ct.New().GetLoginUser(ctx).Id,
Detail: string(marshal),
})
templateID, err := fangzhen.LastInsertId()
if err != nil {
continue
}
templateData, err := create.FetchTemplateData(ctx, templateID)
if err != nil {
continue
}
templateDataList = append(templateDataList, templateData...)
}
_, err = dao.WorkStatus.Ctx(ctx).Data(templateDataList).Batch(50).Insert()
})
return err
})
return
}
func (c *qianqiDxfController) XbFunc(ctx context.Context, req *system.XbReq) (res *system.XbRes, err error) {
var xbList []shp.Polyline
err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
err = g.Try(ctx, func(ctx context.Context) {
/**
箱变的录入
*/
var listE []system.FacFeatureByPoint //面
for _, data := range req.Plane {
adata := system.FacFeatureByPoint{}
for _, bdata := range data.Features {
copier.Copy(&adata, &bdata)
listE = append(listE, adata)
}
}
var listT []system.FacFeatureByPoint //点
for _, data := range req.Point {
adata := system.FacFeatureByPoint{}
for _, bdata := range data.Features {
copier.Copy(&adata, &bdata)
listT = append(listT, adata)
}
}
var xiangbianArray []do.QianqiXiangbian
//3、循环判断坐标是否在点内
for _, i := range listE {
var minVal float64
var fzName string
for num, j := range listT {
distance := tool.PointToPointDistance(i.Geometry.Coordinates, j.Geometry.Coordinates)
if num == 0 {
if len(listT) == 1 { //只有一个情况下直接赋值
minVal = distance
fzName = j.Properties.Text //名字
break
}
minVal = distance
fzName = j.Properties.Text //名字
} else {
if distance < minVal {
minVal = distance
fzName = j.Properties.Text //名字
}
}
}
if fzName != "" {
fzName = strings.Split(fzName, " ")[0]
}
//得到详情数据(箱变)
points := []shp.Point{
{
Lng: i.Geometry.Coordinates[0],
Lat: i.Geometry.Coordinates[1],
Property: shp.Property{
Name: fzName,
},
},
}
polylines := shp.Polyline{
Positions: points,
Property: shp.Property{
Name: fzName,
},
}
xbList = append(xbList, polylines)
marshal, err := json.Marshal(polylines)
if err != nil {
liberr.ErrIsNil(ctx, err, "详情获取失败")
}
xb := do.QianqiXiangbian{
ProjectId: req.SubProjectId,
SourceId: gmd5.MustEncryptString(req.ProjectId + fzName),
Name: fzName,
ModelId: "518bb3c165e22097ebbf2c2c42c8e308",
CreateBy: ct.New().GetLoginUser(ctx).Id,
Detail: string(marshal),
}
// 判断是否已经存在了该方阵,存在了就不再添加
count, _ := dao.QianqiXiangbian.Ctx(ctx).Where(dao.QianqiXiangbian.Columns().SourceId, xb.SourceId).Count()
if count == 0 {
xiangbianArray = append(xiangbianArray, xb)
}
}
if len(xiangbianArray) > 0 {
_, err = dao.QianqiXiangbian.Ctx(ctx).Insert(&xiangbianArray)
liberr.ErrIsNil(ctx, err, "添加失败")
}
/**
需要操作pvmodel
*/
if err == nil {
//1、获取当前项目的所有方阵然后判断箱变是否在方阵内或最近然后记录方阵id
var fzres []*model.QianqiFangzhenInfoRes
dao.QianqiFangzhen.Ctx(ctx).Where(dao.QianqiFangzhen.Columns().ProjectId, req.SubProjectId).Scan(&fzres)
for _, fz := range fzres {
var minVal float64
var fzId int
var data *shp.Polyline
// 解析JSON数据
var polygon shp.Polygon
err = json.Unmarshal([]byte(fz.Detail), &polygon)
array := tool.ConvertPolygonToFloatArray(polygon)
for num, xb := range xbList {
numbers := []float64{xb.Positions[0].Lng, xb.Positions[0].Lat}
wei := tool.FanWei(array, numbers)
//如果为true说明在多边形内
if wei {
fzId = fz.Id
data = &xb
} else {
distance := tool.PointToPolygonDistance(array, numbers)
if num == 0 {
if len(xbList) == 1 { //只有一个情况下直接赋值
minVal = distance
fzId = fz.Id
data = &xb
break
}
minVal = distance
fzId = fz.Id
data = &xb
} else {
if distance < minVal {
minVal = distance
fzId = fz.Id
data = &xb
}
}
}
}
if data != nil {
err := service.PvModule().ImportCory(ctx, &system.PvModuleImportCory{
FangZhenID: strconv.Itoa(fzId),
ProjectID: req.ProjectId,
SubProjectID: req.SubProjectId,
Shapes: &shp.ShpObj{
Polylines: []shp.Polyline{
*data,
},
},
})
liberr.ErrIsNil(ctx, err, "pvmodel箱变录入失败")
}
}
}
})
return err
})
return
}
func (c *qianqiDxfController) NbqFunc(ctx context.Context, req *system.NbqReq) (res *system.NbqRes, err error) {
var nbqList []shp.Polyline
err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
err = g.Try(ctx, func(ctx context.Context) {
/**
处理逆变器数据
*/
//1、获取数据
point := req.Point
plane := req.Plane
//2、合并名称
var listE []system.FacFeatureByPoint //面
for _, data := range plane {
adata := system.FacFeatureByPoint{}
for _, bdata := range data.Features {
copier.Copy(&adata, &bdata)
listE = append(listE, adata)
}
}
var listT []system.FacFeatureByPoint //点
for _, data := range point {
adata := system.FacFeatureByPoint{}
for _, bdata := range data.Features {
copier.Copy(&adata, &bdata)
listT = append(listT, adata)
}
}
var arr []do.QianqiNibianqi
//3、循环判断坐标是否在点内
for _, i := range listE {
var minVal float64
var fzName string
for num, j := range listT {
distance := tool.PointToPointDistance(i.Geometry.Coordinates, j.Geometry.Coordinates)
if num == 0 {
if len(listT) == 1 { //只有一个情况下直接赋值
minVal = distance
fzName = j.Properties.Text //名字
break
}
minVal = distance
fzName = j.Properties.Text //名字
} else {
if distance < minVal {
minVal = distance
fzName = j.Properties.Text //名字
}
}
//}
}
if fzName != "" {
fzName = strings.Split(fzName, " ")[0]
}
//得到详情数据(方阵)
points := []shp.Point{
{
Lng: i.Geometry.Coordinates[0],
Lat: i.Geometry.Coordinates[1],
Property: shp.Property{
Name: fzName,
},
},
}
polylines := shp.Polyline{
Positions: points,
Property: shp.Property{
Name: fzName,
},
}
nbqList = append(nbqList, polylines)
marshal, err := json.Marshal(polylines)
if err != nil {
liberr.ErrIsNil(ctx, err, "详情获取失败")
}
nibianqi := do.QianqiNibianqi{}
nibianqi.ProjectId = req.SubProjectId
nibianqi.SourceId = gmd5.MustEncryptString(req.ProjectId + fzName)
nibianqi.Name = fzName
nibianqi.ModelId = "41b366a9bae250098716da675d3ae26d"
nibianqi.CreateBy = ct.New().GetLoginUser(ctx).Id
nibianqi.Detail = string(marshal)
// 判断是否已经存在了该方阵,存在了就不再添加
count, _ := dao.QianqiNibianqi.Ctx(ctx).Where(dao.QianqiNibianqi.Columns().SourceId, nibianqi.SourceId).Count()
if count == 0 {
arr = append(arr, nibianqi)
}
}
if len(arr) > 0 {
_, err = dao.QianqiNibianqi.Ctx(ctx).Insert(&arr)
liberr.ErrIsNil(ctx, err, "添加失败")
}
/**
进行pvmodel数据处理
*/
if err == nil {
//1、获取当前项目的所有方阵然后判断箱变是否在方阵内或最近然后记录方阵id
var fzres []*model.QianqiFangzhenInfoRes
dao.QianqiFangzhen.Ctx(ctx).Where(dao.QianqiFangzhen.Columns().ProjectId, req.SubProjectId).Scan(&fzres)
for _, fz := range fzres {
var minVal float64
var fzId int
var data *shp.Polyline
// 解析JSON数据
var polygon shp.Polygon
err = json.Unmarshal([]byte(fz.Detail), &polygon)
array := tool.ConvertPolygonToFloatArray(polygon)
for num, xb := range nbqList {
numbers := []float64{xb.Positions[0].Lng, xb.Positions[0].Lat}
wei := tool.FanWei(array, numbers)
//如果为true说明在多边形内
if wei {
fzId = fz.Id
} else {
distance := tool.PointToPolygonDistance(array, numbers)
if num == 0 {
if len(nbqList) == 1 { //只有一个情况下直接赋值
minVal = distance
fzId = fz.Id
data = &xb
break
}
minVal = distance
fzId = fz.Id
data = &xb
} else {
if distance < minVal {
minVal = distance
fzId = fz.Id
data = &xb
}
}
}
}
if data != nil {
err := service.PvModule().ImportInverterCory(ctx, &system.ImportInverterCory{
FangZhenID: strconv.Itoa(fzId),
ProjectID: req.ProjectId,
SubProjectID: req.SubProjectId,
Shapes: &shp.ShpObj{
Polylines: []shp.Polyline{
*data,
},
},
})
liberr.ErrIsNil(ctx, err, "pvmodel逆变器录入失败")
}
}
}
})
return err
})
return
}
func (c *qianqiDxfController) GfbFunc(ctx context.Context, req *system.GfbReq) (res *system.GfbRes, err error) {
err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
err = g.Try(ctx, func(ctx context.Context) {
var gfbList []shp.Polyline
var eles []do.QianqiGuangfubanIds
/**
处理光伏板数据
*/
//1、获取数据
point := req.Point
plane := req.Plane
//2、合并名称
var listE []system.FacFeatureByPlane //面
for _, data := range plane {
adata := system.FacFeatureByPlane{}
for _, bdata := range data.Features {
copier.Copy(&adata, &bdata)
listE = append(listE, adata)
}
}
var listT []system.FacFeatureByPoint //点
for _, data := range point {
adata := system.FacFeatureByPoint{}
for _, bdata := range data.Features {
copier.Copy(&adata, &bdata)
listT = append(listT, adata)
}
}
//3、循环判断坐标是否在点内
for _, i := range listE {
var minVal float64
var fzName string
for num, j := range listT {
inPolygon := tool.FanWei(i.Geometry.Coordinates[0], j.Geometry.Coordinates)
//如果为true说明在多边形内
if inPolygon {
//直接确认数据
fzName = j.Properties.Text //名字
break
} else {
distance := tool.PointToPolygonDistance(i.Geometry.Coordinates[0], j.Geometry.Coordinates)
if num == 0 {
if len(listT) == 1 { //只有一个情况下直接赋值
minVal = distance
fzName = j.Properties.Text //名字
break
}
minVal = distance
fzName = j.Properties.Text //名字
} else {
if distance < minVal {
minVal = distance
fzName = j.Properties.Text //名字
}
}
}
}
if fzName != "" {
fzName = strings.Split(fzName, " ")[0]
}
//得到详情数据(方阵)
points := []shp.Point{}
for _, jwd := range i.Geometry.Coordinates[0] {
points = append(points, shp.Point{
Lng: jwd[0],
Lat: jwd[1],
Property: shp.Property{
Name: fzName,
},
})
}
polylines := shp.Polyline{
Positions: points,
Property: shp.Property{
Name: fzName,
},
}
gfbList = append(gfbList, polylines)
marshal, err := json.Marshal(polylines)
if err != nil {
liberr.ErrIsNil(ctx, err, "详情获取失败")
}
//===================
if !strings.HasPrefix(fzName, "G") {
continue
}
// 设置随机数种子
rand.Seed(time.Now().UnixNano())
randomNum := rand.Intn(6) + 1
randomStr1 := strconv.Itoa(randomNum)
ele := do.QianqiGuangfubanIds{
Name: fzName,
DevType: "1",
CreateBy: ct.New().GetLoginUser(ctx).Id,
SourceType: "guangfuban",
SourceId: tool2.GetUuid() + randomStr1,
ProjectId: req.SubProjectId,
Range: string(marshal),
}
eles = append(eles, ele)
if len(eles) > 500 {
dao.QianqiGuangfubanIds.Ctx(ctx).Insert(eles)
eles = []do.QianqiGuangfubanIds{}
}
}
/**
进行pvmodel数据处理
*/
if err == nil {
//1、获取当前项目的所有方阵然后判断箱变是否在方阵内或最近然后记录方阵id
fzres := []entity.QianqiFangzhen{}
queryErr := dao.QianqiFangzhen.Ctx(ctx).
Where(dao.QianqiFangzhen.Columns().ProjectId, req.SubProjectId).
Scan(&fzres)
if queryErr != nil {
liberr.ErrIsNil(ctx, queryErr, "方阵获取失败")
return
}
for _, fz := range fzres {
var data []shp.Polyline
// 解析JSON数据
var polygon shp.Polygon
err = json.Unmarshal([]byte(fz.Detail), &polygon)
array := tool.ConvertPolygonToFloatArray(polygon)
for _, xb := range gfbList {
numbers := []float64{xb.Positions[0].Lng, xb.Positions[0].Lat}
wei := tool.FanWei(array, numbers)
//如果为true说明在多边形内
if wei {
polyline := shp.Polyline{}
polyline = xb
data = append(data, polyline)
}
}
if data != nil {
err := service.PvModule().ImportPvBoardCory(ctx, &system.ImportPvBoardCory{
FangZhenID: strconv.Itoa(fz.Id),
ProjectID: req.ProjectId,
SubProjectID: req.SubProjectId,
Shapes: &shp.ShpObj{
Polylines: data,
},
Fangzhens: fzres,
})
liberr.ErrIsNil(ctx, err, "pvmodel光伏板录入失败")
}
}
}
})
return err
})
return
}
// 传入 point 构建出 detail 和 SourceID
func buildDetailAndSourceID(point shp.Point, name string) (string, string) {
// 生成 SourceID
sourceID := fmt.Sprintf("%s.%s", point.Name, strings.ReplaceAll(uuid.New().String(), "-", ""))
detail := Zhuangdian{
Position: point,
}
detail.Position.SourceId = sourceID
// 序列化后传回
data, err := json.Marshal(detail)
if err != nil {
return "", ""
}
return string(data), sourceID
}
func (c *qianqiDxfController) ZhuangDianFunc(ctx context.Context, req *system.ZdReq) (res *system.ZdRes, err error) {
//1、获取数据
plane := req.Plane
//2、合并名称
var listE []system.FacFeatureByPoint //面
for _, data := range plane {
adata := system.FacFeatureByPoint{}
for _, bdata := range data.Features {
copier.Copy(&adata, &bdata)
listE = append(listE, adata)
}
}
//3-1、获取到所有的方阵、光伏板,获取到方阵id根布版图绑定
fzres := []entity.QianqiFangzhen{}
queryErr := dao.QianqiFangzhen.Ctx(ctx).
Where(dao.QianqiFangzhen.Columns().ProjectId, req.SubProjectid).
Scan(&fzres)
if queryErr != nil {
liberr.ErrIsNil(ctx, queryErr, "方阵获取失败")
return
}
columns := dao.QianqiGuangfubanIds.Columns()
var resData []*model.QianqiGuangfubanIdsInfoRes
dao.QianqiGuangfubanIds.Ctx(ctx).Where(columns.ProjectId, req.SubProjectid).Scan(&resData)
if resData == nil && len(resData) == 0 {
liberr.ErrIsNil(ctx, errors.New("光伏板获取失败"))
return
}
for i, datum := range resData {
//布版图
var polygon1 shp.Polygon
err = json.Unmarshal([]byte(datum.Range), &polygon1)
if err != nil {
liberr.ErrIsNil(ctx, err, "详情获取失败")
return
}
f64 := []float64{polygon1.Positions[0].Lng, polygon1.Positions[0].Lat}
for _, fzre := range fzres { //方阵
//解析JSON数据
var polygon shp.Polygon
err = json.Unmarshal([]byte(fzre.Detail), &polygon)
if err != nil {
liberr.ErrIsNil(ctx, err, "详情获取失败")
return
}
array2 := tool.ConvertPolygonToFloatArray(polygon)
if tool.FanWei(array2, f64) {
resData[i].FzId = fzre.Id
}
}
}
//3-2、获取布版图
if resData != nil && len(resData) > 0 {
insertList := []do.QianqiGuangfubanIdsZhuangdian{}
for _, i := range resData { //面
num := 0
r := i.Range
// 解析JSON数据
var polygon shp.Polygon
err = json.Unmarshal([]byte(r), &polygon)
if err != nil {
return nil, err
}
//判断点是否在多边形内
array := tool.ConvertPolygonToFloatArray(polygon)
for _, j := range listE { //坐标点()
inPolygon := tool.FanWei(array, j.Geometry.Coordinates)
if inPolygon {
num = num + 1
// 调用 buildDetailAndSourceID 生成 detail 和 SourceID
pointcory := shp.Point{
Lng: j.Geometry.Coordinates[0],
Lat: j.Geometry.Coordinates[1],
Property: shp.Property{
Name: j.Geometry.Type,
},
}
_, sourceID := buildDetailAndSourceID(pointcory, j.Geometry.Type)
points := []shp.Point{pointcory}
polylines := shp.Polyline{Positions: points}
marshal, err := json.Marshal(polylines)
if err != nil {
liberr.ErrIsNil(ctx, err, "详情获取失败")
}
zhuangdian := do.QianqiGuangfubanIdsZhuangdian{
Name: i.Name + "." + strconv.Itoa(num),
SourceId: sourceID,
ProjectId: req.ProjectId,
Status: "0",
Detail: marshal,
SubProjectid: req.SubProjectid,
FangzhenId: i.FzId,
}
insertList = append(insertList, zhuangdian)
}
}
}
if len(insertList) > 0 {
batchNumber := 700
_, err = dao.QianqiGuangfubanIdsZhuangdian.Ctx(ctx).Batch(batchNumber).Insert(&insertList)
liberr.ErrIsNil(ctx, err, "光伏板插入失败")
_, err = dao.QianqiGuangfubanIdsLizhu.Ctx(ctx).Batch(batchNumber).Insert(&insertList)
liberr.ErrIsNil(ctx, err, "立柱插入失败")
_, err = dao.QianqiGuangfubanIdsZhijia.Ctx(ctx).Batch(batchNumber).Insert(&insertList)
liberr.ErrIsNil(ctx, err, "支架失败")
}
}
return
}
func (c *qianqiDxfController) DxfGet(ctx context.Context, req *system.DxfGetReq) (res *system.DxfGetRes, err error) {
// 定义 exe <DXF文件的绝对路径><结果 JS0N 文件的绝对路径><源 EPSG 代码><目标 EPSG 代码>
cmd := exec.Command("E:\\cory\\project\\go\\zmkgC\\resource\\public\\zmFiles\\pythonDxf.exe",
"E:\\cory\\project\\go\\zmkgC\\resource\\public\\zmFiles\\b93ba1d7008247a79503e8a80fe1de62.dxf",
"E:\\cory\\project\\go\\zmkgC\\resource\\public\\zmFiles\\nr.json",
"4524",
"4326",
)
// 执行并获取输出
output, err := cmd.CombinedOutput()
if err != nil {
fmt.Println("执行出错:", err)
}
fmt.Println("输出内容:", string(output))
return
}
func (c *qianqiDxfController) DxfData(ctx context.Context, req *system.DxfDataReq) (res *system.DxfDataRes, err error) {
res = &system.DxfDataRes{}
err = g.Try(ctx, func(ctx context.Context) {
// 指定要读取的JSON文件路径
filePath := "E:\\cory\\project\\go\\zmkgC\\resource\\public\\zmFiles\\nr.json"
// 读取文件内容
data, err := os.ReadFile(filePath)
if err != nil {
liberr.ErrIsNil(ctx, err, "读取失败")
}
// 用于存储解析后的JSON数据
var result map[string]interface{}
// 解析JSON数据
if err := json.Unmarshal(data, &result); err != nil {
liberr.ErrIsNil(ctx, err, "解析JSON失败")
}
res.Map = result
})
return
}
//
//func FanWei(mian [][]float64, dian [][]float64) bool {
//
// // 定义多边形范围 (经纬度点的顺序很重要,需要闭合:首尾点相同)
// polygon := orb.Polygon{
// {
// {106.518314, 29.627223}, // 起始位置
// {106.519419, 29.627223},
// {106.518238, 29.626399},
// {106.519491, 29.626435},
// {106.518314, 29.627223}, // 回到起始
// },
// }
// // 目标点
// point := orb.Point{106.518907, 29.626458} // 假设是一个经纬度点
//
// // 判断点是否在多边形内
// if planar.PolygonContains(polygon, point) {
// fmt.Println("点在多边形范围内")
// return true
// } else {
// fmt.Println("点不在多边形范围内")
// return false
// }
//}