优化抽稀

@@ -4,29 +4,51 @@
 #email:         nheweijun@sina.com
 #email:         nheweijun@sina.com
 
 
 
 
-from app.models import Database,db
+from app.models import Database,db,Table,TableVacuate
 
 
 
 
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+import configure
+from osgeo.ogr import DataSource
+from flask import current_app
 class Api(ApiTemplate):
 class Api(ApiTemplate):
     api_name = "删除数据库"
     api_name = "删除数据库"
     def process(self):
     def process(self):
-        res ={}
+        re ={}
+        sys_ds = None
         try:
         try:
     
     
             database = db.session.query(Database).filter_by(guid=self.para.get("guid")).one_or_none()
             database = db.session.query(Database).filter_by(guid=self.para.get("guid")).one_or_none()
+            sys_ds :DataSource= PGUtil.open_pg_data_source(1,configure.SQLALCHEMY_DATABASE_URI)
             if database:
             if database:
+                # 删除table
+                re_tables = Table.query.filter_by(database_guid=database.guid).all()
+                for table in re_tables:
+                    re_tvs = TableVacuate.query.filter_by(table_guid=table.guid).all()
+                    for tv in re_tvs:
+                        db.session.delete(tv)
+                        try:
+                            sys_ds.DeleteLayer(tv.name)
+                        except:
+                            current_app.logger.warning("{}不存在".format(tv.name))
+                    db.session.delete(table)
                 db.session.delete(database)
                 db.session.delete(database)
+
                 db.session.commit()
                 db.session.commit()
-                res["msg"] = "数据库删除成功！"
-                res["result"] = True
+                re["result"] = True
+                re["msg"] = "数据库删除成功！"
             else:
             else:
-                res["msg"] = "数据库不存在!"
-                res["result"] = False
+                re["result"] = False
+                re["msg"] = "数据库不存在！"
         except Exception as e:
         except Exception as e:
             db.session.rollback()
             db.session.rollback()
+            sys_ds.RollbackTransaction()
             raise e
             raise e
-        return res
+        finally:
+            if sys_ds:
+                sys_ds.Destroy()
+        return re
     
     
     
     
     
     

@@ -17,6 +17,7 @@ from app.util.component.PGUtil import PGUtil
 from app.util.component.SQLUtil import SQLUtil
 from app.util.component.SQLUtil import SQLUtil
 from app.util.component.GeometryAdapter import GeometryAdapter
 from app.util.component.GeometryAdapter import GeometryAdapter
 from app.util.component.StructuredPrint import StructurePrint
 from app.util.component.StructuredPrint import StructurePrint
+import configure
 class Api(ApiTemplate):
 class Api(ApiTemplate):
     api_name = "注册数据库"
     api_name = "注册数据库"
     def process(self):
     def process(self):
@@ -57,7 +58,6 @@ class Api(ApiTemplate):
             elif not self.check_space(sqlalchemy_uri):
             elif not self.check_space(sqlalchemy_uri):
                 res["msg"] = "数据不是空间数据库！"
                 res["msg"] = "数据不是空间数据库！"
                 return res
                 return res
-
             else:
             else:
                 this_time = datetime.datetime.now()
                 this_time = datetime.datetime.now()
                 database_guid = uuid.uuid1().__str__()
                 database_guid = uuid.uuid1().__str__()
@@ -96,12 +96,8 @@ class Api(ApiTemplate):
         # 注册空间表
         # 注册空间表
         spatial_table_name,tables = self.register_spatial_table(pg_ds, database, this_time,db_tuple)
         spatial_table_name,tables = self.register_spatial_table(pg_ds, database, this_time,db_tuple)
 
 
-        #注册抽稀表
-        self.regiser_vacuate_table(pg_ds,tables,db_tuple)
-
         #注册普通表
         #注册普通表
         self.register_common_table(this_time,database,spatial_table_name,db_tuple)
         self.register_common_table(this_time,database,spatial_table_name,db_tuple)
-
         pg_ds.Destroy()
         pg_ds.Destroy()
 
 
 
 
@@ -245,11 +241,11 @@ class Api(ApiTemplate):
             if l_name.__contains__("_vacuate_"):
             if l_name.__contains__("_vacuate_"):
 
 
                 # 没有权限的表跳过
                 # 没有权限的表跳过
-                if not PGUtil.check_table_privilege(l_name, "SELECT", db_tuple[0], pg_ds):
-                    StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0], l_name), "warn")
-                    continue
+                # if not PGUtil.check_table_privilege(l_name, "SELECT", db_tuple[0], pg_ds):
+                #     StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0], l_name), "warn")
+                #     continue
 
 
-                base_layer_name=l_name.split("_vacuate_")[0]
+                base_layer_name=l_name.split("_vacuate_")[1]
                 level = l_name.split("_")[-2]
                 level = l_name.split("_")[-2]
                 pixel_distance_str: str ="0"
                 pixel_distance_str: str ="0"
                 try:
                 try:

@@ -15,7 +15,6 @@ import uuid
 from sqlalchemy.orm import Session
 from sqlalchemy.orm import Session
 from app.util.component.SQLUtil import SQLUtil
 from app.util.component.SQLUtil import SQLUtil
 from app.util.component.PGUtil import PGUtil
 from app.util.component.PGUtil import PGUtil
-from app.util.component.ModelVisitor import ModelVisitor
 from app.util.component.StructuredPrint import StructurePrint
 from app.util.component.StructuredPrint import StructurePrint
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.GeometryAdapter import GeometryAdapter
 from app.util.component.GeometryAdapter import GeometryAdapter
@@ -37,8 +36,6 @@ class Api(ApiTemplate):
                 # 初始化task
                 # 初始化task
             task_guid = uuid.uuid1().__str__()
             task_guid = uuid.uuid1().__str__()
 
 
-            # result = self.table_refresh(database)
-
             refresh_process = multiprocessing.Process(target=self.table_refresh,args=(database,task_guid))
             refresh_process = multiprocessing.Process(target=self.table_refresh,args=(database,task_guid))
             refresh_process.start()
             refresh_process.start()
 
 
@@ -67,6 +64,7 @@ class Api(ApiTemplate):
     def table_refresh(self,database,task_guid):
     def table_refresh(self,database,task_guid):
 
 
         pg_ds =None
         pg_ds =None
+        sys_ds =None
         data_session=None
         data_session=None
         result = {}
         result = {}
         sys_session = None
         sys_session = None
@@ -74,7 +72,7 @@ class Api(ApiTemplate):
 
 
         try:
         try:
             sys_session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
             sys_session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
-
+            sys_ds = PGUtil.open_pg_data_source(0,configure.SQLALCHEMY_DATABASE_URI)
 
 
             this_time = datetime.datetime.now()
             this_time = datetime.datetime.now()
             database_guid = database.guid
             database_guid = database.guid
@@ -99,8 +97,6 @@ class Api(ApiTemplate):
             # 空间表处理完毕
             # 空间表处理完毕
             sys_session.commit()
             sys_session.commit()
 
 
-            # 处理抽稀表
-            self.deal_vacuate_table(pg_ds,sys_session, database.guid,db_tuple)
 
 
             # 空间表处理完毕
             # 空间表处理完毕
             sys_session.commit()
             sys_session.commit()
@@ -168,6 +164,8 @@ class Api(ApiTemplate):
                 data_session.close()
                 data_session.close()
             if sys_session:
             if sys_session:
                 sys_session.close()
                 sys_session.close()
+            if sys_ds:
+                sys_ds.Destroy()
         return result
         return result
 
 
     def add_spatail_table(self,database,pg_ds,sys_session,spatial_tables_names,this_time,db_tuple):
     def add_spatail_table(self,database,pg_ds,sys_session,spatial_tables_names,this_time,db_tuple):
@@ -251,11 +249,11 @@ class Api(ApiTemplate):
                     sys_session.add(column)
                     sys_session.add(column)
         return db_tables_names
         return db_tables_names
 
 
-    def deal_vacuate_table(self,pg_ds,sys_session,database_guid,db_tuple):
+    def deal_vacuate_table(self,sys_ds,sys_session,database_guid):
 
 
 
 
-        for i in range(pg_ds.GetLayerCount()):
-            layer: Layer = pg_ds.GetLayer(i)
+        for i in range(sys_ds.GetLayerCount()):
+            layer: Layer = sys_ds.GetLayer(i)
             geom_column = layer.GetGeometryColumn()
             geom_column = layer.GetGeometryColumn()
 
 
             if not geom_column:
             if not geom_column:
@@ -266,12 +264,8 @@ class Api(ApiTemplate):
             if layer.GetName().__contains__("_vacuate_"):
             if layer.GetName().__contains__("_vacuate_"):
                 l_name = layer.GetName()
                 l_name = layer.GetName()
 
 
-                # 没有权限的表跳过
-                if not PGUtil.check_table_privilege(l_name, "SELECT", db_tuple[0], pg_ds):
-                    StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0], l_name), "warn")
-                    continue
+                base_layer_name = l_name.split("_vacuate_")[0].split("_")[1]
 
 
-                base_layer_name = l_name.split("_vacuate_")[0]
                 level = l_name.split("_")[-2]
                 level = l_name.split("_")[-2]
 
 
                 pixel_distance_str: str ="0"
                 pixel_distance_str: str ="0"

@@ -132,7 +132,7 @@ class Api(ApiTemplate):
 
 
             layer = pg_ds.GetLayerByName(table.name)
             layer = pg_ds.GetLayerByName(table.name)
 
 
-            vacuate_process:VacuateProcess = VacuateProcess(layer, table.name, options,database.sqlalchemy_uri)
+            vacuate_process:VacuateProcess = VacuateProcess(layer, table.guid, options)
 
 
 
 
             for feature in layer:
             for feature in layer:

@@ -18,6 +18,7 @@ import uuid
 import configure
 import configure
 from osgeo.ogr import DataSource,Layer,Geometry
 from osgeo.ogr import DataSource,Layer,Geometry
 from osgeo import ogr
 from osgeo import ogr
+from flask import current_app
 
 
 class Api(ApiTemplate):
 class Api(ApiTemplate):
     api_name = "删除抽稀表"
     api_name = "删除抽稀表"
@@ -26,6 +27,7 @@ class Api(ApiTemplate):
         res = {}
         res = {}
         res["data"] = {}
         res["data"] = {}
         pg_ds = None
         pg_ds = None
+        sys_ds = None
         try:
         try:
             table_guid = self.para.get("guid")
             table_guid = self.para.get("guid")
             table: Table = Table.query.filter_by(guid=table_guid).one_or_none()
             table: Table = Table.query.filter_by(guid=table_guid).one_or_none()
@@ -40,13 +42,9 @@ class Api(ApiTemplate):
 
 
             # 判断图层是否存在
             # 判断图层是否存在
             pg_ds :DataSource= PGUtil.open_pg_data_source(0,DES.decode(table.relate_database.sqlalchemy_uri))
             pg_ds :DataSource= PGUtil.open_pg_data_source(0,DES.decode(table.relate_database.sqlalchemy_uri))
-            layer = pg_ds.GetLayerByName(table.name)
+            sys_ds :DataSource= PGUtil.open_pg_data_source(0,configure.SQLALCHEMY_DATABASE_URI)
 
 
-            # 判断用户权限
-            # user, pw, host, port, database = PGUtil.get_info_from_sqlachemy_uri(DES.decode(table.relate_database.sqlalchemy_uri))
-            # query_role:Layer = pg_ds.ExecuteSQL("SELECT rolcreatedb FROM pg_roles WHERE rolname='{}'".format(user))
-            # if not query_role.GetFeature(0).GetField("rolcreatedb"):
-            #     raise Exception("用户不具备建表权限！")
+            layer = pg_ds.GetLayerByName(table.name)
 
 
             if not layer:
             if not layer:
                 raise Exception("图层不存在！")
                 raise Exception("图层不存在！")
@@ -58,9 +56,9 @@ class Api(ApiTemplate):
             for tv in tvs :
             for tv in tvs :
                 db.session.delete(tv)
                 db.session.delete(tv)
                 try:
                 try:
-                    pg_ds.DeleteLayer(tv.name)
+                    sys_ds.DeleteLayer(tv.name)
                 except Exception as e :
                 except Exception as e :
-                    StructurePrint.print("抽稀图层不存在！","warn")
+                    current_app.logger.warning("抽稀图层不存在！")
             db.session.commit()
             db.session.commit()
             res["result"] = True
             res["result"] = True
 
 
@@ -69,6 +67,8 @@ class Api(ApiTemplate):
         finally:
         finally:
             if pg_ds:
             if pg_ds:
                 pg_ds.Destroy()
                 pg_ds.Destroy()
+            if sys_ds:
+                sys_ds.Destroy()
         return res
         return res
 
 
 
 

@@ -25,8 +25,10 @@ class Api(ApiTemplate):
             if not table:
             if not table:
                 raise Exception("数据不存在！")
                 raise Exception("数据不存在！")
             tvs = TableVacuate.query.filter_by(table_guid=table_guid).all()
             tvs = TableVacuate.query.filter_by(table_guid=table_guid).all()
-            dat = collections.OrderedDict()
-            if float(table.extent.split(",")[0])<180:
+            dat = {}
+            info = {}
+
+            if float(table.extent.split(",")[0]) < 180:
                 grid_size = copy.copy(lonlat_gridsize)
                 grid_size = copy.copy(lonlat_gridsize)
             else:
             else:
                 grid_size = copy.copy(project_gridsize)
                 grid_size = copy.copy(project_gridsize)
@@ -36,12 +38,13 @@ class Api(ApiTemplate):
             grid_size.reverse()
             grid_size.reverse()
 
 
             # 正在精华的任务
             # 正在精华的任务
-            task_running = Task.query.filter_by(task_type=2,table_guid=table_guid,state=0).all()
+            task_running = Task.query.filter_by(task_type=2, table_guid=table_guid, state=0).all()
             grid_running = []
             grid_running = []
-            
+
             for t in task_running:
             for t in task_running:
                 grid_running.extend(t.parameter.split(","))
                 grid_running.extend(t.parameter.split(","))
 
 
+            info["type"] = "m"
             for grid in grid_size:
             for grid in grid_size:
                 if grid in now_grid:
                 if grid in now_grid:
                     dat[str(grid)] = 1
                     dat[str(grid)] = 1
@@ -49,8 +52,14 @@ class Api(ApiTemplate):
                     dat[str(grid)] = 0
                     dat[str(grid)] = 0
                 if str(grid) in grid_running:
                 if str(grid) in grid_running:
                     dat[str(grid)] = 2
                     dat[str(grid)] = 2
+                # 特殊处理一下
+                if grid == 0.00008:
+                    dat["0.00008"] = dat[str(grid)]
+                    del dat[str(grid)]
+                    info["type"] = "d"
+            info["info"] = dat
 
 
-            res["data"] = json.dumps(dat)
+            res["data"] = info
             res["result"] = True
             res["result"] = True
 
 
         except Exception as e:
         except Exception as e:

@@ -121,13 +121,16 @@ class Api(ApiTemplate):
 
 
             pg_ds :DataSource= PGUtil.open_pg_data_source(1,DES.decode(database.sqlalchemy_uri))
             pg_ds :DataSource= PGUtil.open_pg_data_source(1,DES.decode(database.sqlalchemy_uri))
 
 
+
+
+
             # 创建抽稀过程
             # 创建抽稀过程
             options = ["OVERWRITE=yes", "GEOMETRY_NAME={}".format(PGUtil.get_geo_column(table.name,pg_session)),
             options = ["OVERWRITE=yes", "GEOMETRY_NAME={}".format(PGUtil.get_geo_column(table.name,pg_session)),
                        "PRECISION=NO"]
                        "PRECISION=NO"]
 
 
             layer = pg_ds.GetLayerByName(table.name)
             layer = pg_ds.GetLayerByName(table.name)
 
 
-            vacuate_process:VacuateProcess = VacuateProcess(layer, table.name, options,database.sqlalchemy_uri,grids)
+            vacuate_process:VacuateProcess = VacuateProcess(layer, table.guid, options,database.sqlalchemy_uri,grids)
 
 
 
 
             for feature in layer:
             for feature in layer:
@@ -233,7 +236,7 @@ class VacuateProcess:
     this_gridsize=[]
     this_gridsize=[]
 
 
 
 
-    def __init__(self,layer:Layer,new_layer_name, options,sqlalchemy_uri,grids):
+    def __init__(self,layer:Layer,table_guid, options,sqlalchemy_uri,grids):
 
 
         #是空间图层才初始化
         #是空间图层才初始化
         if layer.GetExtent()[0] > 0 or layer.GetExtent()[0] < 0:
         if layer.GetExtent()[0] > 0 or layer.GetExtent()[0] < 0:
@@ -254,7 +257,9 @@ class VacuateProcess:
 
 
             # 创建抽稀ds
             # 创建抽稀ds
             for l in range(self.max_level):
             for l in range(self.max_level):
-                pg_ds_l: DataSource = PGUtil.open_pg_data_source(1, DES.decode(sqlalchemy_uri))
+
+                pg_ds_l: DataSource = PGUtil.open_pg_data_source(1, configure.SQLALCHEMY_DATABASE_URI)
+                # pg_ds_l: DataSource = PGUtil.open_pg_data_source(1, DES.decode(sqlalchemy_uri))
                 pg_ds_l.StartTransaction()
                 pg_ds_l.StartTransaction()
                 self.pg_ds_dict[l] = pg_ds_l
                 self.pg_ds_dict[l] = pg_ds_l
 
 
@@ -271,8 +276,8 @@ class VacuateProcess:
 
 
                 if this_grid_len<1:
                 if this_grid_len<1:
                     grid_name = str(this_grid_len).split(".")[-1]
                     grid_name = str(this_grid_len).split(".")[-1]
-                    if this_grid_len.__eq__(0.000075):
-                        grid_name = "000075"
+                    if this_grid_len.__eq__(0.00008):
+                        grid_name = "00008"
                 else:
                 else:
                     grid_name = str(int(this_grid_len))
                     grid_name = str(int(this_grid_len))
 
 
@@ -284,8 +289,10 @@ class VacuateProcess:
 
 
                 lev = this_grid_szie.index(this_grid_len)
                 lev = this_grid_szie.index(this_grid_len)
                 print("{}:{}".format(grid_name, lev))
                 print("{}:{}".format(grid_name, lev))
-                vl = pg.CreateLayer("{}_vacuate_{}_{}".format(new_layer_name, lev, grid_name), layer.GetSpatialRef(),
-                                    ogr.wkbUnknown, options)
+
+
+                v_ln = "z{}_vacuate_{}_{}".format(table_guid,lev, grid_name)
+                vl = pg.CreateLayer(v_ln, layer.GetSpatialRef(),ogr.wkbUnknown, options)
                 # 抽稀表不需要属性
                 # 抽稀表不需要属性
                 # vl.CreateFields(schema)
                 # vl.CreateFields(schema)
                 self.vacuate_layers[l] = vl
                 self.vacuate_layers[l] = vl
@@ -308,6 +315,13 @@ class VacuateProcess:
                 lat_extent = extent[3]-extent[2]
                 lat_extent = extent[3]-extent[2]
 
 
                 this_grid_len =self.vacuate_layers_gridsize[level]
                 this_grid_len =self.vacuate_layers_gridsize[level]
+                #超大的直接加入
+                # if long_extent > 10*this_grid_len or lat_extent >10*this_grid_len:
+                #     vacuate_layer: Layer = self.vacuate_layers.get(level)
+                #     feat = ogr.Feature(vacuate_layer.GetLayerDefn())
+                #     feat.SetGeometry(g)
+                #     vacuate_layer.CreateFeature(feat)
+                # else:
 
 
                 row = int((center.GetY() - self.extent[2]) / this_grid_len)
                 row = int((center.GetY() - self.extent[2]) / this_grid_len)
                 col = int((center.GetX() - self.extent[0]) / this_grid_len)
                 col = int((center.GetX() - self.extent[0]) / this_grid_len)
@@ -325,7 +339,14 @@ class VacuateProcess:
                     else:
                     else:
                         feat.SetGeometry(g)
                         feat.SetGeometry(g)
                     vacuate_layer.CreateFeature(feat)
                     vacuate_layer.CreateFeature(feat)
-                self.fill_dict[key] += 1
+                    self.fill_dict[key] += 1
+                #超大的还有机会
+                elif (long_extent > 10*this_grid_len or lat_extent >10*this_grid_len) and self.fill_dict[key]<5:
+                    vacuate_layer: Layer = self.vacuate_layers.get(level)
+                    feat = ogr.Feature(vacuate_layer.GetLayerDefn())
+                    feat.SetGeometry(g)
+                    vacuate_layer.CreateFeature(feat)
+                    self.fill_dict[key] += 1
 
 
     def end(self):
     def end(self):
         for pg in self.pg_ds_dict.values():
         for pg in self.pg_ds_dict.values():

@@ -43,10 +43,6 @@ class Api(ApiTemplate):
             layer = pg_ds.GetLayerByName(table.name)
             layer = pg_ds.GetLayerByName(table.name)
 
 
             # 判断用户权限
             # 判断用户权限
-            user, pw, host, port, database = PGUtil.get_info_from_sqlachemy_uri(DES.decode(table.relate_database.sqlalchemy_uri))
-            query_role:Layer = pg_ds.ExecuteSQL("SELECT rolcreatedb FROM pg_roles WHERE rolname='{}'".format(user))
-            if not query_role.GetFeature(0).GetField("rolcreatedb"):
-                raise Exception("用户不具备建表权限！")
 
 
             if not layer:
             if not layer:
                 raise Exception("图层不存在！")
                 raise Exception("图层不存在！")

@@ -149,6 +149,10 @@ def copydata():
 
 
 
 
 if __name__ == '__main__':
 if __name__ == '__main__':
+    bound_shp = ""
+    gdb = ""
+    layer_name = ""
+
     copydata()
     copydata()
 
 
 
 

+# coding=utf-8
+#author:        4N
+#createtime:    2021/6/11
+#email:         nheweijun@sina.com
+import copy
+from osgeo.ogr import *
+from osgeo import gdal,ogr
+import uuid
+import time
+import os
+import json
+
+
+def get_info_from_sqlachemy_uri(uri):
+    parts = uri.split(":")
+    user = parts[1][2:]
+
+    password_list = parts[2].split("@")
+    if password_list.__len__() > 2:
+        password = "@".join(password_list[:-1])
+    else:
+        password = parts[2].split("@")[0]
+    host = parts[2].split("@")[-1]
+    port = parts[3].split("/")[0]
+    database = parts[3].split("/")[1]
+
+    return user, password, host, port, database
+
+def open_pg_data_source(iswrite, uri):
+    """
+    # 获取PostGIS数据源
+    :return:
+    """
+    db_conn_tuple = get_info_from_sqlachemy_uri(uri)
+    fn = "PG: user=%s password=%s host=%s port=%s dbname=%s " % db_conn_tuple
+    driver = ogr.GetDriverByName("PostgreSQL")
+    if driver is None:
+        raise Exception("打开PostgreSQL驱动失败，可能是当前GDAL未支持PostgreSQL驱动！")
+    ds = driver.Open(fn, iswrite)
+    if ds is None:
+        raise Exception("打开数据源失败！")
+    return ds
+
+
+def move_digui(coords,offx,offy):
+    if isinstance(coords[0],list):
+        for coord in coords:
+            move_digui(coord, offx, offy)
+    else :
+        coords[0] += offx
+        coords[1] += offy
+
+def move(geo,offx,offy):
+
+
+    geojson_str = geo.ExportToJson()
+    geojson = json.loads(geojson_str)
+
+    coords = geojson["coordinates"]
+    move_digui(coords, offx, offy)
+    og = ogr.CreateGeometryFromJson(json.dumps(geojson))
+
+    return og
+
+
+def copydata(bound,input,output):
+    work_dir = os.path.dirname(os.path.abspath(__file__))
+
+    shp_driver: Driver = ogr.GetDriverByName("ESRI Shapefile")
+    bound_ds : DataSource = shp_driver.Open(bound, 0)
+    bound_layer :Layer = bound_ds.GetLayer(0)
+
+    bf = bound_layer.GetNextFeature()
+    bound_geom = bf.GetGeometryRef()
+
+
+
+    gdb_driver: Driver = ogr.GetDriverByName("FileGDB")
+    # gdb_ds: DataSource = gdb_driver.Open(gdb, 0)
+    # layer: Layer = gdb_ds.GetLayerByName(layer_name)
+
+    input_ds: DataSource = shp_driver.Open(input, 0)
+    layer: Layer = input_ds.GetLayer(0)
+
+    if not layer:
+        raise Exception("打开数据失败！")
+
+
+    output_ds: DataSource = gdb_driver.CreateDataSource(output)
+
+
+    gdb_layer:Layer = output_ds.CreateLayer(layer.GetName(),layer.GetSpatialRef(),layer.GetGeomType())
+
+    gdb_layer.CreateFields(layer.schema)
+
+
+
+
+    #
+    bound_exent = bound_layer.GetExtent()
+
+    layer_extent = layer.GetExtent()
+
+    xxrange=layer_extent[1]-layer_extent[0]
+    yrange = layer_extent[3]-layer_extent[2]
+
+
+    left = (int((layer_extent[0] - bound_exent[0]) / xxrange) + 1) * (-1)
+    right = int((bound_exent[1] - layer_extent[1]) / xxrange) + 1
+    up = int((bound_exent[3] - layer_extent[3]) / yrange) + 1
+    down =  (int((layer_extent[2] - bound_exent[2]) / yrange) + 1) * (-1)
+
+
+    begin = time.time()
+    count=1
+
+
+    for f in layer:
+
+        new_f = copy.copy(f)
+        for xt in range(left,right+1,1):
+            for yt in range(down,up+1,1):
+                out_g = move(f.GetGeometryRef(),xxrange*xt,yrange*yt)
+
+                if out_g.Intersect(bound_geom):
+                    out_g = out_g.Intersection(bound_geom)
+                    new_f.SetGeometry(out_g)
+                    new_f.SetFID(count)
+                    gdb_layer.CreateFeature(new_f)
+                    count += 1
+                    if count % 10000 == 0:
+                        # print(count)
+                        with open(os.path.join(work_dir, "copy.txt"), "w") as fi:
+                            fi.write("已完成{}".format(count))
+
+    print(time.time()-begin)
+
+    input_ds.Destroy()
+
+def envelop_2_polygon(env):
+    ring = ogr.Geometry(ogr.wkbLinearRing)
+    ring.AddPoint(env[0], env[2])
+    ring.AddPoint(env[0], env[3])
+    ring.AddPoint(env[1], env[3])
+    ring.AddPoint(env[1], env[2])
+    ring.AddPoint(env[0], env[2])
+    # Create polygon
+    poly = ogr.Geometry(ogr.wkbPolygon)
+    poly.AddGeometry(ring)
+    return poly
+
+def clip():
+
+    input = r"E:\Data\copy\x.shp"
+    output = r"E:\Data\copy\xianorigin.shp"
+    gdal.SetConfigOption("SHAPE_ENCODING", "UTF-8")
+    shp_driver: Driver = ogr.GetDriverByName("ESRI Shapefile")
+
+    input_ds: DataSource = shp_driver.Open(input, 0)
+    layer: Layer = input_ds.GetLayer(0)
+
+    bound_geo = envelop_2_polygon([112.84,112.952,22.914,22.985])
+
+    if not layer:
+        raise Exception("打开数据失败！")
+
+    output_ds: DataSource = shp_driver.CreateDataSource(output)
+
+    out_layer: Layer = output_ds.CreateLayer(layer.GetName(), layer.GetSpatialRef(), layer.GetGeomType())
+    out_layer.CreateFields(layer.schema)
+    for f in layer:
+        new_f = copy.copy(f)
+        out_g = f.GetGeometryRef()
+        if out_g.Intersect(bound_geo):
+            out_g = out_g.Intersection(bound_geo)
+            new_f.SetGeometry(out_g)
+            # new_f.UnsetField("OBJECTID")
+            out_layer.CreateFeature(new_f)
+
+    output_ds.Destroy()
+
+
+
+if __name__ == '__main__':
+    # bound_shp = "E:\Data\广东边界\gdsample.shp"
+    # input = r"E:\Data\copy\origin.shp"
+    # output = r"E:\Data\copy\re.shp"
+    # copydata(bound_shp,input,output)
+
+    # bound_shp = "/root/CopyData/gdsample.shp"
+    # input = r"/root/CopyData/origin.shp"
+    # output = r"/root/CopyData/re.gdb"
+    # copydata(bound_shp,input,output)
+    clip()
+
+
+
+
+
+
+
+
+
+
+

@@ -159,7 +159,7 @@ class EntryDataVacuate:
         new_layer_name = None
         new_layer_name = None
         vacuate_process= None
         vacuate_process= None
         success = True
         success = True
-
+        table_guid = uuid.uuid1().__str__()
         try:
         try:
             # 图层设置
             # 图层设置
             parameter = this_task.parameter
             parameter = this_task.parameter
@@ -200,7 +200,7 @@ class EntryDataVacuate:
             pg_layer.CreateFields(schema)
             pg_layer.CreateFields(schema)
 
 
             #创建抽稀过程
             #创建抽稀过程
-            vacuate_process = VacuateProcess(layer,new_layer_name,options,this_task.database.sqlalchemy_uri)
+            vacuate_process = VacuateProcess(layer,table_guid,options)
 
 
 
 
 
 
@@ -235,7 +235,8 @@ class EntryDataVacuate:
             # 注册图层信息
             # 注册图层信息
             # 是否抽吸过
             # 是否抽吸过
             is_vacuate = 1 if vacuate_process.max_level>0 else 0
             is_vacuate = 1 if vacuate_process.max_level>0 else 0
-            table_guid = this_task.register_table(pg_layer,new_layer_name,overwrite,parameter.get("creator"),is_vacuate)
+
+            this_task.register_table(pg_layer,new_layer_name,overwrite,parameter.get("creator"),is_vacuate,table_guid)
 
 
             # 注册抽稀表
             # 注册抽稀表
             this_task.register_table_vacuate(table_guid,vacuate_process.vacuate_layers)
             this_task.register_table_vacuate(table_guid,vacuate_process.vacuate_layers)
@@ -295,7 +296,7 @@ class ThisTask:
         self.process_session.add(task_process)
         self.process_session.add(task_process)
         self.process_session.commit()
         self.process_session.commit()
 
 
-    def register_table(self, layer: Layer, new_layer_name, overwrite, creator,is_vacuate):
+    def register_table(self, layer: Layer, new_layer_name, overwrite, creator,is_vacuate,table_guid):
         '''
         '''
         注册表
         注册表
         :param layer: 图层
         :param layer: 图层
@@ -321,7 +322,7 @@ class ThisTask:
         geom_type = GeometryAdapter.get_geometry_type(layer)
         geom_type = GeometryAdapter.get_geometry_type(layer)
 
 
         extent = "{},{},{},{}".format(ext[0], ext[1], ext[2], ext[3])
         extent = "{},{},{},{}".format(ext[0], ext[1], ext[2], ext[3])
-        table_guid = uuid.uuid1().__str__()
+
         table = Table(guid=table_guid,
         table = Table(guid=table_guid,
                       database_guid=self.database.guid,
                       database_guid=self.database.guid,
                       creator=creator,
                       creator=creator,
@@ -419,7 +420,7 @@ class VacuateProcess:
     this_gridsize=[]
     this_gridsize=[]
 
 
 
 
-    def __init__(self,layer:Layer,new_layer_name, options,sqlalchemy_uri):
+    def __init__(self,layer:Layer,table_guid, options):
 
 
         #是空间图层才初始化
         #是空间图层才初始化
         if layer.GetExtent()[0] > 0 or layer.GetExtent()[0] < 0:
         if layer.GetExtent()[0] > 0 or layer.GetExtent()[0] < 0:
@@ -466,6 +467,7 @@ class VacuateProcess:
                 self.t_grid_size=self.project_gridsize
                 self.t_grid_size=self.project_gridsize
             else:
             else:
                 self.t_grid_size = self.lonlat_gridsize
                 self.t_grid_size = self.lonlat_gridsize
+
             for grid_size in self.t_grid_size:
             for grid_size in self.t_grid_size:
                 # 最少抽稀个数
                 # 最少抽稀个数
                 if lc > self.least_vacuate_count:
                 if lc > self.least_vacuate_count:
@@ -482,7 +484,8 @@ class VacuateProcess:
 
 
             # 创建抽稀ds
             # 创建抽稀ds
             for l in range(self.max_level):
             for l in range(self.max_level):
-                pg_ds_l: DataSource = PGUtil.open_pg_data_source(1, DES.decode(sqlalchemy_uri))
+                # pg_ds_l: DataSource = PGUtil.open_pg_data_source(1, DES.decode(sqlalchemy_uri))
+                pg_ds_l: DataSource = PGUtil.open_pg_data_source(1, configure.SQLALCHEMY_DATABASE_URI)
                 pg_ds_l.StartTransaction()
                 pg_ds_l.StartTransaction()
                 self.pg_ds_dict[l] = pg_ds_l
                 self.pg_ds_dict[l] = pg_ds_l
 
 
@@ -500,16 +503,19 @@ class VacuateProcess:
                 grid_name = str(this_grid_len)
                 grid_name = str(this_grid_len)
                 if this_grid_len<1:
                 if this_grid_len<1:
                     grid_name = str(this_grid_len).split(".")[-1]
                     grid_name = str(this_grid_len).split(".")[-1]
-                    if this_grid_len.__eq__(0.000075):
-                        grid_name = "000075"
+                    if this_grid_len.__eq__(0.00008):
+                        grid_name = "00008"
 
 
                 # 抽稀图层是点面混合的
                 # 抽稀图层是点面混合的
                 # 抽稀表有固定的命名规则
                 # 抽稀表有固定的命名规则
                 # 抽稀表一定要覆盖
                 # 抽稀表一定要覆盖
 
 
 
 
-                vl = pg.CreateLayer("{}_vacuate_{}_{}".format(new_layer_name, self.t_grid_size.index(this_grid_len), grid_name), layer.GetSpatialRef(),
-                                    ogr.wkbUnknown, options)
+                print("{}:{}".format(self.t_grid_size.index(this_grid_len),this_grid_len))
+
+
+                v_ln = "z{}_vacuate_{}_{}".format(table_guid, self.t_grid_size.index(this_grid_len), grid_name)
+                vl = pg.CreateLayer(v_ln, layer.GetSpatialRef(),ogr.wkbUnknown, options)
                 # 抽稀表不需要属性
                 # 抽稀表不需要属性
                 # vl.CreateFields(schema)
                 # vl.CreateFields(schema)
                 self.vacuate_layers[l] = vl
                 self.vacuate_layers[l] = vl
@@ -532,6 +538,13 @@ class VacuateProcess:
                 lat_extent = extent[3]-extent[2]
                 lat_extent = extent[3]-extent[2]
 
 
                 this_grid_len =self.vacuate_layers_gridsize[level]
                 this_grid_len =self.vacuate_layers_gridsize[level]
+                #超大的直接加入
+                # if long_extent > 10*this_grid_len or lat_extent >10*this_grid_len:
+                #     vacuate_layer: Layer = self.vacuate_layers.get(level)
+                #     feat = ogr.Feature(vacuate_layer.GetLayerDefn())
+                #     feat.SetGeometry(g)
+                #     vacuate_layer.CreateFeature(feat)
+                # else:
 
 
                 row = int((center.GetY() - self.extent[2]) / this_grid_len)
                 row = int((center.GetY() - self.extent[2]) / this_grid_len)
                 col = int((center.GetX() - self.extent[0]) / this_grid_len)
                 col = int((center.GetX() - self.extent[0]) / this_grid_len)
@@ -549,7 +562,14 @@ class VacuateProcess:
                     else:
                     else:
                         feat.SetGeometry(g)
                         feat.SetGeometry(g)
                     vacuate_layer.CreateFeature(feat)
                     vacuate_layer.CreateFeature(feat)
-                self.fill_dict[key] += 1
+                    self.fill_dict[key] += 1
+                #超大的还有机会
+                elif (long_extent > 10*this_grid_len or lat_extent >10*this_grid_len) and self.fill_dict[key]<5:
+                    vacuate_layer: Layer = self.vacuate_layers.get(level)
+                    feat = ogr.Feature(vacuate_layer.GetLayerDefn())
+                    feat.SetGeometry(g)
+                    vacuate_layer.CreateFeature(feat)
+                    self.fill_dict[key] += 1
 
 
     def end(self):
     def end(self):
         for pg in self.pg_ds_dict.values():
         for pg in self.pg_ds_dict.values():

+ﾒﾑﾍﾉ20000

@@ -355,6 +355,9 @@ IncludeOptional conf.d/*.conf
 LoadModule wsgi_module "/usr/lib64/httpd/modules/mod_wsgi-py37.cpython-37m-x86_64-linux-gnu.so"
 LoadModule wsgi_module "/usr/lib64/httpd/modules/mod_wsgi-py37.cpython-37m-x86_64-linux-gnu.so"
  "/var/gdal"
  "/var/gdal"
 
 
+ dmapmanager processes=4 threads=16 display-name=%{GROUP}
+ dmapmanager
+
  / /usr/src/app/run.wsgi
  / /usr/src/app/run.wsgi
 <Directory /usr/>
 <Directory /usr/>
   Require all granted
   Require all granted

@@ -19,15 +19,5 @@ import json
 # print(sys.getsizeof(json.dumps(pixel_array.tolist())))
 # print(sys.getsizeof(json.dumps(pixel_array.tolist())))
 # print(sys.getsizeof((content)))
 # print(sys.getsizeof((content)))
 
 
-def c(dd):
-    return 1
-
-dd = numpy.zeros((2000, 2000), dtype=int) + 2
-
-
-dd[range(0, 5), 1]=1
-
-
-
-
-print(dd)
+for x in range(-3,3,1):
+    print(x)