ÐÞ¸´»ñȡͼ²ãÒªËØÊýÁ¿bugºÍ²»ÄÜʶ±ðͼ²ãÀàÐÍbug

@@ -119,20 +119,22 @@ class Task(db.Model):
     create_time = Column(DateTime)
     create_time = Column(DateTime)
     update_time = Column(DateTime)
     update_time = Column(DateTime)
     state = Column(Integer)
     state = Column(Integer)
-    # 数据源外键
+    #数据源外键
     database_guid = Column(String(256), ForeignKey('dmdms_database.guid'))
     database_guid = Column(String(256), ForeignKey('dmdms_database.guid'))
-    # 目录外键
+    #目录外键
     catalog_guid = Column(String(256), ForeignKey('dmdms_catalog.guid'))
     catalog_guid = Column(String(256), ForeignKey('dmdms_catalog.guid'))
-
+    #抽稀任务指定表的guid
     table_guid =  Column(String(256))
     table_guid =  Column(String(256))
     #任务类型
     #任务类型
+    #1：入库任务
+    #2：抽稀任务
+    #3：数据库刷新任务
+    #4：影像金字塔任务
+    #5：数据下载任务
     task_type=Column(Integer)
     task_type=Column(Integer)
-
     creator = Column(Text)
     creator = Column(Text)
     file_name = Column(Text)
     file_name = Column(Text)
-
     relate_processes = relationship('Process', backref='relate_task', lazy='dynamic')
     relate_processes = relationship('Process', backref='relate_task', lazy='dynamic')
-
     # 入库参数
     # 入库参数
     parameter= Column(Text)
     parameter= Column(Text)
 
 
@@ -177,12 +179,9 @@ class Database(db.Model):
     description = Column(Text)
     description = Column(Text)
     # 唯一性约束，不能注册相同连接的库
     # 唯一性约束，不能注册相同连接的库
     connectstr= Column(Text,unique=True)
     connectstr= Column(Text,unique=True)
-
     creator = Column(String(256))
     creator = Column(String(256))
-
     create_time = Column(DateTime)
     create_time = Column(DateTime)
     update_time = Column(DateTime)
     update_time = Column(DateTime)
-
     relate_catalogs = relationship('Catalog', backref='relate_database', lazy='dynamic')
     relate_catalogs = relationship('Catalog', backref='relate_database', lazy='dynamic')
     relate_tables = relationship('Table', backref='relate_database', lazy='dynamic')
     relate_tables = relationship('Table', backref='relate_database', lazy='dynamic')
     relate_tasks = relationship('Task', backref='relate_database', lazy='dynamic')
     relate_tasks = relationship('Task', backref='relate_database', lazy='dynamic')

@@ -118,7 +118,7 @@ class Api(ApiTemplate):
 
 
             # 范围统计和数量统计以100w为界限
             # 范围统计和数量统计以100w为界限
             query_count_layer: Layer = pg_ds.ExecuteSQL(
             query_count_layer: Layer = pg_ds.ExecuteSQL(
-                "SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public.{}'::regclass".format(l_name))
+                '''SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public."{}"'::regclass'''.format(l_name))
             feature_count = query_count_layer.GetFeature(0).GetField("ec")
             feature_count = query_count_layer.GetFeature(0).GetField("ec")
             # 要素少于100w可以精确统计
             # 要素少于100w可以精确统计
             if feature_count < 1000000:
             if feature_count < 1000000:
@@ -141,7 +141,7 @@ class Api(ApiTemplate):
                           database_guid=database.guid,
                           database_guid=database.guid,
                           # alias=layer.GetName(),
                           # alias=layer.GetName(),
                           name=layer.GetName(), create_time=this_time, update_time=this_time,
                           name=layer.GetName(), create_time=this_time, update_time=this_time,
-                          table_type=GeometryAdapter.get_table_type(layer.GetGeomType()),
+                          table_type=GeometryAdapter.get_table_type(GeometryAdapter.get_geometry_type(layer)),
                           extent=extent,
                           extent=extent,
                           feature_count=feature_count
                           feature_count=feature_count
                           )
                           )

+# coding=utf-8
+#author:        4N
+#createtime:    2021/8/11
+#email:         nheweijun@sina.com
+
+from flasgger import swag_from
+from flask import Blueprint
+from app.util import BlueprintApi
+from . import feature_query
+from . import feature_add
+from . import feature_buffer_query
+from . import feature_info
+from . import feature_delete
+from . import feature_schema
+from . import feature_edit
+
+class DataManager(BlueprintApi):
+
+    bp = Blueprint("FeatureService", __name__, url_prefix="/API/FeatureService")
+
+    @staticmethod
+    @bp.route('/Query', methods=['POST'])
+    @swag_from(feature_query.Api.api_doc)
+    def feature_query():
+        """
+        要素查询
+        """
+        return feature_query.Api().result
+
+    @staticmethod
+    @bp.route('/BufferQuery', methods=['POST'])
+    @swag_from(feature_buffer_query.Api.api_doc)
+    def feature_buffer_query():
+        """
+        缓冲区查询
+        """
+        return feature_buffer_query.Api().result
+
+    @staticmethod
+    @bp.route('/Info', methods=['POST'])
+    @swag_from(feature_info.Api.api_doc)
+    def feature_info():
+        """
+        要素info
+        """
+        return feature_info.Api().result
+
+
+    @staticmethod
+    @bp.route('/Delete', methods=['POST'])
+    @swag_from(feature_delete.Api.api_doc)
+    def feature_delete():
+        """
+        要素删除
+        """
+        return feature_delete.Api().result
+
+    @staticmethod
+    @bp.route('/Add', methods=['POST'])
+    @swag_from(feature_add.Api.api_doc)
+    def feature_add():
+        """
+        要素增加
+        """
+        return feature_add.Api().result
+
+    @staticmethod
+    @bp.route('/Edit', methods=['POST'])
+    @swag_from(feature_edit.Api.api_doc)
+    def feature_edit():
+        """
+        要素修改
+        """
+        return feature_edit.Api().result
+
+    @staticmethod
+    @bp.route('/Schema', methods=['POST'])
+    @swag_from(feature_schema.Api.api_doc)
+    def feature_schema():
+        """
+        要素schema
+        """
+        return feature_schema.Api().result

+# coding=utf-8
+# author:        4N
+# createtime:    2021/8/4
+# email:         nheweijun@sina.com
+import datetime
+
+
+
+from app.models import Task
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ModelVisitor import ModelVisitor
+class Api(ApiTemplate):
+    api_name = "要素增加"
+    def para_check(self):
+        pass
+
+    def process(self):
+
+        res = {}
+        res["data"] = {}
+        try:
+            pass
+        except Exception as e:
+            raise e
+        return res
+
+
+
+    api_doc={
+    "tags":["要素接口"],
+    "parameters":[
+
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+# coding=utf-8
+# author:        4N
+# createtime:    2021/8/4
+# email:         nheweijun@sina.com
+import datetime
+
+
+
+from app.models import Table,Database
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.GeometryAdapter import GeometryAdapter
+from app.util.component.LayerUtil import LayerUtil
+from app.util.component.PGUtil import PGUtil
+from osgeo.ogr import Geometry,Layer,DataSource,Feature
+from app.models import DES
+from osgeo import ogr
+import gzip
+from flask import make_response
+class Api(ApiTemplate):
+    api_name = "缓冲区查询"
+    def para_check(self):
+        pass
+
+    def process(self):
+
+        res = {}
+        pg_ds:DataSource = None
+        try:
+            table:Table = Table.query.filter_by(guid=self.para.get("guid")).one_or_none()
+            if not table:
+                raise Exception("数据不存在!")
+            if table.table_type == 0:
+                raise Exception("非空间数据!")
+
+            database:Database = table.relate_database
+            pg_ds:DataSource = PGUtil.open_pg_data_source(0,DES.decode(database.sqlalchemy_uri))
+            layer:Layer = pg_ds.GetLayerByName(table.name)
+
+            #缓冲区查询
+            point = GeometryAdapter.tuple_2_point([float(x) for x in self.para.get("point").split(",")])
+            layer.SetSpatialFilter(point.Buffer(float(self.para.get("buffer"))))
+
+            feature_collection = LayerUtil.layer_to_feature_collection(layer,limit=1000)
+            res["data"] = feature_collection
+            res["result"] = True
+
+        except Exception as e:
+            raise e
+        finally:
+            if pg_ds:
+                pg_ds.Destroy()
+
+        # 使用gzip 压缩传输
+        content = gzip.compress(bytes('{}'.format(json.dumps(res,ensure_ascii=False)), 'utf-8'), 2)
+        response = make_response(content)
+        response.headers['Content-length'] = len(content)
+        response.headers['Content-Encoding'] = 'gzip'
+        return response
+
+    api_doc={
+    "tags":["要素接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string",
+         "description": "guid"},
+        {"name": "point",
+         "in": "formData",
+         "type": "string",
+         "description": "point"},
+        {"name": "buffer",
+         "in": "formData",
+         "type": "float",
+         "description": "buffer"}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+# coding=utf-8
+# author:        4N
+# createtime:    2021/8/4
+# email:         nheweijun@sina.com
+from app.models import Table,Database
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.GeometryAdapter import GeometryAdapter
+from app.util.component.LayerUtil import LayerUtil
+from app.util.component.PGUtil import PGUtil
+from osgeo.ogr import Geometry,Layer,DataSource,Feature
+from app.models import DES
+import json
+class Api(ApiTemplate):
+    api_name = "要素删除"
+    def para_check(self):
+        pass
+
+    def process(self):
+
+        res = {}
+        pg_ds:DataSource = None
+        try:
+            table:Table = Table.query.filter_by(guid=self.para.get("guid")).one_or_none()
+            if not table:
+                raise Exception("数据不存在!")
+            if table.table_type == 0:
+                raise Exception("非空间数据!")
+
+            database:Database = table.relate_database
+            pg_ds:DataSource = PGUtil.open_pg_data_source(1,DES.decode(database.sqlalchemy_uri))
+            layer:Layer = pg_ds.GetLayerByName(table.name)
+
+            fid = int(self.para.get("fid"))
+            is_success = layer.DeleteFeature(fid)
+            if is_success == 0:
+                res["msg"] = "删除成功！"
+                res["result"] = True
+            else :
+                res["msg"] = "要素不存在，删除失败！"
+                res["result"] = False
+
+        except Exception as e:
+            raise e
+        finally:
+            if pg_ds:
+                pg_ds.Destroy()
+        return res
+
+
+
+
+    api_doc={
+    "tags":["要素接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string",
+         "description": "guid"},
+        {"name": "fid",
+         "in": "formData",
+         "type": "string",
+         "description": "fid"}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+# coding=utf-8
+# author:        4N
+# createtime:    2021/8/4
+# email:         nheweijun@sina.com
+import datetime
+
+
+
+from app.models import Task
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ModelVisitor import ModelVisitor
+class Api(ApiTemplate):
+    api_name = "要素编辑"
+    def para_check(self):
+        pass
+
+    def process(self):
+
+        res = {}
+        res["data"] = {}
+        try:
+            pass
+        except Exception as e:
+            raise e
+        return res
+
+
+
+    api_doc={
+    "tags":["要素接口"],
+    "parameters":[
+
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+# coding=utf-8
+# author:        4N
+# createtime:    2021/8/4
+# email:         nheweijun@sina.com
+
+
+from app.models import Table,Database
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.GeometryAdapter import GeometryAdapter
+from app.util.component.LayerUtil import LayerUtil
+from app.util.component.PGUtil import PGUtil
+from osgeo.ogr import Geometry,Layer,DataSource,Feature
+from app.models import DES
+import json
+import gzip
+from flask import make_response
+class Api(ApiTemplate):
+    api_name = "要素info"
+    def para_check(self):
+        pass
+
+    def process(self):
+
+        res = {}
+        pg_ds:DataSource = None
+        try:
+            table:Table = Table.query.filter_by(guid=self.para.get("guid")).one_or_none()
+            if not table:
+                raise Exception("数据不存在!")
+            if table.table_type == 0:
+                raise Exception("非空间数据!")
+
+            database:Database = table.relate_database
+            pg_ds:DataSource = PGUtil.open_pg_data_source(0,DES.decode(database.sqlalchemy_uri))
+            layer:Layer = pg_ds.GetLayerByName(table.name)
+
+            #info查询
+            point = GeometryAdapter.tuple_2_point([float(x) for x in self.para.get("point").split(",")])
+            layer.SetSpatialFilter(point)
+            intersect_feats = []
+            for feature in layer:
+                if feature.geometry().Intersect(point):
+                    intersect_feats.append(feature)
+            feature_collection = LayerUtil.layer_to_feature_collection(intersect_feats,limit=1000)
+            res["data"] = feature_collection
+            res["result"] = True
+
+        except Exception as e:
+            raise e
+        finally:
+            if pg_ds:
+                pg_ds.Destroy()
+
+        # 使用gzip 压缩传输
+        content = gzip.compress(bytes("{}".format(json.dumps(res,ensure_ascii=False)), "utf-8"), 2)
+        response = make_response(content)
+        response.headers['Content-length'] = len(content)
+        response.headers['Content-Encoding'] = "gzip"
+        return response
+
+
+    api_doc={
+    "tags":["要素接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string",
+         "description": "guid"},
+        {"name": "point",
+         "in": "formData",
+         "type": "string",
+         "description": "point"}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+# coding=utf-8
+# author:        4N
+# createtime:    2021/8/4
+# email:         nheweijun@sina.com
+import datetime
+
+
+
+from app.models import Table,Database
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.GeometryAdapter import GeometryAdapter
+from app.util.component.LayerUtil import LayerUtil
+from app.util.component.PGUtil import PGUtil
+from osgeo.ogr import Geometry,Layer,DataSource,Feature
+from app.models import DES
+import json
+import gzip
+from flask import make_response
+class Api(ApiTemplate):
+    api_name = "空间查询"
+    def para_check(self):
+        pass
+
+    def process(self):
+
+        res = {}
+        pg_ds:DataSource = None
+        try:
+            table:Table = Table.query.filter_by(guid=self.para.get("guid")).one_or_none()
+            if not table:
+                raise Exception("数据不存在!")
+            if table.table_type == 0:
+                raise Exception("非空间数据!")
+
+            database:Database = table.relate_database
+            pg_ds:DataSource = PGUtil.open_pg_data_source(0,DES.decode(database.sqlalchemy_uri))
+            layer:Layer = pg_ds.GetLayerByName(table.name)
+
+            #空间查询
+            if self.para.get("bbox"):
+                bbox:Geometry = GeometryAdapter.envelop_2_polygon([float(x) for x in self.para.get("bbox").split(",")])
+                layer.SetSpatialFilter(bbox)
+            #属性查询
+            if self.para.get("filter"):
+                conditions = json.loads(self.para.get("filter"))
+                filter_conds = []
+                for cond in conditions:
+                    if cond["type"].__eq__("range"):
+                        filter_conds.append("{}>{} AND {}<{}".format(cond["name"],cond["lower"],
+                                                                          cond["name"], cond["higher"]))
+                    if cond["type"].__eq__("value"):
+                        try:
+                            val = float(cond["value"])
+                            filter_conds.append("{}={}".format(cond["name"], val))
+                        except:
+                            filter_conds.append("{} like '%{}%'".format(cond["name"], cond["value"]))
+                    if cond["type"].__eq__("time"):
+                        filter_conds.append("{} > timestamp '{}' AND {} < timestamp '{}'".format(cond["name"],
+                                                                                                 cond["lower"],
+                                                                                                 cond["name"],
+                                                                                                 cond["higher"]))
+                layer.SetAttributeFilter(" AND ".join(filter_conds))
+
+
+            feature_collection = LayerUtil.layer_to_feature_collection(layer,limit=1000)
+            res["data"] = feature_collection
+            res["result"] = True
+
+        except Exception as e:
+            raise e
+        finally:
+            if pg_ds:
+                pg_ds.Destroy()
+
+        # 使用gzip 压缩传输
+        content = gzip.compress(bytes('{}'.format(json.dumps(res,ensure_ascii=False)), 'utf-8'), 2)
+        response = make_response(content)
+        response.headers['Content-length'] = len(content)
+        response.headers['Content-Encoding'] = 'gzip'
+        return response
+
+    api_doc={
+    "tags":["要素接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string",
+         "description": "guid"},
+        {"name": "bbox",
+         "in": "formData",
+         "type": "string",
+         "description": "bbox"},
+        {"name": "filter",
+         "in": "formData",
+         "type": "string",
+         "description": "filter"}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+# coding=utf-8
+# author:        4N
+# createtime:    2021/8/4
+# email:         nheweijun@sina.com
+
+
+from app.models import Table,Database
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.GeometryAdapter import GeometryAdapter
+from app.util.component.LayerUtil import LayerUtil
+from app.util.component.PGUtil import PGUtil
+from osgeo.ogr import Geometry,Layer,DataSource,Feature,FieldDefn
+from app.models import DES
+import json
+class Api(ApiTemplate):
+    api_name = "要素info"
+    def para_check(self):
+        pass
+
+    def process(self):
+
+        res = {}
+        pg_ds:DataSource = None
+        try:
+            table:Table = Table.query.filter_by(guid=self.para.get("guid")).one_or_none()
+            if not table:
+                raise Exception("数据不存在!")
+            if table.table_type == 0:
+                raise Exception("非空间数据!")
+
+            database:Database = table.relate_database
+            pg_ds:DataSource = PGUtil.open_pg_data_source(0,DES.decode(database.sqlalchemy_uri))
+            layer:Layer = pg_ds.GetLayerByName(table.name)
+
+            res["data"] = []
+
+            schema = layer.schema
+            for s in schema:
+                field :FieldDefn = s
+                d1 = field.GetName()
+                d2 = field.GetTypeName()
+                res["data"].append({"name":field.GetName(),"type":field.GetTypeName(),"pricision":field.GetWidth()})
+            res["result"] = True
+
+        except Exception as e:
+            raise e
+        finally:
+            if pg_ds:
+                pg_ds.Destroy()
+        return res
+
+
+
+
+    api_doc={
+    "tags":["要素接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string",
+         "description": "guid"}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

@@ -85,18 +85,12 @@ class Api(ApiTemplate):
             if parameter.get("tilecol"):
             if parameter.get("tilecol"):
                 self.col = int(parameter.get("tilecol"))
                 self.col = int(parameter.get("tilecol"))
 
 
-
-
             image_type = parameter.get("format") if parameter.get("format") else "image/png"
             image_type = parameter.get("format") if parameter.get("format") else "image/png"
-
             quality = int(parameter.get("quality")) if parameter.get("quality") else 30
             quality = int(parameter.get("quality")) if parameter.get("quality") else 30
-
             slice_para = json.loads(image_service.slice_scheme)
             slice_para = json.loads(image_service.slice_scheme)
-
             extent = SliceScheme.get_polygon(slice_para, self.level, self.row, self.col)
             extent = SliceScheme.get_polygon(slice_para, self.level, self.row, self.col)
 
 
             # 结果矩阵
             # 结果矩阵
-
             empty_list = [numpy.zeros((256, 256), dtype=int) + 65536,
             empty_list = [numpy.zeros((256, 256), dtype=int) + 65536,
                           numpy.zeros((256, 256), dtype=int) + 65536,
                           numpy.zeros((256, 256), dtype=int) + 65536,
                           numpy.zeros((256, 256), dtype=int) + 65536]
                           numpy.zeros((256, 256), dtype=int) + 65536]
@@ -108,134 +102,23 @@ class Api(ApiTemplate):
             pixel_array = numpy.zeros((256, 256,3), dtype=int)
             pixel_array = numpy.zeros((256, 256,3), dtype=int)
 
 
             for image in intersect_image:
             for image in intersect_image:
-
                 if image.host.__eq__("本地服务器"):
                 if image.host.__eq__("本地服务器"):
-
-                    pixel_array = numpy.zeros((256, 256, 3), dtype=int)
-                    ceng = 0
-                    img: Dataset = gdal.Open(image.path, 0)
-                    t1 = time.time()
-                    for band in bands:
-
-                        # 自决定金字塔等级
-                        xysize = [img.RasterXSize, img.RasterYSize]
-                        origin_extent = image.extent
-                        band_data: Band = img.GetRasterBand(band)
-                        max_level = band_data.GetOverviewCount()
-
-                        # 超出空间范围
-                        if extent[2] < origin_extent[0] or extent[0] > origin_extent[2] or extent[1] > origin_extent[
-                            3] or extent[3] < origin_extent[1]:
-                            empty = numpy.zeros((256, 256), dtype=int) + 65536
-                        # 空间范围相交
-                        else:
-                            image_level = self.determine_level(xysize, origin_extent, extent, max_level)
-
-                            if image_level == -1:
-                                overview = band_data
-                            else:
-                                try:
-                                    overview: Band = band_data.GetOverview(image_level)
-                                except:
-                                    raise Exception("该影像不存在该级别的金字塔数据！")
-                            ox = overview.XSize
-                            oy = overview.YSize
-
-                            # 网格大小
-                            grid_x = (origin_extent[2] - origin_extent[0]) / (ox * 1.0)
-                            grid_y = (origin_extent[3] - origin_extent[1]) / (oy * 1.0)
-
-                            # 完全在影像范围内
-                            if extent[0] > origin_extent[0] and extent[1] > origin_extent[1] and extent[2] < \
-                                    origin_extent[2] and extent[3] < origin_extent[3]:
-
-                                # 网格偏移量
-                                off_x = math.floor((extent[0] - origin_extent[0]) / grid_x)
-                                off_y = math.floor((origin_extent[3] - extent[3]) / grid_y)
-
-                                # 截取后网格个数
-                                x_g = math.ceil((extent[2] - extent[0]) / grid_x)
-
-                                y_g = math.ceil((extent[3] - extent[1]) / grid_y)
-
-                                empty = overview.ReadAsArray(off_x, off_y, x_g, y_g, 256, 256)
-
-
-                            # 部分相交
-                            else:
-
-                                inter_extent = [0, 0, 0, 0]
-                                inter_extent[0] = origin_extent[0] if origin_extent[0] > extent[0] else extent[0]
-                                inter_extent[1] = origin_extent[1] if origin_extent[1] > extent[1] else extent[1]
-                                inter_extent[2] = origin_extent[2] if origin_extent[2] < extent[2] else extent[2]
-                                inter_extent[3] = origin_extent[3] if origin_extent[3] < extent[3] else extent[3]
-
-                                # 网格偏移量
-                                off_x = math.floor((inter_extent[0] - origin_extent[0]) / grid_x)
-                                off_y = math.floor((origin_extent[3] - inter_extent[3]) / grid_y)
-
-                                # 截取后网格个数
-                                x_g = math.floor((inter_extent[2] - inter_extent[0]) / grid_x)
-                                y_g = math.floor((inter_extent[3] - inter_extent[1]) / grid_y)
-
-                                # 相对于出图的偏移量
-
-                                # 出图的网格大小
-                                out_grid_x = (extent[2] - extent[0]) / (256 * 1.0)
-                                out_grid_y = (extent[3] - extent[1]) / (256 * 1.0)
-
-                                out_off_x = int(math.ceil((inter_extent[0] - extent[0]) / out_grid_x))
-                                out_off_y = int(math.ceil((extent[3] - inter_extent[3]) / out_grid_y))
-
-                                out_x_g = int(math.floor((inter_extent[2] - inter_extent[0]) / out_grid_x))
-                                out_y_g = int(math.floor((inter_extent[3] - inter_extent[1]) / out_grid_y))
-
-                                # 相交部分在出图的哪个位置
-
-                                overview_raster: ndarray = overview.ReadAsArray(off_x, off_y, x_g, y_g, out_x_g,
-                                                                                out_y_g)
-
-                                dat = numpy.zeros((256, 256), dtype=int) + 65536
-                                dat[out_off_y:out_off_y + out_y_g, out_off_x:out_off_x + out_x_g] = overview_raster
-
-                                empty = dat
-
-                        pixel_array[:, :, ceng] = empty
-                        ceng += 1
-
-                    data = pixel_array
-
+                    data = self.get_local_data(image,extent,bands)
                 else:
                 else:
                     ser = "{}:{}".format(image.host,image.port)
                     ser = "{}:{}".format(image.host,image.port)
                     if zoo.exists("/rpc/{}".format(ser)):
                     if zoo.exists("/rpc/{}".format(ser)):
-
-                        transport = TSocket.TSocket(image.host, image.port)
-                        transport = TTransport.TBufferedTransport(transport)
-                        protocol = TBinaryProtocol.TBinaryProtocol(transport)
-                        client = ImageDataService.Client(protocol)
-                        transport.open()
-                        t1 = time.time()
-                        data = client.getData(image.path, extent, json.loads(image.extent), bands)
-                        transport.close()
-                        current_app.logger.info("time {}".format(time.time()-t1))
-
-                        data = gzip.decompress(data)
-                        data = numpy.frombuffer(data, dtype=int)
-                        data= data.reshape((256, 256, 3))
+                        data= self.get_remote_data(image,extent,bands)
                     else:
                     else:
                         data = numpy.zeros((256, 256, 3), dtype=int) + 65536
                         data = numpy.zeros((256, 256, 3), dtype=int) + 65536
 
 
-
                 # 掩膜在中央接口生成
                 # 掩膜在中央接口生成
                 mask = numpy.zeros((256, 256), dtype=int)
                 mask = numpy.zeros((256, 256), dtype=int)
                 mask2 = numpy.zeros((256, 256), dtype=int)
                 mask2 = numpy.zeros((256, 256), dtype=int)
                 jizhun = data[:, :, 0]
                 jizhun = data[:, :, 0]
-
                 mask[jizhun == 65536] = 1
                 mask[jizhun == 65536] = 1
                 mask[jizhun != 65536] = 0
                 mask[jizhun != 65536] = 0
                 mask2[jizhun == 65536] = 0
                 mask2[jizhun == 65536] = 0
                 mask2[jizhun != 65536] = 1
                 mask2[jizhun != 65536] = 1
-
                 # 掩膜计算
                 # 掩膜计算
                 for i, d in enumerate(empty_list):
                 for i, d in enumerate(empty_list):
                     empty_list[i] = empty_list[i] * mask + data[:, :, i] * mask2
                     empty_list[i] = empty_list[i] * mask + data[:, :, i] * mask2
@@ -290,7 +173,7 @@ class Api(ApiTemplate):
             image_out = buf.tobytes()
             image_out = buf.tobytes()
         return image_out
         return image_out
 
 
-    def get_data(self,image,extent,bands):
+    def get_remote_data(self,image,extent,bands):
         '''
         '''
         通过RPC获取远程数据
         通过RPC获取远程数据
         :param image:
         :param image:
@@ -298,16 +181,123 @@ class Api(ApiTemplate):
         :param bands:
         :param bands:
         :return:
         :return:
         '''
         '''
+
         transport = TSocket.TSocket(image.host, image.port)
         transport = TSocket.TSocket(image.host, image.port)
         transport = TTransport.TBufferedTransport(transport)
         transport = TTransport.TBufferedTransport(transport)
         protocol = TBinaryProtocol.TBinaryProtocol(transport)
         protocol = TBinaryProtocol.TBinaryProtocol(transport)
         client = ImageDataService.Client(protocol)
         client = ImageDataService.Client(protocol)
-
         transport.open()
         transport.open()
-        data = client.getData(image.path,extent,json.loads(image.extent), bands)
+        t1 = time.time()
+        data = client.getData(image.path, extent, json.loads(image.extent), bands)
         transport.close()
         transport.close()
+        current_app.logger.info("time {}".format(time.time() - t1))
+
+        data = gzip.decompress(data)
+        data = numpy.frombuffer(data, dtype=int)
+        data = data.reshape((256, 256, 3))
+
+        return data
+
+    def get_local_data(self,image,extent,bands):
+        '''
+        获取本地数据
+        :param image:
+        :param extent:
+        :param bands:
+        :return:
+        '''
+        pixel_array = numpy.zeros((256, 256, 3), dtype=int)
+        ceng = 0
+        img: Dataset = gdal.Open(image.path, 0)
+        t1 = time.time()
+        for band in bands:
+
+            # 自决定金字塔等级
+            xysize = [img.RasterXSize, img.RasterYSize]
+            origin_extent = image.extent
+            band_data: Band = img.GetRasterBand(band)
+            max_level = band_data.GetOverviewCount()
+
+            # 超出空间范围
+            if extent[2] < origin_extent[0] or extent[0] > origin_extent[2] or extent[1] > origin_extent[
+                3] or extent[3] < origin_extent[1]:
+                empty = numpy.zeros((256, 256), dtype=int) + 65536
+            # 空间范围相交
+            else:
+                image_level = self.determine_level(xysize, origin_extent, extent, max_level)
+
+                if image_level == -1:
+                    overview = band_data
+                else:
+                    try:
+                        overview: Band = band_data.GetOverview(image_level)
+                    except:
+                        raise Exception("该影像不存在该级别的金字塔数据！")
+                ox = overview.XSize
+                oy = overview.YSize
+
+                # 网格大小
+                grid_x = (origin_extent[2] - origin_extent[0]) / (ox * 1.0)
+                grid_y = (origin_extent[3] - origin_extent[1]) / (oy * 1.0)
+
+                # 完全在影像范围内
+                if extent[0] > origin_extent[0] and extent[1] > origin_extent[1] and extent[2] < \
+                        origin_extent[2] and extent[3] < origin_extent[3]:
+
+                    # 网格偏移量
+                    off_x = math.floor((extent[0] - origin_extent[0]) / grid_x)
+                    off_y = math.floor((origin_extent[3] - extent[3]) / grid_y)
+
+                    # 截取后网格个数
+                    x_g = math.ceil((extent[2] - extent[0]) / grid_x)
+
+                    y_g = math.ceil((extent[3] - extent[1]) / grid_y)
+
+                    empty = overview.ReadAsArray(off_x, off_y, x_g, y_g, 256, 256)
+
+
+                # 部分相交
+                else:
+
+                    inter_extent = [0, 0, 0, 0]
+                    inter_extent[0] = origin_extent[0] if origin_extent[0] > extent[0] else extent[0]
+                    inter_extent[1] = origin_extent[1] if origin_extent[1] > extent[1] else extent[1]
+                    inter_extent[2] = origin_extent[2] if origin_extent[2] < extent[2] else extent[2]
+                    inter_extent[3] = origin_extent[3] if origin_extent[3] < extent[3] else extent[3]
+
+                    # 网格偏移量
+                    off_x = math.floor((inter_extent[0] - origin_extent[0]) / grid_x)
+                    off_y = math.floor((origin_extent[3] - inter_extent[3]) / grid_y)
+
+                    # 截取后网格个数
+                    x_g = math.floor((inter_extent[2] - inter_extent[0]) / grid_x)
+                    y_g = math.floor((inter_extent[3] - inter_extent[1]) / grid_y)
+
+                    # 相对于出图的偏移量
+
+                    # 出图的网格大小
+                    out_grid_x = (extent[2] - extent[0]) / (256 * 1.0)
+                    out_grid_y = (extent[3] - extent[1]) / (256 * 1.0)
+
+                    out_off_x = int(math.ceil((inter_extent[0] - extent[0]) / out_grid_x))
+                    out_off_y = int(math.ceil((extent[3] - inter_extent[3]) / out_grid_y))
+
+                    out_x_g = int(math.floor((inter_extent[2] - inter_extent[0]) / out_grid_x))
+                    out_y_g = int(math.floor((inter_extent[3] - inter_extent[1]) / out_grid_y))
+
+                    # 相交部分在出图的哪个位置
+
+                    overview_raster: ndarray = overview.ReadAsArray(off_x, off_y, x_g, y_g, out_x_g,
+                                                                    out_y_g)
+
+                    dat = numpy.zeros((256, 256), dtype=int) + 65536
+                    dat[out_off_y:out_off_y + out_y_g, out_off_x:out_off_x + out_x_g] = overview_raster
+
+                    empty = dat
 
 
-        return numpy.array(json.loads(data))
+            pixel_array[:, :, ceng] = empty
+            ceng += 1
+        return pixel_array
 
 
     def determin_intersect(self,extent1,extent2):
     def determin_intersect(self,extent1,extent2):
         g1 = GeometryAdapter.envelop_2_polygon(extent1)
         g1 = GeometryAdapter.envelop_2_polygon(extent1)

@@ -4,11 +4,11 @@
 #email:         nheweijun@sina.com
 #email:         nheweijun@sina.com
 
 
 
 
-from sqlalchemy import Column, Integer, String, ForeignKey, Text, DateTime, Time
+from sqlalchemy import Column, Integer, String, ForeignKey, Text, DateTime, Time,Binary
 from app.models import db
 from app.models import db
-from sqlalchemy.ext.declarative import declarative_base
 
 
-Base = declarative_base()
+
+
 class Image(db.Model):
 class Image(db.Model):
     '''
     '''
     影像元数据
     影像元数据
@@ -27,7 +27,10 @@ class Image(db.Model):
     path=Column(String)
     path=Column(String)
     host=Column(String)
     host=Column(String)
     port=Column(Integer)
     port=Column(Integer)
-
+    #坐标wkt
+    projection = Column(Text)
+    #年份
+    ym= Column(String(256))
 
 
 dmdms_image_rel = db.Table('dmdms_image_rel',
 dmdms_image_rel = db.Table('dmdms_image_rel',
     Column('image_guid',String, ForeignKey('dmdms_image.guid')),
     Column('image_guid',String, ForeignKey('dmdms_image.guid')),
@@ -50,6 +53,10 @@ class ImageService(db.Model):
     description = Column(Text)
     description = Column(Text)
     slice_scheme = Column(Text)
     slice_scheme = Column(Text)
     extent = Column(String(256))
     extent = Column(String(256))
+    #可视范围geojson
+    visual_range = Column(Text)
+    #影像服务缩略图
+    overview = Column(Binary)
     images  = db.relationship('Image',
     images  = db.relationship('Image',
                               secondary=dmdms_image_rel,
                               secondary=dmdms_image_rel,
                               backref='image_services',
                               backref='image_services',

@@ -37,7 +37,7 @@ class Api(ApiTemplate):
     
     
             sort = int(self.para.get("sort","1"))
             sort = int(self.para.get("sort","1"))
             if sort.__eq__(1):
             if sort.__eq__(1):
-                tables = Table.query.order_by(Table.update_time.desc())
+                tables = Table.query.order_by(Table.update_time.desc(),Table.name)
             else:
             else:
                 tables = Table.query.order_by(Table.name)
                 tables = Table.query.order_by(Table.name)
     
     

@@ -198,7 +198,7 @@ class Api(ApiTemplate):
 
 
                 # 范围统计和数量统计以100w为界限
                 # 范围统计和数量统计以100w为界限
                 query_count_layer: Layer = pg_ds.ExecuteSQL(
                 query_count_layer: Layer = pg_ds.ExecuteSQL(
-                    "SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public.{}'::regclass".format(
+                    '''SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public."{}"'::regclass'''.format(
                         l_name))
                         l_name))
                 feature_count = query_count_layer.GetFeature(0).GetField("ec")
                 feature_count = query_count_layer.GetFeature(0).GetField("ec")
                 # 要素少于100w可以精确统计
                 # 要素少于100w可以精确统计
@@ -223,7 +223,7 @@ class Api(ApiTemplate):
                               database_guid=database.guid,
                               database_guid=database.guid,
                               # alias=layer.GetName(),
                               # alias=layer.GetName(),
                               name=layer.GetName(), create_time=this_time, update_time=this_time,
                               name=layer.GetName(), create_time=this_time, update_time=this_time,
-                              table_type=GeometryAdapter.get_table_type(layer.GetGeomType()),
+                              table_type=GeometryAdapter.get_table_type(GeometryAdapter.get_geometry_type(layer)),
                               extent=extent,
                               extent=extent,
                               feature_count=feature_count
                               feature_count=feature_count
                               )
                               )
@@ -331,7 +331,7 @@ class Api(ApiTemplate):
 
 
                 # 范围统计和数量统计以100w为界限
                 # 范围统计和数量统计以100w为界限
                 query_count_layer: Layer = pg_ds.ExecuteSQL(
                 query_count_layer: Layer = pg_ds.ExecuteSQL(
-                    "SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public.{}'::regclass".format(
+                    '''SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public."{}"'::regclass'''.format(
                         l_name))
                         l_name))
                 feature_count = query_count_layer.GetFeature(0).GetField("ec")
                 feature_count = query_count_layer.GetFeature(0).GetField("ec")
                 # 要素少于100w可以精确统计
                 # 要素少于100w可以精确统计

+# 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
+
+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(geo:Geometry,offx,offy):
+
+    g = geo.GetGeometryRef(0)
+    num = g.GetPointCount()
+
+    coor = []
+    try:
+        for j in range(num):
+            point = g.GetPoint(j)
+            x = point[0]
+            y = point[1]
+            x += offx
+            y += offy
+            coor.append([x, y])
+        if num==1:
+            point = ogr.Geometry(ogr.wkbPoint)
+            point.AddPoint(coor[0][0], coor[0][1])
+            return point
+        elif coor[0].__eq__(coor[-1]):
+            ring = ogr.Geometry(ogr.wkbLinearRing)
+            for co in coor:
+                ring.AddPoint(co[0], co[1])
+            poly = ogr.Geometry(ogr.wkbPolygon)
+            poly.AddGeometry(ring)
+            return poly
+        else :
+            line = ogr.Geometry(ogr.wkbLineString)
+            for co in coor:
+                line.AddPoint(co[0], co[1])
+            return line
+    except:
+        return None
+
+
+def copydata():
+
+
+    bound = ""
+
+    work_dir =r"E:\D2\桌面\FSSD_RES_PY_FWM"
+
+    data_path=r"E:\D2\桌面\FSSD_RES_PY_FWM\fs4326.shp"
+
+    base_name="fs900w"
+
+    driver: Driver = ogr.GetDriverByName("ESRI Shapefile")
+    ds: DataSource = driver.Open(data_path, 1)
+
+    bound_ds : DataSource = driver.Open(bound, 1)
+    bound_layer :Layer = bound_ds.GetLayer(0)
+    bound_geom = bound_layer.GetNextFeature().GetGeometryRef()
+
+
+    if not ds:
+        raise Exception("打开数据失败！")
+
+    layer: Layer = ds.GetLayer(0)
+
+
+
+    schema = layer.schema
+    schema = [s for s in schema if not s.GetName().lower().__eq__("objectid")]
+    for s in schema :
+        if s.GetName().lower().__eq__("objectid") and not s.GetTypeName().__eq__("Interger"):
+            s.SetType(ogr.OFTInteger)
+
+
+
+    gdb_driver:Driver = ogr.GetDriverByName("FileGDB")
+    gdb_ds: DataSource = gdb_driver.CreateDataSource(os.path.join(work_dir,"{}.gdb".format(base_name)))
+    gdb_layer:Layer = gdb_ds.CreateLayer(base_name,  layer.GetSpatialRef(),layer.GetGeomType())
+
+    # gdb_layer.CreateFields(schema)
+
+    print(gdb_layer.GetFIDColumn())
+
+    extent = layer.GetExtent()
+    xxrange=extent[1]-extent[0]
+    yrange = extent[3]-extent[2]
+    feature_defn: FeatureDefn = layer.GetLayerDefn()
+
+    begin = time.time()
+    count=0
+    work_dir =os.path.dirname(os.path.abspath(__file__))
+
+    for f in layer:
+
+        if count%10000==0:
+            print(count)
+            with open(os.path.join(work_dir, "copy.txt"), "w") as fi:
+                fi.write("已完成{}".format(count))
+        g:Geometry=f.GetGeometryRef()
+        new_f:Feature = copy.copy(f)
+        for xt in range(3):
+            for yt in range(3):
+                out_g = move(g,xxrange*xt,yrange*yt)
+                new_f.SetGeometry(out_g)
+                new_f.SetFID(count)
+                dd:FieldDefn=new_f.GetField("OBJECTID")
+                # new_f.UnsetField("OBJECTID")
+                gdb_layer.CreateFeature(new_f)
+                count += 1
+
+    print(time.time()-begin)
+
+    gdb_ds.Destroy()
+
+
+
+if __name__ == '__main__':
+    copydata()
+
+
+
+
+
+
+
+
+
+
+

@@ -323,7 +323,7 @@ class ThisTask:
                       database_guid=self.database.guid,
                       database_guid=self.database.guid,
                       creator=creator,
                       creator=creator,
                       name=new_layer_name, create_time=this_time, update_time=this_time,
                       name=new_layer_name, create_time=this_time, update_time=this_time,
-                      catalog_guid=self.catalog_guid, table_type=GeometryAdapter.get_table_type(layer.GetGeomType()),
+                      catalog_guid=self.catalog_guid, table_type=GeometryAdapter.get_table_type(GeometryAdapter.get_geometry_type(layer)),
                       extent=extent,
                       extent=extent,
                       feature_count=layer.GetFeatureCount(),
                       feature_count=layer.GetFeatureCount(),
                       is_vacuate=is_vacuate
                       is_vacuate=is_vacuate

@@ -152,4 +152,21 @@ class GeometryAdapter:
         # Create polygon
         # Create polygon
         poly = ogr.Geometry(ogr.wkbPolygon)
         poly = ogr.Geometry(ogr.wkbPolygon)
         poly.AddGeometry(ring)
         poly.AddGeometry(ring)
-        return poly
+        return poly
+
+    @classmethod
+    def tuple_2_point(cls,tup):
+        point = ogr.Geometry(ogr.wkbPoint)
+        point.AddPoint(tup[0], tup[1])
+        return point
+
+    @classmethod
+    def get_geometry_type(cls,layer):
+        geom_type = layer.GetGeomType()
+        if geom_type.__eq__(0):
+            fea = layer.GetNextFeature()
+            if fea:
+                g: Geometry = fea.geometry()
+                geom_type = g.GetGeometryType()
+            layer.ResetReading()
+        return geom_type

+# coding=utf-8
+#author:        4N
+#createtime:    2021/8/13
+#email:         nheweijun@sina.com
+
+class GzipUtil:
+
+
+    @classmethod
+    def dict_gzip(cls):
+        pass

+# coding=utf-8
+#author:        4N
+#createtime:    2021/8/12
+#email:         nheweijun@sina.com
+from osgeo.ogr import Layer,Feature
+import json
+
+
+class LayerUtil:
+
+    @classmethod
+    def layer_to_feature_collection(cls,layer,limit=None):
+        '''
+        图层转feature collection
+        :param layer:
+        :param limit: 读取限制数
+        :return:
+        '''
+        feature_collection = dict()
+        feature_collection["type"]="FeatureCollection"
+        feature_collection["features"] = []
+        count = 0
+        for feature in layer :
+            feature:Feature = feature
+            feature_collection["features"].append(json.loads(feature.ExportToJson()))
+            #超过限制不再读取
+            if limit:
+                if count>limit:
+                    break
+        return feature_collection

@@ -27,6 +27,11 @@ class PGUtil:
 
 
     @classmethod
     @classmethod
     def get_info_from_sqlachemy_uri(cls,uri):
     def get_info_from_sqlachemy_uri(cls,uri):
+        '''
+        解析sqlachemy_uri
+        :param uri:
+        :return:
+        '''
         parts = uri.split(":")
         parts = uri.split(":")
         user = parts[1][2:]
         user = parts[1][2:]
 
 
@@ -51,7 +56,12 @@ class PGUtil:
 
 
     @classmethod
     @classmethod
     def get_geo_column(cls,table_name,db_session):
     def get_geo_column(cls,table_name,db_session):
+        '''
         # 判断空间列
         # 判断空间列
+        :param table_name:
+        :param db_session:
+        :return:
+        '''
         geom_col_sql = '''
         geom_col_sql = '''
         SELECT a.attname AS field,t.typname AS type
         SELECT a.attname AS field,t.typname AS type
         FROM
         FROM
@@ -74,7 +84,13 @@ class PGUtil:
 
 
     @classmethod
     @classmethod
     def get_table_count(cls,table_name,db_session):
     def get_table_count(cls,table_name,db_session):
-        count_result = db_session.execute("SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public.{}'::regclass".format(
+        '''
+        获取图层数量
+        :param table_name:
+        :param db_session:
+        :return:
+        '''
+        count_result = db_session.execute('''SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public."{}"'::regclass'''.format(
             table_name)).fetchone()
             table_name)).fetchone()
         count = count_result[0]
         count = count_result[0]
         if count< 1000000:
         if count< 1000000:
@@ -84,6 +100,11 @@ class PGUtil:
 
 
     @classmethod
     @classmethod
     def check_space(cls, sqlachemy_uri):
     def check_space(cls, sqlachemy_uri):
+        '''
+        判断数据库是否为空间库
+        :param sqlachemy_uri:
+        :return:
+        '''
         system_session = None
         system_session = None
         check = True
         check = True
         try:
         try:

+# coding=utf-8
+#author:        4N
+#createtime:    2021/8/18
+#email:         nheweijun@sina.com
+import random
+
+def create(extent,example:dict,path,num):
+    with open(path, 'w') as f:
+        each_num = int(num/len(example.keys()))
+        for i in range(each_num):
+            for ext in example.values():
+                x_leng = ext[2] - ext[0]
+                y_leng = ext[3] - ext[1]
+                randomx = random.random() * (extent[2] - extent[0]) + extent[0]
+                randomy = random.random() * (extent[3] - extent[1]) + extent[1]
+
+                wms = [randomx, randomy, randomx + x_leng, randomy + y_leng]
+                wms = [str(x) for x in wms]
+                f.write(",".join(wms))
+                f.write("\n")
+
+
+
+if __name__ == '__main__':
+    extent=[113.060008,22.765613,115.062014,24.470024]
+
+    example={"10km":[114.2578125, 23.37890625, 114.43359375, 23.5546875],
+             "5km": [113.73046875, 23.466796875, 113.818359375, 23.5546875],
+             "3km": [114.1259765625, 23.466796875, 114.169921875, 23.5107421875],
+             "1km": [113.97216796875, 23.48876953125, 113.994140625, 23.5107421875],
+             "500m": [113.97216796875, 23.499755859375, 113.983154296875, 23.5107421875],
+             "300m": [113.9886474609375,23.5107421875,113.994140625,23.5162353515625],
+             "200m":[113.9776611328125,23.51348876953125,113.98040771484375,23.5162353515625],
+             "100m":[113.98590087890625,23.52447509765625,113.98727416992188,23.525848388671875],
+             "50":[113.983154296875,23.530654907226562,113.98384094238281,23.531341552734375]}
+    path = "wms.bat"
+    num = 100000
+    create(extent,example,path,num)

+# coding=utf-8
+#author:        4N
+#createtime:    2021/8/18
+#email:         nheweijun@sina.com

@@ -4,8 +4,8 @@
 deploy_ip_host = "172.26.99.160:8840"
 deploy_ip_host = "172.26.99.160:8840"
 # 系统数据库
 # 系统数据库
 
 
-SQLALCHEMY_DATABASE_URI = "postgresql://postgres:postgres@172.26.40.254:5433/dmap_dms_test"
-# SQLALCHEMY_DATABASE_URI = "postgresql://postgres:chinadci@172.26.99.160:5432/dmap_dms_test"
+# SQLALCHEMY_DATABASE_URI = "postgresql://postgres:postgres@172.26.40.254:5433/dmap_dms_test"
+SQLALCHEMY_DATABASE_URI = "postgresql://postgres:chinadci@172.26.99.160:5432/dmap_dms_test"
 
 
 
 
 # 部署模式cluster，standalone
 # 部署模式cluster，standalone

@@ -33,7 +33,7 @@ IncludeOptional conf.d/*.conf
 LoadModule wsgi_module "/usr/lib/apache2/modules/mod_wsgi-py39.cpython-39-x86_64-linux-gnu.so"
 LoadModule wsgi_module "/usr/lib/apache2/modules/mod_wsgi-py39.cpython-39-x86_64-linux-gnu.so"
 WSGIPythonHome "/usr"
 WSGIPythonHome "/usr"
 
 
-WSGIScriptAlias / /usr/DMapManager/run.wsgi
+WSGIScriptAlias /DMapManager /usr/DMapManager/run.wsgi
 <Directory /usr/>
 <Directory /usr/>
   Require all granted
   Require all granted
 </Directory>
 </Directory>

@@ -9,12 +9,25 @@ import numpy
 import gzip
 import gzip
 import sys
 import sys
 import json
 import json
-pixel_array = numpy.empty((256,256,3),dtype=int)+3
+# pixel_array = numpy.empty((256,256,3),dtype=int)+3
+#
+#
+#
+# # 使用gzip 压缩传输
+# content = gzip.compress(pixel_array, 2)
+#
+# print(sys.getsizeof(json.dumps(pixel_array.tolist())))
+# print(sys.getsizeof((content)))
 
 
+def c(dd):
+    return 1
 
 
+dd = numpy.zeros((2000, 2000), dtype=int) + 2
 
 
-# 使用gzip 压缩传输
-content = gzip.compress(pixel_array, 2)
 
 
-print(sys.getsizeof(json.dumps(pixel_array.tolist())))
-print(sys.getsizeof((content)))
+dd[range(0, 5), 1]=1
+
+
+
+
+print(dd)