csv2geojson

from osgeo import ogr
import pandas as pd

def extract_single_ring( point_list_str ):
    
    ring_instance = ogr.Geometry(ogr.wkbLinearRing)
    point_list = point_list_str.split(',')      
    count = 0
    first_x = None
    first_y = None
    for item in point_list:
        # 空格分割
        str_list = item.split(' ')
        if(len(str_list) == 2):
            ring_instance.AddPoint_2D(float(str_list[0]), float(str_list[1]))
        else:
            print(str_list[0])
        
        if(count == 0):
            first_x = float(str_list[0])
            first_y = float(str_list[1])
            count = count+1

    ring_instance.AddPoint_2D(first_x, first_y)
    return ring_instance
    
"""
    Now I have a list of ring objects. I want to group these rings by area.
    In one area, one ring at least intersects with another. please use python. 
    finally, I want to get the grouped ring with one list that contains lists of rings.
"""
def group_rings(ogr_ring_list):
    grouped_rings = []
    while(ogr_ring_list):
        current_ring = ogr_ring_list.pop(0)
        group = [current_ring]
        
        i = 0
        while i < len(ogr_ring_list):
            if current_ring.Intersect(ogr_ring_list[i]):
                group.append(ogr_ring_list.pop(i))
            else:
                i +=1
        
        grouped_rings.append(group)
    return grouped_rings

if __name__ == '__main__':
    # Create a GeoJSON driver
    driver = ogr.GetDriverByName("GeoJSON")

    # Create a new GeoJSON data source
    data_source = driver.CreateDataSource("my_geojson_file.geojson")

    # Create a new layer within the data source with a specific geometry type (e.g., Point)
    layer = data_source.CreateLayer("my_layer", geom_type=ogr.wkbUnknown)

    # Define the layer's fields (e.g., name)
    layer.CreateField(ogr.FieldDefn("id", ogr.OFTString))
    layer.CreateField(ogr.FieldDefn("ext_path", ogr.OFTString))
    layer.CreateField(ogr.FieldDefn("pid", ogr.OFTString))
    layer.CreateField(ogr.FieldDefn("deep", ogr.OFTString))
    layer.CreateField(ogr.FieldDefn("name", ogr.OFTString))
    layer.CreateField(ogr.FieldDefn("geo_wkt", ogr.OFTString))


    map = {'id':0,'pid':1,'deep':2,'name':3,'ext_path':4,'geo':5,'polygon':6}
    df = pd.read_csv('ok_geo.csv',encoding='utf-8')

    #### LOOP ####
    for index, row in df.iterrows():  
        
        if(index == 0):         
            continue
        
        geo_wkt_str = None
        
        feature = ogr.Feature(layer.GetLayerDefn())
        id_str = str(row.loc['id'])
         
        feature.SetField("id", id_str)
        feature.SetField("ext_path", str(row.loc['ext_path']) )
        feature.SetField("pid", str(row.iloc[map['pid']]) )
        feature.SetField("deep", str(row.iloc[map['deep']]) )
        feature.SetField("name", str(row.iloc[map['name']]) )
        feature.SetField("geo_wkt",  f"POINT ({row.iloc[map['geo']]})" )
        
        poly_str = row.iloc[map['polygon']]
        center_str = row.iloc[map['geo']]
        
        # 關注POLY邏輯 
        poly_instance = None
        ring_instance = None
        area_type = None
        ring_temp = None
        multi_type = None
        group = None
        
        # 根据区域个数预先处理
        if ';' not in poly_str:
            poly_instance =  ogr.Geometry(ogr.wkbPolygon)
            ring_instance =  ogr.Geometry(ogr.wkbLinearRing)
            area_type =  'single'
        elif poly_str == "EMPTY":
            continue
        else:
            area_type = 'multiple'

        # 获取所有的环
        if( area_type == 'single'):
            # 按照逗号分割字符串
            poly_instance.AddGeometry(extract_single_ring(poly_str))       
        elif (area_type == 'multiple'):
            multi_list = poly_str.split(";")
            ogr_ring_list = []
            for ring_list in multi_list:
                ogr_ring_list.append(extract_single_ring(ring_list))      
            
            # SORT THE LIST BY AREA
            sorted_ogr_ring_list = sorted(ogr_ring_list, key=lambda ring: ring.GetArea(), reverse= True)
            group = group_rings(sorted_ogr_ring_list)
            multi_type = 'hole_poly' if len(group) == 1 else 'multipolygon'
        
        if(multi_type == 'hole_poly'):
            # TODO deal
            poly_instance = ogr.Geometry(ogr.wkbPolygon)
            for item in group[0]:
                poly_instance.AddGeometry(item)
        elif(multi_type == 'multipolygon'):
            # TODO deal
            poly_instance = ogr.Geometry(ogr.wkbMultiPolygon)
            single_poly_inst = ogr.Geometry(ogr.wkbPolygon)
            for poly in group:
                for item in poly:
                    single_poly_inst.AddGeometry(item)
                poly_instance.AddGeometry(single_poly_inst)
    
        feature.SetGeometry(poly_instance)
        layer.CreateFeature(feature) # push back the feature item 
        feature = None  # Clear the feature to reuse it
        
    # Save the changes and close the data source
    data_source = None

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144