0
0

WebGIS开发之编辑功能（分割、融合、捕捉、追踪）

前言

目前市面上大部分WebGIS的产品的编辑功能都很简陋，大部分都只支持简单节点编辑。稍微好一点的会支持面数据裁剪分割、融合。但是在大部分数据使用场景中，为避免出现矢量和矢量之间出现缝隙、压盖等拓扑错误，捕捉和追踪功能就非常重要了。本博客主要讲解如何通过postgis和go语言实现来实现这些功能。

一、面分割

  1.     面分割实现，主要是通过绘制的线来切割面数据，需要考虑的是如果线反复穿越面几何，面几何存在多环岛，且线穿过多环岛。这种逻辑如果是通过纯前端turf库是较难实现的。但是如果是通过postgis，就没有那么难实现了，废话不多说直接上代码：
  1. // 图斑分割
  2. func (uc *UserController) SplitGeo(c *gin.Context) {
  3.     var jsonData ZDList
  4.     c.BindJSON(&jsonData)
  5.     var pic []models.GeoPic
  6.     DB := models.DB
  7.     var Way TempWay
  8.     DB.Where("tb_id = ?", jsonData.TBID).Find(&Way.TempGeo)
  9.     if len(Way.TempGeo) == 0 {
  10.         DB.Where("tb_id = ?", jsonData.TBID).Find(&Way.TempLayer)
  11.     }
  12.     DB.Where("tb_id = ?", jsonData.TBID).Find(&pic)
  13.     var att models.TempLayerAttribute
  14.     DB.Where("tb_id = ?", jsonData.TBID).Find(&att)
  15.     //线切割面
  16.     line := Transformer.GetGeometryString(jsonData.Line.Features[0])
  17.     p := GetSingleGeo(jsonData.TBID)
  18.     polygon := Transformer.GetGeometryString(p.Features[0])
  19.     sql := fmt.Sprintf("WITH geom AS ( SELECT ST_GeomFromGeoJSON('%s') AS line, ST_GeomFromGeoJSON('%s' ) AS polygon) SELECT ST_AsGeoJSON(ST_Split(geom.polygon,geom.line)) AS geojson FROM geom", line, polygon)
  20.     var geomData Transformer.GeometryData
  21.     err := DB.Raw(sql).Scan(&geomData)
  22.     if err.Error != nil {
  23.         c.String(http.StatusBadRequest, "err")
  24.         return
  25.     }
  26.     t := p.Features[0].Type
  27.     Properties := p.Features[0].Properties
  28.     geo := PGBytesToGeojson(geomData)
  29.     var NewGeo geojson.FeatureCollection
  30.     for index, item := range geo.Geometry {
  31.         var feature struct {
  32.             Geometry   map[string]interface{} `json:"geometry"`
  33.             Properties map[string]interface{} `json:"properties"`
  34.             Type       string                 `json:"type"`
  35.         }
  36.         feature.Properties = Properties
  37.         feature.Type = t
  38.         feature.Geometry = item
  39.         data2, _ := json.Marshal(feature)
  40.         var myfeature *geojson.Feature
  41.         json.Unmarshal(data2, &myfeature)
  42.         //判断是图层还是调查
  44.         TBID := uuid.New().String()
  45.         myfeature.ID = TBID
  46.         myfeature.Properties["TBID"] = TBID
  48.         //照片ID转移
  49.         for pi, _ := range pic {
  50.             pic[pi].TBID = TBID
  51.         }
  52.         DB.Save(pic)
  53.         if len(Way.TempGeo) >= 1 {
  54.             myfeature.Properties["bsm"] = TBID
  55.             myfeature.Properties["name"] = Way.TempGeo[0].Name + strconv.Itoa(index)
  56.             newgeo := geojson.NewFeatureCollection()
  58.             newgeo.Features = append(newgeo.Features, myfeature)
  59.             geoJSONData, err := json.MarshalIndent(newgeo, "", "  ")
  60.             if err == nil {
  61.                 result := models.TempGeo{TBID: TBID, Geojson: geoJSONData, MAC: Way.TempGeo[0].MAC, BSM: TBID, Date: time.Now().Format("2006-01-02 15:04:05"), Name: Way.TempGeo[0].Name + strconv.Itoa(index), ZT: Way.TempGeo[0].ZT}
  62.                 result_att := models.TempLayerAttribute{TBID: TBID, QKSM: att.QKSM, B: att.B, D: att.D, N: att.N, X: att.X, BZ: att.BZ, ZJR: att.ZJR, DCR: att.ZJR}
  63.                 DB.Create(&result)
  64.                 DB.Create(&result_att)
  65.             }
  66.         } else {
  67.             Layername := Way.TempLayer[0].Layername
  68.             bsm := Way.TempLayer[0].BSM
  69.             MAC := Way.TempLayer[0].MAC
  70.             myfeature.Properties["name"] = Way.TempLayer[0].Name + strconv.Itoa(index)
  71.             newgeo := geojson.NewFeatureCollection()
  72.             newgeo.Features = append(newgeo.Features, myfeature)
  73.             geoJSONData, err := json.MarshalIndent(newgeo, "", "  ")
  74.             if err == nil {
  75.                 result := models.TempLayer{Layername: Layername, MAC: MAC, BSM: bsm, TBID: TBID, Geojson: geoJSONData, ZT: Way.TempLayer[0].ZT, Name: Way.TempLayer[0].Name}
  76.                 result_att := models.TempLayerAttribute{TBID: TBID, Layername: Layername, QKSM: att.QKSM, B: att.B, D: att.D, N: att.N, X: att.X, BZ: att.BZ, ZJR: att.ZJR, DCR: att.ZJR}
  77.                 DB.Create(&result_att)
  78.                 DB.Create(&result)
  79.             }
  80.         }
  81.         NewGeo.Features = append(NewGeo.Features, myfeature)
  82.     }
  83.     DB.Delete(&att)
  84.     //照片处理
  86.     //删除原图形
  87.     if len(Way.TempGeo) >= 1 {
  88.         DB.Delete(&Way.TempGeo)
  89.     } else {
  90.         DB.Delete(&Way.TempLayer)
  91.     }
  92.     c.JSON(http.StatusOK, NewGeo)
  93. }

分割效果展示：

分割

二、面融合

面融合主要逻辑是需要提前判断两个面是否符合能够融合的条件，比如是否存在共边，是否空间存在重叠，所以需要提前使用ST_Intersects和ST_Touches进行判断。前端代码则需要写好交互逻辑，比如合并需要选择一个要素作为主要属性。

  1. // 图斑合并
  2. type DissolverType struct {
  3.     ZD       []string `json:"ZD"`
  4.     MainTBID string   `json:"MainTBID"`
  5. }
  7. func (uc *UserController) DissolverGeo(c *gin.Context) {
  8.     var jsonData DissolverType
  9.     c.BindJSON(&jsonData)
  10.     db := models.DB
  11.     var Properties map[string]interface{}
  12.     var NewGeo geojson.FeatureCollection
  13.     var t string
  14.     var geolist []string
  15.     var zds []*geojson.FeatureCollection
  16.     for _, tt := range jsonData.ZD {
  17.         zds = append(zds, GetSingleGeo(tt))
  18.     }
  19.     var DelID []string
  20.     for _, features := range zds {
  21.         geo := Transformer.GetGeometryString(features.Features[0])
  22.         t = features.Features[0].Type
  23.         if features.Features[0].Properties["TBID"] == jsonData.MainTBID {
  24.             Properties = features.Features[0].Properties
  25.         } else {
  26.             DelID = append(DelID, features.Features[0].Properties["TBID"].(string))
  28.         }
  29.         geolist = append(geolist, geo)
  30.     }
  31.     var sqlgeo string
  32.     var geom []string
  33.     var geom1 []string
  34.     for index, item := range geolist {
  35.         sql1 := fmt.Sprintf("%s AS ( SELECT ST_GeomFromGeoJSON('%s') AS geom),", "geo"+strconv.Itoa(index), item)
  36.         sqlgeo = sqlgeo + sql1
  37.         geom = append(geom, "geo"+strconv.Itoa(index)+".geom")
  38.         geom1 = append(geom1, "geo"+strconv.Itoa(index))
  39.     }
  40.     result1 := strings.Join(geom, ",")
  41.     result2 := strings.Join(geom1, ",")
  42.     sql := fmt.Sprintf("WITH %s is_adjacent AS ( SELECT ST_Intersects(%s) AS intersects , ST_Touches(%s) AS touches FROM %s) SELECT  CASE  WHEN intersects OR touches THEN ST_AsGeoJSON(ST_Union(%s)) ELSE ST_AsGeoJSON(ST_GeomFromGeoJSON('{\"type\": \"GeometryCollection\", \"geometries\": []}')) END AS geojson FROM %s,is_adjacent;", sqlgeo, result1, result1, result2, result1, result2)
  43.     var geomData Transformer.GeometryData
  44.     err := db.Raw(sql).Scan(&geomData)
  45.     if err.Error != nil {
  46.         c.String(http.StatusBadRequest, "err")
  47.         return
  48.     }
  50.     var feature struct {
  51.         Geometry   map[string]interface{} `json:"geometry"`
  52.         Properties map[string]interface{} `json:"properties"`
  53.         Type       string                 `json:"type"`
  54.     }
  55.     feature.Properties = Properties
  56.     feature.Type = t
  57.     json.Unmarshal(geomData.GeoJSON, &feature.Geometry)
  59.     if feature.Geometry["geometries"] != nil {
  60.         if len(feature.Geometry["geometries"].([]interface{})) == 0 {
  61.             c.String(http.StatusBadRequest, "err")
  62.             return
  63.         }
  64.     }
  66.     data2, _ := json.Marshal(feature)
  68.     var myfeature *geojson.Feature
  69.     json.Unmarshal(data2, &myfeature)
  70.     myfeature.ID = jsonData.MainTBID
  71.     NewGeo.Features = append(NewGeo.Features, myfeature)
  73.     geoJSONData, _ := json.MarshalIndent(NewGeo, "", "  ")
  74.     var templayer []models.TempLayer
  75.     db.Where("tb_id = ?", jsonData.MainTBID).Find(&templayer)
  76.     if len(templayer) >= 1 {
  77.         templayer[0].Geojson = geoJSONData
  78.         db.Save(&templayer)
  79.     } else {
  80.         var templayer2 models.TempGeo
  81.         db.Where("tb_id = ?", jsonData.MainTBID).Find(&templayer2)
  82.         templayer2.Geojson = geoJSONData
  83.         db.Save(&templayer2)
  84.     }
  85.     db.Where("tb_id IN (?)", DelID).Delete(&models.TempLayer{})
  86.     db.Where("tb_id IN (?)", DelID).Delete(&models.TempGeo{})
  87.     db.Where("tb_id IN (?)", DelID).Delete(&models.TempLayerAttribute{})
  88.     c.JSON(http.StatusOK, NewGeo)
  89. }

融合效果：

合并

三、捕捉

捕捉的实现需要实现几个逻辑，第一个就是判断当前需要捕捉的图层，第二个是判断需要捕捉的对象的几何类型（点、线、面），第三个是需要判断捕捉的对象是矢量瓦片，还是geojson。代码如下，这里进行了6种情况的的判断并返回捕捉的点：

  1. // 图形捕捉
  2. func (uc *UserController) Capture(c *gin.Context) {
  3.     var jsonData CaptureType
  4.     c.BindJSON(&jsonData)
  5.     DB := models.DB
  7.     Templarers := jsonData.TempLayer
  8.     //临时图层同时存在
  9.     if len(Templarers) != 0 && jsonData.Layer != "" {
  10.         var sql string
  11.         geojsons := GetTempLayers(Templarers)
  12.         //点线面分离
  13.         var PolygonJson []*geojson.Feature
  14.         var LineJson []*geojson.Feature
  15.         var PointJson []*geojson.Feature
  16.         for _, item := range geojsons {
  17.             switch item.Geometry.GeoJSONType() {
  18.             case "Polygon":
  19.                 PolygonJson = append(PolygonJson, item)
  20.             case "LineString":
  21.                 LineJson = append(LineJson, item)
  22.             case "Point":
  23.                 PointJson = append(PointJson, item)
  24.             }
  25.         }
  26.         //面数据捕捉
  27.         if len(PolygonJson) != 0 {
  28.             geo := Transformer.GetFeatureString(PolygonJson)
  29.             sql = fmt.Sprintf(`
  30. WITH input_point AS (
  31.     SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  32. ),
  33. geojson_data AS (
  34.     SELECT 
  35.         jsonb_array_elements('%s'::jsonb) AS feature
  36. ),
  37. nearest_polygon AS (
  38.     SELECT 
  39.         ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326) AS poly_geom
  40.     FROM 
  41.         geojson_data, input_point AS input
  42.     WHERE 
  43.         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) < 0.0005 
  44.     ORDER BY 
  45.         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) 
  46.     LIMIT 1
  47. ),
  48. line_geom AS (
  49.     SELECT 
  50.         ST_Boundary(poly_geom) AS line_geom
  51.     FROM 
  52.         nearest_polygon
  53. )
  54. SELECT 
  55.     ST_AsGeoJSON(ST_ClosestPoint(line_geom.line_geom, input.geom)) AS geojson,
  56.     ST_Distance(input.geom, ST_ClosestPoint(line_geom.line_geom, input.geom))::float AS distance
  57. FROM 
  58.     input_point AS input, line_geom;
  60.             `, jsonData.Point[0], jsonData.Point[1], geo)
  61.         }
  62.         //线数据捕捉
  63.         if len(LineJson) != 0 {
  64.             geo := Transformer.GetFeatureString(LineJson)
  65.             sql = fmt.Sprintf(`
  66.                 WITH input_point AS (
  67.                     SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  68.                 ),
  69.                 geojson_data AS (
  70.                     SELECT 
  71.                         jsonb_array_elements('%s'::jsonb) AS feature
  72.                 ),
  73.                 nearest_line AS (
  74.                     SELECT 
  75.                         ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326) AS line_geom
  76.                     FROM 
  77.                         geojson_data, input_point AS input
  78.                     WHERE 
  79.                         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) < 0.0005 
  80.                     ORDER BY 
  81.                         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) 
  82.                     LIMIT 1
  83.                 )
  84.                 SELECT 
  85.                     ST_AsGeoJSON(ST_ClosestPoint(line_geom, input.geom)) AS geojson,
  86.                     ST_Distance(input.geom, ST_ClosestPoint(line_geom, input.geom))::float AS distance
  87.                 FROM 
  88.                     input_point AS input, nearest_line;
  89.             `, jsonData.Point[0], jsonData.Point[1], geo)
  90.         }
  91.         //点数据捕捉
  92.         if len(PointJson) != 0 {
  93.             geo := Transformer.GetFeatureString(PointJson)
  94.             sql = fmt.Sprintf(`
  95.                 WITH input_point AS (
  96.                     SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  97.                 ),
  98.                 geojson_data AS (
  99.                     SELECT 
  100.                         jsonb_array_elements('%s'::jsonb) AS feature
  101.                 ),
  102.                 nearest_point AS (
  103.                     SELECT 
  104.                         ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326) AS point_geom
  105.                     FROM 
  106.                         geojson_data, input_point AS input
  107.                     WHERE 
  108.                         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) < 0.0005 
  109.                     ORDER BY 
  110.                         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) 
  111.                     LIMIT 1
  112.                 )
  113.                 SELECT 
  114.                     ST_AsGeoJSON(point_geom) AS geojson,
  115.                     ST_Distance(input.geom, point_geom)::float AS distance
  116.                 FROM 
  117.                     input_point AS input, nearest_point;
  118.             `, jsonData.Point[0], jsonData.Point[1], geo)
  119.         }
  120.         var geomData CaptureData
  121.         err := DB.Raw(sql).Scan(&geomData)
  122.         if err.Error != nil {
  123.             c.String(http.StatusBadRequest, "err")
  124.             return
  125.         }
  126.         var feature struct {
  127.             Geometry GeometryPoint `json:"geometry"`
  128.         }
  129.         json.Unmarshal(geomData.GeoJSON, &feature.Geometry)
  130.         if geomData.Distance <= 0.00015 && len(feature.Geometry.Coordinates) != 0 {
  131.             c.JSON(http.StatusOK, feature.Geometry.Coordinates)
  132.         } else {
  133.             layer := jsonData.Layer
  134.             var schema []models.MySchema
  135.             DB.Where("en = ?", layer).Find(&schema)
  136.             if len(schema) >= 1 {
  137.                 switch schema[0].Type {
  138.                 case "polygon":
  139.                     sql = fmt.Sprintf(`
  140.             WITH input_point AS (
  141.                 SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  142.             ),
  143.             nearest_polygon AS (
  144.                 SELECT 
  145.                     %s.geom AS poly_geom
  146.                 FROM 
  147.                     %s, input_point AS input
  148.                 WHERE 
  149.                     ST_Distance(input.geom, %s.geom) < 0.0005  
  150.                 ORDER BY 
  151.                     ST_Distance(input.geom, %s.geom) 
  152.                 LIMIT 1
  153.             ),
  154.             line_geom AS (
  155.                 SELECT 
  156.                     ST_Boundary(poly_geom) AS line_geom
  157.                 FROM 
  158.                     nearest_polygon
  159.             )
  160.             SELECT 
  161.                 ST_AsGeoJSON(ST_ClosestPoint(line_geom.line_geom, input.geom)) AS geojson,
  162.                 ST_Distance(input.geom, ST_ClosestPoint(line_geom.line_geom, input.geom))::float AS distance
  163.             FROM 
  164.                 input_point AS input, line_geom;
  165.             `, jsonData.Point[0], jsonData.Point[1], jsonData.Layer, jsonData.Layer, jsonData.Layer, jsonData.Layer)
  166.                 case "line":
  167.                     sql = fmt.Sprintf(`
  168.             WITH input_point AS (
  169.                 SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  170.             ),
  171.             closest_line AS (
  172.                 SELECT 
  173.                     %s.geom AS line_geom
  174.                 FROM 
  175.                     %s, input_point AS input
  176.                 WHERE 
  177.                     ST_Distance(input.geom, %s.geom) < 0.0005  
  178.                 ORDER BY 
  179.                     ST_Distance(input.geom, %s.geom) 
  180.                 LIMIT 1
  181.             )
  182.             SELECT 
  183.                 ST_AsGeoJSON(ST_ClosestPoint(closest_line.line_geom, input.geom)) AS geojson,
  184.                 ST_Distance(input.geom, ST_ClosestPoint(closest_line.line_geom, input.geom))::float AS distance
  185.             FROM 
  186.                 input_point AS input, closest_line;
  187.             `, jsonData.Point[0], jsonData.Point[1], jsonData.Layer, jsonData.Layer, jsonData.Layer, jsonData.Layer)
  188.                 case "point":
  189.                     sql = fmt.Sprintf(`
  190.             WITH input_point AS (
  191.                 SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  192.             ),
  193.             nearest_point AS (
  194.                 SELECT 
  195.                     %s.geom AS nearest_geom
  196.                 FROM 
  197.                     %s, input_point AS input
  198.                 ORDER BY 
  199.                     ST_Distance(input.geom, %s.geom) 
  200.                 LIMIT 1
  201.             )
  202.             SELECT 
  203.                 ST_AsGeoJSON(nearest_geom) AS geojson,
  204.                 ST_Distance(input.geom, nearest_geom)::float AS distance
  205.             FROM 
  206.                 input_point AS input, nearest_point;
  207.             `, jsonData.Point[0], jsonData.Point[1], jsonData.Layer, jsonData.Layer, jsonData.Layer)
  208.                 }
  209.             }
  210.             err := DB.Raw(sql).Scan(&geomData)
  211.             if err.Error != nil {
  212.                 c.String(http.StatusBadRequest, "err")
  213.                 return
  214.             }
  215.             json.Unmarshal(geomData.GeoJSON, &feature.Geometry)
  216.             if geomData.Distance <= 0.00015 {
  217.                 c.JSON(http.StatusOK, feature.Geometry.Coordinates)
  218.             } else {
  219.                 c.String(http.StatusBadRequest, "err")
  220.             }
  221.         }
  223.     } else {
  224.         var sql string
  225.         if len(Templarers) != 0 && jsonData.Layer == "" {
  226.             geojsons := GetTempLayers(Templarers)
  227.             //点线面分离
  228.             var PolygonJson []*geojson.Feature
  229.             var LineJson []*geojson.Feature
  230.             var PointJson []*geojson.Feature
  231.             for _, item := range geojsons {
  232.                 switch item.Geometry.GeoJSONType() {
  233.                 case "Polygon":
  234.                     PolygonJson = append(PolygonJson, item)
  235.                 case "LineString":
  236.                     LineJson = append(LineJson, item)
  237.                 case "Point":
  238.                     PointJson = append(PointJson, item)
  239.                 }
  240.             }
  241.             //面数据捕捉
  242.             if len(PolygonJson) != 0 {
  243.                 geo := Transformer.GetFeatureString(PolygonJson)
  244.                 sql = fmt.Sprintf(`
  245. WITH input_point AS (
  246.     SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  247. ),
  248. geojson_data AS (
  249.     SELECT 
  250.         jsonb_array_elements('%s'::jsonb) AS feature
  251. ),
  252. nearest_polygon AS (
  253.     SELECT 
  254.         ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326) AS poly_geom
  255.     FROM 
  256.         geojson_data, input_point AS input
  257.     WHERE 
  258.         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) < 0.0005 
  259.     ORDER BY 
  260.         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) 
  261.     LIMIT 1
  262. ),
  263. line_geom AS (
  264.     SELECT 
  265.         ST_Boundary(poly_geom) AS line_geom
  266.     FROM 
  267.         nearest_polygon
  268. )
  269. SELECT 
  270.     ST_AsGeoJSON(ST_ClosestPoint(line_geom.line_geom, input.geom)) AS geojson,
  271.     ST_Distance(input.geom, ST_ClosestPoint(line_geom.line_geom, input.geom))::float AS distance
  272. FROM 
  273.     input_point AS input, line_geom;
  275.             `, jsonData.Point[0], jsonData.Point[1], geo)
  276.             }
  277.             //线数据捕捉
  278.             if len(LineJson) != 0 {
  279.                 geo := Transformer.GetFeatureString(LineJson)
  280.                 sql = fmt.Sprintf(`
  281.                 WITH input_point AS (
  282.                     SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  283.                 ),
  284.                 geojson_data AS (
  285.                     SELECT 
  286.                         jsonb_array_elements('%s'::jsonb) AS feature
  287.                 ),
  288.                 nearest_line AS (
  289.                     SELECT 
  290.                         ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326) AS line_geom
  291.                     FROM 
  292.                         geojson_data, input_point AS input
  293.                     WHERE 
  294.                         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) < 0.0005 
  295.                     ORDER BY 
  296.                         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) 
  297.                     LIMIT 1
  298.                 )
  299.                 SELECT 
  300.                     ST_AsGeoJSON(ST_ClosestPoint(line_geom, input.geom)) AS geojson,
  301.                     ST_Distance(input.geom, ST_ClosestPoint(line_geom, input.geom))::float AS distance
  302.                 FROM 
  303.                     input_point AS input, nearest_line;
  304.             `, jsonData.Point[0], jsonData.Point[1], geo)
  305.             }
  306.             //点数据捕捉
  307.             if len(PointJson) != 0 {
  308.                 geo := Transformer.GetFeatureString(PointJson)
  309.                 sql = fmt.Sprintf(`
  310.                 WITH input_point AS (
  311.                     SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  312.                 ),
  313.                 geojson_data AS (
  314.                     SELECT 
  315.                         jsonb_array_elements('%s'::jsonb) AS feature
  316.                 ),
  317.                 nearest_point AS (
  318.                     SELECT 
  319.                         ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326) AS point_geom
  320.                     FROM 
  321.                         geojson_data, input_point AS input
  322.                     WHERE 
  323.                         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) < 0.0005 
  324.                     ORDER BY 
  325.                         ST_Distance(input.geom, ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326)) 
  326.                     LIMIT 1
  327.                 )
  328.                 SELECT 
  329.                     ST_AsGeoJSON(point_geom) AS geojson,
  330.                     ST_Distance(input.geom, point_geom)::float AS distance
  331.                 FROM 
  332.                     input_point AS input, nearest_point;
  333.             `, jsonData.Point[0], jsonData.Point[1], geo)
  334.             }
  335.         } else if len(Templarers) == 0 && jsonData.Layer != "" {
  336.             layer := jsonData.Layer
  337.             var schema []models.MySchema
  338.             DB.Where("en = ?", layer).Find(&schema)
  339.             if len(schema) >= 1 {
  340.                 switch schema[0].Type {
  341.                 case "polygon":
  342.                     sql = fmt.Sprintf(`
  343.             WITH input_point AS (
  344.                 SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  345.             ),
  346.             nearest_polygon AS (
  347.                 SELECT 
  348.                     %s.geom AS poly_geom
  349.                 FROM 
  350.                     %s, input_point AS input
  351.                 WHERE 
  352.                     ST_Distance(input.geom, %s.geom) < 0.0005  
  353.                 ORDER BY 
  354.                     ST_Distance(input.geom, %s.geom) 
  355.                 LIMIT 1
  356.             ),
  357.             line_geom AS (
  358.                 SELECT 
  359.                     ST_Boundary(poly_geom) AS line_geom
  360.                 FROM 
  361.                     nearest_polygon
  362.             )
  363.             SELECT 
  364.                 ST_AsGeoJSON(ST_ClosestPoint(line_geom.line_geom, input.geom)) AS geojson,
  365.                 ST_Distance(input.geom, ST_ClosestPoint(line_geom.line_geom, input.geom))::float AS distance
  366.             FROM 
  367.                 input_point AS input, line_geom;
  368.             `, jsonData.Point[0], jsonData.Point[1], jsonData.Layer, jsonData.Layer, jsonData.Layer, jsonData.Layer)
  369.                 case "line":
  370.                     sql = fmt.Sprintf(`
  371.             WITH input_point AS (
  372.                 SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  373.             ),
  374.             closest_line AS (
  375.                 SELECT 
  376.                     %s.geom AS line_geom
  377.                 FROM 
  378.                     %s, input_point AS input
  379.                 WHERE 
  380.                     ST_Distance(input.geom, %s.geom) < 0.0005  
  381.                 ORDER BY 
  382.                     ST_Distance(input.geom, %s.geom) 
  383.                 LIMIT 1
  384.             )
  385.             SELECT 
  386.                 ST_AsGeoJSON(ST_ClosestPoint(closest_line.line_geom, input.geom)) AS geojson,
  387.                 ST_Distance(input.geom, ST_ClosestPoint(closest_line.line_geom, input.geom))::float AS distance
  388.             FROM 
  389.                 input_point AS input, closest_line;
  390.             `, jsonData.Point[0], jsonData.Point[1], jsonData.Layer, jsonData.Layer, jsonData.Layer, jsonData.Layer)
  391.                 case "point":
  392.                     sql = fmt.Sprintf(`
  393.             WITH input_point AS (
  394.                 SELECT ST_SetSRID(ST_MakePoint(%f, %f), 4326) AS geom
  395.             ),
  396.             nearest_point AS (
  397.                 SELECT 
  398.                     %s.geom AS nearest_geom
  399.                 FROM 
  400.                     %s, input_point AS input
  401.                 ORDER BY 
  402.                     ST_Distance(input.geom, %s.geom) 
  403.                 LIMIT 1
  404.             )
  405.             SELECT 
  406.                 ST_AsGeoJSON(nearest_geom) AS geojson,
  407.                 ST_Distance(input.geom, nearest_geom)::float AS distance
  408.             FROM 
  409.                 input_point AS input, nearest_point;
  410.             `, jsonData.Point[0], jsonData.Point[1], jsonData.Layer, jsonData.Layer, jsonData.Layer)
  411.                 }
  412.             }
  413.         }
  414.         var geomData CaptureData
  415.         err := DB.Raw(sql).Scan(&geomData)
  416.         if err.Error != nil {
  417.             c.String(http.StatusBadRequest, "err")
  418.             return
  419.         }
  420.         var feature struct {
  421.             Geometry GeometryPoint `json:"geometry"`
  422.         }
  423.         json.Unmarshal(geomData.GeoJSON, &feature.Geometry)
  424.         if geomData.Distance <= 0.00015 {
  425.             c.JSON(http.StatusOK, feature.Geometry.Coordinates)
  426.         } else {
  427.             c.String(http.StatusBadRequest, "err")
  428.         }
  429.     }
  431. }

捕捉效果：

捕捉

四、追踪构面

追踪构面的实现逻辑可以说是最为复杂的，实现逻辑主要是根据绘制的线段和当前已经加载好了的图层进行空间分析，查询到最为合适的边界，并将该边界与绘制线进行构面。分解下来的逻辑大概是：

1、因为容差因素，需要将传入的线按照节点顺序进行两端延长，保证线会超过图层线并形成交点。

2、将延长线与几何图层进行空间分析，将与线有交集的几何提取出来

3、如果几何是面，需要转换为线要素

4、将输入线与相交线进行节点打散，并重新构造面

5、再将输入线与重新构造好的面进行线线叠加分析，找出重叠率最高的几何，并返回该几何

代码如下：

  1. type AutoData struct {
  2.     Line      geojson.FeatureCollection `json:"Line"`
  3.     Layer     string
  4.     TempLayer []string
  5. }
  7. func (uc *UserController) AutoPolygon(c *gin.Context) {
  8.     var jsonData AutoData
  9.     c.BindJSON(&jsonData)
  10.     DB := models.DB
  11.     var sql string
  12.     line := Transformer.GetGeometryString(jsonData.Line.Features[0])
  13.     Templarers := jsonData.TempLayer
  14.     if len(Templarers) != 0 {
  15.         geojsons := GetTempLayers(Templarers)
  16.         //点线面分离
  17.         var PolygonJson []*geojson.Feature
  18.         var LineJson []*geojson.Feature
  19.         for _, item := range geojsons {
  20.             switch item.Geometry.GeoJSONType() {
  21.             case "Polygon":
  22.                 PolygonJson = append(PolygonJson, item)
  23.             case "LineString":
  24.                 LineJson = append(LineJson, item)
  25.             }
  26.         }
  27.         //面数据捕捉
  28.         if len(PolygonJson) != 0 {
  29.             geo := Transformer.GetFeatureString(PolygonJson)
  30.             sql = fmt.Sprintf(`
  31.                     WITH input_linefrist AS (
  32.                         SELECT ST_SetSRID(ST_GeomFromGeoJSON('%s'), 4326) AS geom
  33.                     ),
  34.                     input_line AS (
  35.                         SELECT
  36.                         ST_LineMerge(ST_Union( ARRAY[
  37.                                 ST_MakeLine(ST_StartPoint(geom),ST_Project(ST_StartPoint(geom), 0.000001, ST_Azimuth(ST_PointN(geom,2),ST_StartPoint(geom)))::geometry),
  38.                                 geom,
  39.                                 ST_MakeLine(ST_EndPoint(geom),ST_Project(ST_EndPoint(geom), 0.000001, ST_Azimuth(ST_PointN(geom,ST_NumPoints(geom) - 1),ST_EndPoint(geom)))::geometry)
  40.                              ])) AS geom
  41.                         FROM input_linefrist
  42.                     ),
  43.                     intersecting_areas AS (
  44.                         SELECT ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326) AS geom
  45.                         FROM jsonb_array_elements('%s'::jsonb) AS feature
  46.                         WHERE ST_Intersects(ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326), (SELECT geom FROM input_line))
  47.                     ),
  48.                     boundary_lines AS (
  49.                         SELECT ST_Boundary(geom) AS geom
  50.                         FROM intersecting_areas
  51.                     ),
  52.                     closed_geometries AS (
  53.                         SELECT ST_Union(ST_Collect((SELECT geom FROM input_line), boundary_lines.geom)) AS lines
  54.                         FROM boundary_lines
  55.                     ),
  56.                     newpolygons AS (
  57.                         SELECT ST_Polygonize(lines) AS polygon_geoms
  58.                         FROM closed_geometries
  59.                     ),
  60.                     boundary_lines2 AS (
  61.                         SELECT (ST_Dump(ST_Boundary(polygon_geoms))).geom AS geom 
  62.                         FROM newpolygons
  63.                     ),
  64.                     intersecting_lines AS (
  65.                         SELECT ST_Intersection(input_line.geom, boundary_lines2.geom,0.0000001) AS geom, boundary_lines2.geom AS boundary_geom
  66.                         FROM input_line, boundary_lines2
  67.                     ),
  68.                     max_overlap AS (
  69.                         SELECT 
  70.                             boundary_geom, 
  71.                             ST_Length(geom)/ST_Length(boundary_geom) AS overlap_length
  72.                         FROM intersecting_lines
  73.                         ORDER BY overlap_length DESC
  74.                         LIMIT 1
  75.                     )
  76.                     SELECT ST_AsGeoJSON(ST_MakePolygon(boundary_geom)) AS geojson,
  77.                     overlap_length::float AS lenth
  78.                     FROM max_overlap
  79.             `, line, geo)
  80.         }
  81.         if len(LineJson) != 0 {
  82.             geo := Transformer.GetFeatureString(LineJson)
  83.             sql = fmt.Sprintf(`
  84.                     WITH input_linefrist AS (
  85.                         SELECT ST_SetSRID(ST_GeomFromGeoJSON('%s'), 4326) AS geom
  86.                     ),
  87.                     input_line AS (
  88.                         SELECT
  89.                         ST_LineMerge(ST_Union( ARRAY[
  90.                                 ST_MakeLine(ST_StartPoint(geom),ST_Project(ST_StartPoint(geom), 0.000001, ST_Azimuth(ST_PointN(geom,2),ST_StartPoint(geom)))::geometry),
  91.                                 geom,
  92.                                 ST_MakeLine(ST_EndPoint(geom),ST_Project(ST_EndPoint(geom), 0.000001, ST_Azimuth(ST_PointN(geom,ST_NumPoints(geom) - 1),ST_EndPoint(geom)))::geometry)
  93.                              ])) AS geom
  94.                         FROM input_linefrist
  95.                     ),
  96.                     intersecting_areas AS (
  97.                         SELECT ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326) AS geom
  98.                         FROM jsonb_array_elements('%s'::jsonb) AS feature
  99.                         WHERE ST_Intersects(ST_SetSRID(ST_GeomFromGeoJSON(feature->'geometry'::text), 4326), (SELECT geom FROM input_line))
  100.                     ),
  101.                     boundary_lines AS (
  102.                         SELECT geom AS geom
  103.                         FROM intersecting_areas
  104.                     ),
  105.                     closed_geometries AS (
  106.                         SELECT ST_Union(ST_Collect((SELECT geom FROM input_line), boundary_lines.geom)) AS lines
  107.                         FROM boundary_lines
  108.                     ),
  109.                     newpolygons AS (
  110.                         SELECT ST_Polygonize(lines) AS polygon_geoms
  111.                         FROM closed_geometries
  112.                     ),
  113.                     boundary_lines2 AS (
  114.                         SELECT (ST_Dump(ST_Boundary(polygon_geoms))).geom AS geom 
  115.                         FROM newpolygons
  116.                     ),
  117.                     intersecting_lines AS (
  118.                         SELECT ST_Intersection(input_line.geom, boundary_lines2.geom,0.0000001) AS geom, boundary_lines2.geom AS boundary_geom
  119.                         FROM input_line, boundary_lines2
  120.                     ),
  121.                     max_overlap AS (
  122.                         SELECT 
  123.                             boundary_geom, 
  124.                             ST_Length(geom)/ST_Length(boundary_geom) AS overlap_length
  125.                         FROM intersecting_lines
  126.                         ORDER BY overlap_length DESC
  127.                         LIMIT 1
  128.                     )
  129.                     SELECT ST_AsGeoJSON(ST_MakePolygon(boundary_geom)) AS geojson,
  130.                     overlap_length::float AS lenth
  131.                     FROM max_overlap
  132.             `, line, geo)
  133.         }
  134.     } else {
  135.         layer := jsonData.Layer
  136.         var schema []models.MySchema
  137.         DB.Where("en = ?", layer).Find(&schema)
  138.         if len(schema) >= 1 {
  139.             switch schema[0].Type {
  140.             case "polygon":
  141.                 sql = fmt.Sprintf(`
  142.                     WITH input_linefrist AS (
  143.                         SELECT ST_SetSRID(ST_GeomFromGeoJSON('%s'), 4326) AS geom
  144.                     ),
  145.                     input_line AS (
  146.                         SELECT
  147.                         ST_LineMerge(ST_Union( ARRAY[
  148.                                 ST_MakeLine(ST_StartPoint(geom),ST_Project(ST_StartPoint(geom), 0.000001, ST_Azimuth(ST_PointN(geom,2),ST_StartPoint(geom)))::geometry),
  149.                                 geom,
  150.                                 ST_MakeLine(ST_EndPoint(geom),ST_Project(ST_EndPoint(geom), 0.000001, ST_Azimuth(ST_PointN(geom,ST_NumPoints(geom) - 1),ST_EndPoint(geom)))::geometry)
  151.                              ])) AS geom
  152.                         FROM input_linefrist
  153.                     ),
  154.                     intersecting_areas AS (
  155.                         SELECT *
  156.                         FROM %s
  157.                         WHERE ST_Intersects(%s.geom, (SELECT geom FROM input_line))
  158.                     ),
  159.                     boundary_lines AS (
  160.                         SELECT ST_Boundary(geom) AS geom
  161.                         FROM intersecting_areas
  162.                     ),
  163.                     closed_geometries AS (
  164.                         SELECT ST_Union(ST_Collect((SELECT geom FROM input_line), boundary_lines.geom)) AS lines
  165.                         FROM boundary_lines
  166.                     ),
  167.                     newpolygons AS (
  168.                         SELECT ST_Polygonize(lines) AS polygon_geoms
  169.                         FROM closed_geometries
  170.                     ),
  171.                     boundary_lines2 AS (
  172.                         SELECT (ST_Dump(ST_Boundary(polygon_geoms))).geom AS geom 
  173.                         FROM newpolygons
  174.                     ),
  175.                     intersecting_lines AS (
  176.                         SELECT ST_Intersection(input_line.geom, boundary_lines2.geom,0.0000001) AS geom, boundary_lines2.geom AS boundary_geom
  177.                         FROM input_line, boundary_lines2
  178.                     ),
  179.                     max_overlap AS (
  180.                         SELECT 
  181.                             boundary_geom, 
  182.                             ST_Length(geom)/ST_Length(boundary_geom) AS overlap_length
  183.                         FROM intersecting_lines
  184.                         ORDER BY overlap_length DESC
  185.                         LIMIT 1
  186.                     )
  187.                     SELECT ST_AsGeoJSON(ST_MakePolygon(boundary_geom)) AS geojson,
  188.                     overlap_length::float AS lenth
  189.                     FROM max_overlap
  190.                 `, line, jsonData.Layer, jsonData.Layer)
  191.             case "line":
  192.                 sql = fmt.Sprintf(`
  193.                     WITH input_linefrist AS (
  194.                         SELECT ST_SetSRID(ST_GeomFromGeoJSON('%s'), 4326) AS geom
  195.                     ),
  196.                     input_line AS (
  197.                         SELECT
  198.                         ST_LineMerge(ST_Union( ARRAY[
  199.                                 ST_MakeLine(ST_StartPoint(geom),ST_Project(ST_StartPoint(geom), 0.000001, ST_Azimuth(ST_PointN(geom,2),ST_StartPoint(geom)))::geometry),
  200.                                 geom,
  201.                                 ST_MakeLine(ST_EndPoint(geom),ST_Project(ST_EndPoint(geom), 0.000001, ST_Azimuth(ST_PointN(geom,ST_NumPoints(geom) - 1),ST_EndPoint(geom)))::geometry)
  202.                              ])) AS geom
  203.                         FROM input_linefrist
  204.                     ),
  205.                     intersecting_areas AS (
  206.                         SELECT *
  207.                         FROM %s
  208.                         WHERE ST_Intersects(%s.geom, (SELECT geom FROM input_line))
  209.                     ),
  210.                     boundary_lines AS (
  211.                         SELECT geom AS geom
  212.                         FROM intersecting_areas
  213.                     ),
  214.                     closed_geometries AS (
  215.                         SELECT ST_Union(ST_Collect((SELECT geom FROM input_line), boundary_lines.geom)) AS lines
  216.                         FROM boundary_lines
  217.                     ),
  218.                     newpolygons AS (
  219.                         SELECT ST_Polygonize(lines) AS polygon_geoms
  220.                         FROM closed_geometries
  221.                     ),
  222.                     boundary_lines2 AS (
  223.                         SELECT (ST_Dump(ST_Boundary(polygon_geoms))).geom AS geom 
  224.                         FROM newpolygons
  225.                     ),
  226.                     intersecting_lines AS (
  227.                         SELECT ST_Intersection(input_line.geom, boundary_lines2.geom,0.0000001) AS geom, boundary_lines2.geom AS boundary_geom
  228.                         FROM input_line, boundary_lines2
  229.                         WHERE ST_Intersects(input_line.geom, boundary_lines2.geom)
  230.                     ),
  231.                     max_overlap AS (
  232.                         SELECT 
  233.                             boundary_geom, 
  234.                             ST_Length(geom)/ST_Length(boundary_geom) AS overlap_length
  235.                         FROM intersecting_lines
  236.                         ORDER BY overlap_length DESC
  237.                         LIMIT 1
  238.                     )
  239.                     SELECT ST_AsGeoJSON(ST_MakePolygon(boundary_geom)) AS geojson,
  240.                     overlap_length::float AS lenth
  241.                     FROM max_overlap
  242.             `, line, jsonData.Layer, jsonData.Layer)
  243.             }
  244.         }
  245.     }
  247.     var geomData Transformer.GeometryData
  248.     err := DB.Raw(sql).Scan(&geomData)
  250.     if err.Error != nil {
  251.         c.String(http.StatusBadRequest, "err")
  252.         return
  253.     }
  255.     var feature struct {
  256.         Geometry   map[string]interface{} `json:"geometry"`
  257.         Properties map[string]interface{} `json:"properties"`
  258.         Type       string                 `json:"type"`
  259.     }
  260.     feature.Type = "Feature"
  261.     json.Unmarshal(geomData.GeoJSON, &feature.Geometry)
  262.     feature.Properties = make(map[string]interface{})
  263.     feature.Properties["name"] = ""
  264.     var NewGeo geojson.FeatureCollection
  265.     data2, _ := json.Marshal(feature)
  266.     var myfeature *geojson.Feature
  267.     aa := json.Unmarshal(data2, &myfeature)
  268.     if aa != nil {
  269.         fmt.Println(aa.Error())
  270.     }
  271.     NewGeo.Features = append(NewGeo.Features, myfeature)
  272.     c.JSON(http.StatusOK, NewGeo)
  273. }

追踪构面效果如下：

追踪

总结

这是我团队的移动端离线GIS产品《新源地图》的绘制模块的开发日志，该软件采用前后端部署一体式方案，将go语言开发的后端和postgis在安卓设备上进行编译。实现了在移动设备上能进行GIS分析、绘制功能。并通过动态瓦片技术实现了离线毫秒级加载千万级的矢量数据。如果对该产品有兴趣的同学可以在后台联系我。

标签： golang postgresql vue.js
本文转载自: https://blog.csdn.net/weixin_57664381/article/details/143287187
版权归原作者 努力的无空 所有， 如有侵权，请联系我们删除。
登录后发布评论

“WebGIS开发之编辑功能（分割、融合、捕捉、追踪）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？