面向对象优化

@@ -192,7 +192,10 @@ class Service(db.Model):
     __tablename__ = 'dmap_service'
     __tablename__ = 'dmap_service'
     guid = Column(String(256), primary_key=True)
     guid = Column(String(256), primary_key=True)
     name = Column(String(256))
     name = Column(String(256))
-    alias = Column(String(256))
+    # alias = Column(String(256))
+
+    title = Column(String(256))
+
     #服务状态
     #服务状态
     state= Column(Integer)
     state= Column(Integer)
     create_time = Column(DateTime)
     create_time = Column(DateTime)
@@ -217,7 +220,6 @@ class ServiceCatalog(db.Model):
     '''
     '''
     __tablename__ = 'dmap_service_catalog'
     __tablename__ = 'dmap_service_catalog'
     guid = Column(String(256), primary_key=True)
     guid = Column(String(256), primary_key=True)
-    database_guid = Column(String(256), ForeignKey('dmap_database.guid'))
     pguid = Column(String(256))
     pguid = Column(String(256))
     path = Column(Text)
     path = Column(Text)
     name = Column(String(256))
     name = Column(String(256))

@@ -8,7 +8,7 @@ from app.util import BlueprintApi
 
 
 from flask import send_from_directory
 from flask import send_from_directory
 import os
 import os
-from . import data_download
+from . import data_download,data_download_task
 from . import get_meta
 from . import get_meta
 from . import data_entry_by_meta
 from . import data_entry_by_meta
 from . import get_data_list
 from . import get_data_list
@@ -64,6 +64,15 @@ class DataManager(BlueprintApi):
         """
         """
         return data_download.Api().result
         return data_download.Api().result
 
 
+    @staticmethod
+    @bp.route('/DataDownloadTask', methods=['POST'])
+    @swag_from(data_download_task.Api.api_doc)
+    def api_data_download_task():
+        """
+        下载数据任务
+        """
+        return data_download_task.Api().result
+
 
 
     @staticmethod
     @staticmethod
     @bp.route('/GetMeta', methods=['POST'])
     @bp.route('/GetMeta', methods=['POST'])

+# coding=utf-8
+#author:        4N
+#createtime:    2020/11/27
+#email:         nheweijun@sina.com
+
+
+from app.models import *
+
+import traceback
+
+from osgeo.ogr import DataSource,Layer,FeatureDefn,FieldDefn,Feature
+from osgeo import gdal,ogr
+import os
+import uuid
+import configure
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+from app.util.component.ZipUtil import ZipUtil
+import multiprocessing
+
+class Api(ApiTemplate):
+
+    def process(self):
+
+        res = {}
+        #获取参数
+        try:
+
+            task_guid = uuid.uuid1().__str__()
+            download_process = multiprocessing.Process(target=self.download, args=(task_guid,self.para))
+
+            task = Task(guid=task_guid,
+                        name="{}下载".format(self.para.get("table_name")),
+                        create_time=datetime.datetime.now(),
+                        state=0,
+                        task_type=4,
+                        creator=self.para.get("creator"),
+                        file_name=None,
+                        process="数据下载中",
+                        database_guid=self.para.get("database_guid"))
+
+            db.session.add(task)
+            db.session.commit()
+            download_process.start()
+
+            res["data"] = "下载任务已提交!"
+            res["state"] = True
+
+        except Exception as e:
+            raise e
+        return res
+
+
+    def download(self,task_guid,para):
+
+        sys_session = None
+        ds: DataSource = None
+
+        # 设置编码
+        encoding = para.get("encoding")
+        if encoding:
+            gdal.SetConfigOption("SHAPE_ENCODING", encoding)
+        else:
+            gdal.SetConfigOption("SHAPE_ENCODING", "UTF-8")
+
+        try:
+
+            sys_session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
+
+            table_names = para.get("table_name").split(",")
+            database_guid = para.get("database_guid")
+            database = sys_session.query(Database).filter_by(guid=database_guid).one_or_none()
+            if not database:
+                raise Exception("数据库不存在！")
+
+            ds: DataSource = PGUtil.open_pg_data_source(0, DES.decode(database.sqlalchemy_uri))
+
+            download_type = para.get("download_type")
+
+            data = None
+            if download_type.__eq__("shp"):
+                data = self.download_shp(table_names, ds)
+            if download_type.__eq__("gdb"):
+                data = self.download_gdb(sys_session,table_names, ds, database_guid)
+
+            sys_session.query(Task).filter_by(guid=task_guid).update({"state":1,"update_time":datetime.datetime.now(),
+                                                                      "process" : "下载完成",
+                                                                      "parameter":data[0]["download_url"]})
+            sys_session.commit()
+
+
+        except Exception as e:
+            try:
+                sys_session.query(Task).filter_by(guid=task_guid).update({"state": -1,"update_time":datetime.datetime.now(),
+                                                                          "process": "下载失败"})
+
+                message = "{} {}".format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e.__str__())
+                task_process_guid = uuid.uuid1().__str__()
+                task_process = Process(guid=task_process_guid, message=message, time=datetime.datetime.now(),
+                                       task_guid=task_guid)
+                sys_session.add(task_process)
+                sys_session.commit()
+            except Exception as ee:
+                print(traceback.format_exc())
+            raise e
+        finally:
+            try:
+                if ds:
+                    ds.Destroy()
+                if sys_session:
+                    sys_session.close()
+            except:
+                print(traceback.format_exc())
+    
+    
+    def download_shp(self,table_names,ds):
+        data = []
+        for table_name in table_names:
+            url = self.download_one(ds, table_name)
+            data.append({"name": table_name, "download_url": url})
+        return data
+    
+    def download_one(self,ds,table_name):
+    
+        layer: Layer = ds.GetLayerByName(table_name)
+        driver = ogr.GetDriverByName("ESRI Shapefile")
+        uuid_ = uuid.uuid1().__str__()
+        parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        dirpath = os.path.join(parent, "file_tmp", uuid_)
+        os.makedirs(dirpath)
+        data_source: DataSource = driver.CreateDataSource(dirpath + "/{}.shp".format(table_name))
+        # data_source.CopyLayer(layer, table_name)
+
+        fid = layer.GetFIDColumn()
+        pg_layer: Layer = data_source.CreateLayer(table_name, layer.GetSpatialRef(), layer.GetGeomType())
+        schema = [sche for sche in layer.schema if not sche.name.__eq__(fid)]
+
+        pg_layer.CreateFields(schema)
+        layer.ResetReading()
+        for feature in layer:
+            pg_layer.CreateFeature(feature)
+
+        data_source.Destroy()
+
+
+        ZipUtil.create_zip(os.path.join(parent, "file_tmp", table_name+"_"+uuid_) + ".zip", [dirpath])
+
+        return "http://" + configure.deploy_ip_host + "/API/IO/Download/{}".format(table_name+"_"+uuid_ + ".zip")
+    
+    
+    def download_gdb(self,sys_session,table_names,ds,database_guid):
+        ogr.RegisterAll()
+        data = []
+        gdal.UseExceptions()
+        gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES")
+    
+        # 创建一个gdb datasource
+        gdb_driver = ogr.GetDriverByName('FileGDB')
+        uuid_ = uuid.uuid1().__str__()
+        parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        gdb_path = os.path.join(parent, "file_tmp", uuid_+".gdb")
+
+        gdb_ds: DataSource = gdb_driver.CreateDataSource(gdb_path)
+    
+    
+        for table_name in table_names:
+    
+            layer: Layer = ds.GetLayerByName(table_name)
+            table = sys_session.query(Table).filter_by(name=table_name, database_guid=database_guid).one_or_none()
+            feature_defn: FeatureDefn = layer.GetLayerDefn()
+    
+            for i in range(feature_defn.GetFieldCount()):
+                field_defn:FieldDefn = feature_defn.GetFieldDefn(i)
+                field_alias = sys_session.query(Columns).filter_by(table_guid=table.guid,name=field_defn.GetName()).one_or_none().alias
+                field_defn.SetAlternativeName(field_alias)
+    
+            table_alias= table.alias
+    
+            # if is_chinese(table_name):
+            #     if not table_alias:
+            #         table_alias = table_name
+            #     table_name = "table{}".format(table_name.__hash__())
+
+            fid = layer.GetFIDColumn()
+            pg_layer: Layer = gdb_ds.CreateLayer(table_name, layer.GetSpatialRef(), layer.GetGeomType(),["LAYER_ALIAS={}".format(table_alias)])
+            schema = [sche for sche in layer.schema if not sche.name.__eq__(fid)]
+            # schema = layer.schema
+            pg_layer.CreateFields(schema)
+
+
+            # gdb 不支持fid=0的要素，所以识别到后要+1
+            offset = 0
+            f1:Feature =  layer.GetNextFeature()
+            if f1:
+                if f1.GetFID().__eq__(0):
+                    offset = 1
+            layer.ResetReading()
+            for feature in layer:
+                feature.SetFID(feature.GetFID()+offset)
+                pg_layer.CreateFeature(feature)
+
+
+            # gdb_ds.CopyLayer(layer, table_name,["LAYER_ALIAS={}".format(table_alias)])
+    
+        gdb_ds.Destroy()
+        ZipUtil.create_zip(gdb_path + ".zip", [gdb_path])
+        data.append({"name": ",".join(table_names), "download_url": "http://" + configure.deploy_ip_host + "/API/IO/Download/{}".format(uuid_+".gdb" + ".zip")})
+
+    
+        return data
+    
+    
+
+
+    api_doc={
+    "tags":["IO接口"],
+    "description":"下载数据",
+    "parameters":[
+        {"name": "table_name",
+         "in": "formData",
+         "type":"string","description":"支持多图层下载，以逗号相隔","required":"true"},
+        {"name": "encoding",
+         "in": "formData",
+         "type": "string",
+         "enum":["GBK","UTF-8"]},
+        {"name": "download_type",
+        "in": "formData",
+        "type": "string",
+        "enum": ["shp", "gdb"],"required":"true"
+        },
+        {"name": "database_guid",
+         "in": "formData",
+         "type": "string","required":"true"
+         },
+        {"name": "creator",
+         "in": "formData",
+         "type": "string"
+         }
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                    "content":{
+                        "type": "string",
+                        "description": "The name of the user"
+                    }
+                }
+            }
+            }
+        }
+}

+# coding=utf-8
+#author:        4N
+#createtime:    2021/10/11
+#email:         nheweijun@sina.com
+
+from app.models import Task
+import configure
+from app.models import InsertingLayerName, Database, DES, Task,Columns
+from sqlalchemy.orm import Session
+import multiprocessing
+from app.util.component.EntryDataVacuate import EntryDataVacuate
+import json
+from sqlalchemy import distinct
+import uuid
+from osgeo.ogr import DataSource
+from app.util.component.StructuredPrint import StructurePrint
+from app.util.component.PGUtil import PGUtil
+import time
+import datetime
+import traceback
+from app.models import Table, Database, DES,Task,db,TableVacuate
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+from app.util.component.EntryDataVacuate import Process
+from app.util.component.SQLUtil import SQLUtil
+import multiprocessing
+import uuid
+import configure
+from osgeo.ogr import DataSource,Layer,Geometry,FieldDefn,FeatureDefn
+from osgeo import ogr
+from app.util.component.StructuredPrint import StructurePrint
+from app.util.component.VacuateConf import VacuateConf
+import datetime
+import traceback
+from app.models import Table, Database, DES,Task,db,TableVacuate,Process
+
+from sqlalchemy.engine import ResultProxy
+from app.util.component.ApiTemplate import ApiTemplate
+
+from app.util.component.StructuredPrint import StructurePrint
+from app.util.component.PGUtil import PGUtil
+import multiprocessing
+import uuid
+import configure
+from osgeo.ogr import DataSource,Layer,Geometry
+from osgeo import ogr
+from app.util.component.VacuateConf import VacuateConf
+from app.util.component.GeometryAdapter import GeometryAdapter
+from app.models import *
+
+import traceback
+
+from osgeo.ogr import DataSource,Layer,FeatureDefn,FieldDefn,Feature
+from osgeo import gdal,ogr
+import os
+import uuid
+import configure
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+from app.util.component.ZipUtil import ZipUtil
+import multiprocessing
+
+
+
+def task_consumer():
+
+    running_dict = {}
+    sys_session: Session = PGUtil.get_db_session(
+        configure.SQLALCHEMY_DATABASE_URI)
+
+    while True:
+
+        try:
+            time.sleep(3)
+
+            # 已经结束的进程 从监测中删除
+            remove_process = []
+
+            # structured_print(running_dict.__len__().__str__())
+
+            for process, layer_names in running_dict.items():
+                if not process.is_alive():
+                    for l in layer_names:
+                        inserted = sys_session.query(
+                            InsertingLayerName).filter_by(name=l).one_or_none()
+                        if inserted:
+                            sys_session.delete(inserted)
+                    sys_session.commit()
+                    remove_process.append(process)
+            for process in remove_process:
+                running_dict.pop(process)
+
+            # StructurePrint().print("listening...")
+
+            # 入库进程少于阈值，开启入库进程
+
+            inter_size = sys_session.query(
+                distinct(InsertingLayerName.task_guid)).count()
+
+            if inter_size < configure.entry_data_thread:
+                # 锁表啊
+                ready_task: Task = sys_session.query(Task).filter_by(state=0).order_by(
+                    Task.create_time).with_lockmode("update").limit(1).one_or_none()
+                if ready_task:
+
+                    if ready_task.task_type == 1:
+                        task_entry_data(ready_task,sys_session,running_dict)
+                    elif ready_task.task_type == 2:
+                        task_table_refresh()
+                    elif ready_task.task_type == 3:
+                        task_vacuate()
+                    elif ready_task.task_type == 4:
+                        task_download()
+
+                else:
+                    # 解表啊
+                    sys_session.commit()
+        except Exception as e:
+            sys_session.commit()
+            StructurePrint().print(e.__str__(), "error")
+
+
+
+def task_download(para,task_guid):
+    sys_session = None
+    ds: DataSource = None
+
+    # 设置编码
+    encoding = para.get("encoding")
+    if encoding:
+        gdal.SetConfigOption("SHAPE_ENCODING", encoding)
+    else:
+        gdal.SetConfigOption("SHAPE_ENCODING", "UTF-8")
+
+    try:
+
+        sys_session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
+
+        table_names = para.get("table_name").split(",")
+        database_guid = para.get("database_guid")
+        database = sys_session.query(Database).filter_by(guid=database_guid).one_or_none()
+        if not database:
+            raise Exception("数据库不存在！")
+
+        ds: DataSource = PGUtil.open_pg_data_source(0, DES.decode(database.sqlalchemy_uri))
+
+        download_type = para.get("download_type")
+
+        data = None
+        if download_type.__eq__("shp"):
+            data = download_shp(table_names, ds)
+        if download_type.__eq__("gdb"):
+            data = download_gdb(sys_session, table_names, ds, database_guid)
+
+        sys_session.query(Task).filter_by(guid=task_guid).update({"state": 1, "update_time": datetime.datetime.now(),
+                                                                  "process": "下载完成",
+                                                                  "parameter": data[0]["download_url"]})
+        sys_session.commit()
+
+
+    except Exception as e:
+        try:
+            sys_session.query(Task).filter_by(guid=task_guid).update(
+                {"state": -1, "update_time": datetime.datetime.now(),
+                 "process": "下载失败"})
+
+            message = "{} {}".format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e.__str__())
+            task_process_guid = uuid.uuid1().__str__()
+            task_process = Process(guid=task_process_guid, message=message, time=datetime.datetime.now(),
+                                   task_guid=task_guid)
+            sys_session.add(task_process)
+            sys_session.commit()
+        except Exception as ee:
+            print(traceback.format_exc())
+        raise e
+    finally:
+        try:
+            if ds:
+                ds.Destroy()
+            if sys_session:
+                sys_session.close()
+        except:
+            print(traceback.format_exc())
+
+
+def download_shp(table_names, ds):
+    data = []
+    for table_name in table_names:
+        url = download_one(ds, table_name)
+        data.append({"name": table_name, "download_url": url})
+    return data
+
+
+def download_one( ds, table_name):
+    layer: Layer = ds.GetLayerByName(table_name)
+    driver = ogr.GetDriverByName("ESRI Shapefile")
+    uuid_ = uuid.uuid1().__str__()
+    parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    dirpath = os.path.join(parent, "file_tmp", uuid_)
+    os.makedirs(dirpath)
+    data_source: DataSource = driver.CreateDataSource(dirpath + "/{}.shp".format(table_name))
+    # data_source.CopyLayer(layer, table_name)
+
+    fid = layer.GetFIDColumn()
+    pg_layer: Layer = data_source.CreateLayer(table_name, layer.GetSpatialRef(), layer.GetGeomType())
+    schema = [sche for sche in layer.schema if not sche.name.__eq__(fid)]
+
+    pg_layer.CreateFields(schema)
+    layer.ResetReading()
+    for feature in layer:
+        pg_layer.CreateFeature(feature)
+
+    data_source.Destroy()
+
+    ZipUtil.create_zip(os.path.join(parent, "file_tmp", table_name + "_" + uuid_) + ".zip", [dirpath])
+
+    return "http://" + configure.deploy_ip_host + "/API/IO/Download/{}".format(table_name + "_" + uuid_ + ".zip")
+
+
+def download_gdb( sys_session, table_names, ds, database_guid):
+    ogr.RegisterAll()
+    data = []
+    gdal.UseExceptions()
+    gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES")
+
+    # 创建一个gdb datasource
+    gdb_driver = ogr.GetDriverByName('FileGDB')
+    uuid_ = uuid.uuid1().__str__()
+    parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    gdb_path = os.path.join(parent, "file_tmp", uuid_ + ".gdb")
+
+    gdb_ds: DataSource = gdb_driver.CreateDataSource(gdb_path)
+
+    for table_name in table_names:
+
+        layer: Layer = ds.GetLayerByName(table_name)
+        table = sys_session.query(Table).filter_by(name=table_name, database_guid=database_guid).one_or_none()
+        feature_defn: FeatureDefn = layer.GetLayerDefn()
+
+        for i in range(feature_defn.GetFieldCount()):
+            field_defn: FieldDefn = feature_defn.GetFieldDefn(i)
+            field_alias = sys_session.query(Columns).filter_by(table_guid=table.guid,
+                                                               name=field_defn.GetName()).one_or_none().alias
+            field_defn.SetAlternativeName(field_alias)
+
+        table_alias = table.alias
+
+        # if is_chinese(table_name):
+        #     if not table_alias:
+        #         table_alias = table_name
+        #     table_name = "table{}".format(table_name.__hash__())
+
+        fid = layer.GetFIDColumn()
+        pg_layer: Layer = gdb_ds.CreateLayer(table_name, layer.GetSpatialRef(), layer.GetGeomType(),
+                                             ["LAYER_ALIAS={}".format(table_alias)])
+        schema = [sche for sche in layer.schema if not sche.name.__eq__(fid)]
+        # schema = layer.schema
+        pg_layer.CreateFields(schema)
+
+        # gdb 不支持fid=0的要素，所以识别到后要+1
+        offset = 0
+        f1: Feature = layer.GetNextFeature()
+        if f1:
+            if f1.GetFID().__eq__(0):
+                offset = 1
+        layer.ResetReading()
+        for feature in layer:
+            feature.SetFID(feature.GetFID() + offset)
+            pg_layer.CreateFeature(feature)
+
+        # gdb_ds.CopyLayer(layer, table_name,["LAYER_ALIAS={}".format(table_alias)])
+
+    gdb_ds.Destroy()
+    ZipUtil.create_zip(gdb_path + ".zip", [gdb_path])
+    data.append({"name": ",".join(table_names),
+                 "download_url": "http://" + configure.deploy_ip_host + "/API/IO/Download/{}".format(
+                     uuid_ + ".gdb" + ".zip")})
+
+    return data
+
+
+def task_entry_data(ready_task,sys_session,running_dict):
+    try:
+        parameter = json.loads(ready_task.parameter)
+        StructurePrint().print("检测到入库任务")
+        ready_task.state = 2
+        ready_task.process = "入库中"
+        sys_session.commit()
+
+        metas: list = json.loads(
+            parameter.get("meta").__str__())
+        parameter["meta"] = metas
+
+        database = sys_session.query(Database).filter_by(
+            guid=ready_task.database_guid).one_or_none()
+        pg_ds: DataSource = PGUtil.open_pg_data_source(
+            1, DES.decode(database.sqlalchemy_uri))
+
+        this_task_layer = []
+        for meta in metas:
+            overwrite = parameter.get("overwrite", "no")
+
+            for layer_name_origin, layer_name in meta.get("layer").items():
+                origin_name = layer_name
+                no = 1
+
+                while (overwrite.__eq__("no") and pg_ds.GetLayerByName(layer_name)) or sys_session.query(
+                        InsertingLayerName).filter_by(name=layer_name).one_or_none():
+                    layer_name = origin_name + "_{}".format(no)
+                    no += 1
+
+                # 添加到正在入库的列表中
+                iln = InsertingLayerName(guid=uuid.uuid1().__str__(),
+                                         task_guid=ready_task.guid,
+                                         name=layer_name)
+
+                sys_session.add(iln)
+                sys_session.commit()
+                this_task_layer.append(layer_name)
+                # 修改表名
+                meta["layer"][layer_name_origin] = layer_name
+
+        pg_ds.Destroy()
+        entry_data_process = multiprocessing.Process(
+            target=EntryDataVacuate().entry, args=(parameter,))
+        entry_data_process.start()
+        running_dict[entry_data_process] = this_task_layer
+    except Exception as e:
+        sys_session.query(Task).filter_by(guid=ready_task.guid).update(
+            {"state": -1, "process": "入库失败"})
+        sys_session.commit()
+        StructurePrint().print(e.__str__(), "error")
+
+
+def task_table_refresh(database,task_guid):
+    pg_ds =None
+    sys_ds =None
+    data_session=None
+    result = {}
+    sys_session = None
+    db_tuple = PGUtil.get_info_from_sqlachemy_uri(DES.decode(database.sqlalchemy_uri))
+
+    try:
+        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()
+        database_guid = database.guid
+
+        # 已注册空间表
+        spatial_tables = sys_session.query(Table).order_by(Table.create_time.desc()).filter_by(database_guid=database_guid).filter(
+            Table.table_type != 0).all()
+
+        # 已注册空间表名
+        spatial_tables_names = [table.name for table in spatial_tables]
+
+        # 实体库datasource
+        pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(database.sqlalchemy_uri))
+
+        # 更新空间表
+        # 增加表
+        db_tables_names = add_spatail_table(database, pg_ds, sys_session,spatial_tables_names, this_time,db_tuple)# 实体库中空间表名
+
+        # 删除/修改表
+        edit_spatial_table(pg_ds, sys_session,spatial_tables, db_tables_names, this_time,db_tuple)
+
+        # 空间表处理完毕
+        sys_session.commit()
+
+
+        # 空间表处理完毕
+        sys_session.commit()
+
+        # 注册普通表
+        # 实体库连接
+        data_session: Session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))
+
+        # 处理后空间表
+        spatial_tables = sys_session.query(Table).order_by(Table.create_time.desc()).filter_by(database_guid=database_guid).filter(
+            Table.table_type != 0).all()
+        # 处理后空间表名
+        spatial_tables_names = [table.name for table in spatial_tables]
+
+        # 原有普通表
+        common_tables = sys_session.query(Table).order_by(Table.create_time.desc()).filter_by(database_guid=database_guid).filter(
+            Table.table_type == 0).all()
+        # 原有普通表 名
+        origin_common_tables_name = [table.name for table in common_tables]
+
+        # 现有普通表
+        real_common_tables_name = []
+
+        # 只注册public中的表
+        common_result = data_session.execute(
+            "select relname as tabname from pg_class c where  relkind = 'r' and relnamespace=2200 and  relname not like 'pg_%' and relname not like 'sql_%' order by relname").fetchall()
+        for re in common_result:
+            table_name = re[0]
+            if table_name not in spatial_tables_names and (not table_name.__contains__("_vacuate_")):
+                real_common_tables_name.append(table_name)
+
+        # 增加新普通表
+
+        add_common_table(data_session, sys_session, database_guid, real_common_tables_name, origin_common_tables_name,
+                              this_time,db_tuple)
+
+        # 删除、修改普通表
+        edit_common_table(data_session,sys_session, database_guid, real_common_tables_name, origin_common_tables_name,
+                               this_time,db_tuple)
+
+        sys_session.commit()
+        result["data"] = "刷新数据成功！"
+        result["state"] = 1
+        sys_session.query(Task).filter_by(guid=task_guid).update(
+            {"state": 1, "update_time": datetime.datetime.now(),"process":"更新成功"})
+        sys_session.commit()
+
+    except Exception as e:
+        try:
+            print(traceback.format_exc())
+            sys_session.query(Task).filter_by(guid=task_guid).update(
+                {"state": -1, "update_time": datetime.datetime.now(),"process":"更新失败"})
+            message = "{} {}".format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e.__str__())
+            task_process_guid = uuid.uuid1().__str__()
+            task_process = Process(guid=task_process_guid, message=message, time=datetime.datetime.now(),
+                                   task_guid=task_guid)
+            sys_session.add(task_process)
+            sys_session.commit()
+        except Exception as ee:
+            print(traceback.format_exc())
+    finally:
+        if pg_ds:
+            pg_ds.Destroy()
+        if data_session:
+            data_session.close()
+        if sys_session:
+            sys_session.close()
+        if sys_ds:
+            sys_ds.Destroy()
+    return result
+
+def add_spatail_table(database,pg_ds,sys_session,spatial_tables_names,this_time,db_tuple):
+    '''
+    注册新增空间表
+    :param database:
+    :param pg_ds:
+    :param spatial_tables_names: 已注册空间表名
+    :param this_time:
+    :return: 实体库中空间表名
+    '''
+
+    db_tables_names=[]
+
+    for i in range(pg_ds.GetLayerCount()):
+        layer: Layer = pg_ds.GetLayer(i)
+        geom_column = layer.GetGeometryColumn()
+        db_tables_names.append(layer.GetName())
+        if not geom_column:
+            continue
+        if layer.GetName() not in spatial_tables_names:
+            l_name = layer.GetName()
+
+            try:
+                # 只注册public的空间表,其他表空间的表名会有.
+                if layer.GetName().__contains__("."):
+                    continue
+                # 略过抽稀表
+                if layer.GetName().__contains__("_vacuate_"):
+                    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
+
+
+                # 范围统计和数量统计以100w为界限
+                query_count_layer: Layer = pg_ds.ExecuteSQL(
+                    '''SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public."{}"'::regclass'''.format(
+                        l_name))
+
+                feature_count = query_count_layer.GetFeature(0).GetField("ec")
+                # 要素少于100w可以精确统计
+                if feature_count < 1000000:
+                    feature_count = layer.GetFeatureCount()
+                    ext = layer.GetExtent()
+                else:
+                    query_ext_layer: Layer = pg_ds.ExecuteSQL(
+                        "select geometry(ST_EstimatedExtent('public', '{}','{}'))".format(l_name,
+                                                                                          layer.GetGeometryColumn()))
+                    ext = query_ext_layer.GetExtent()
+                if ext[0] < 360:
+                    ext = [round(e, 6) for e in ext]
+                else:
+                    ext = [round(e, 2) for e in ext]
+                extent = "{},{},{},{}".format(ext[0], ext[1], ext[2], ext[3])
+
+                StructurePrint().print("空间表增加！")
+
+                geom_type = GeometryAdapter.get_geometry_type(layer)
+            except:
+                StructurePrint().print("表{}注册失败！".format(l_name), "warn")
+                continue
+
+            table_guid = uuid.uuid1().__str__()
+            table = Table(guid=table_guid,
+                          database_guid=database.guid,
+                          # alias=layer.GetName(),
+                          name=layer.GetName(), create_time=this_time, update_time=this_time,
+                          table_type=GeometryAdapter.get_table_type(geom_type),
+                          extent=extent,
+                          feature_count=feature_count
+                          )
+            sys_session.add(table)
+            feature_defn: FeatureDefn = layer.GetLayerDefn()
+
+            for i in range(feature_defn.GetFieldCount()):
+                field_defn: FieldDefn = feature_defn.GetFieldDefn(i)
+                field_name = field_defn.GetName().lower()
+                field_alias = field_name if field_defn.GetAlternativeName() is None or field_defn.GetAlternativeName().__eq__(
+                    "") else field_defn.GetAlternativeName()
+                column = Columns(guid=uuid.uuid1().__str__(), table_guid=table_guid,
+                                 name=field_name, alias=field_alias, create_time=this_time, update_time=this_time)
+                sys_session.add(column)
+    return db_tables_names
+
+def deal_vacuate_table(sys_ds,sys_session,database_guid):
+
+
+    for i in range(sys_ds.GetLayerCount()):
+        layer: Layer = sys_ds.GetLayer(i)
+        geom_column = layer.GetGeometryColumn()
+
+        if not geom_column:
+            continue
+
+
+
+        if layer.GetName().__contains__("_vacuate_"):
+            l_name = layer.GetName()
+
+            base_layer_name = l_name.split("_vacuate_")[0].split("_")[1]
+
+            level = l_name.split("_")[-2]
+
+            pixel_distance_str: str ="0"
+            try:
+                pixel_distance_str: str = l_name.split("_")[-1]
+                if pixel_distance_str.startswith("0"):
+                    pixel_distance_str = "0.{}".format(pixel_distance_str)
+            except:
+                pass
+
+            base_table =sys_session.query(Table).filter_by(name=base_layer_name,database_guid=database_guid).one_or_none()
+            if base_table:
+                if not sys_session.query(TableVacuate).filter_by(table_guid=base_table.guid,name=l_name).one_or_none():
+                    table_vacuate = TableVacuate(guid=uuid.uuid1().__str__(),
+                                                 table_guid=base_table.guid,
+                                                 level=level,
+                                                 name=l_name,
+                                                 pixel_distance=float(pixel_distance_str))
+                    sys_session.add(table_vacuate)
+
+                    sys_session.query(Table).filter_by(guid=base_table.guid).update({"is_vacuate": 1})
+            else:
+                kk=1
+
+
+
+def edit_spatial_table(pg_ds,sys_session,spatial_tables,db_tables_names,this_time,db_tuple):
+
+
+
+    for table in spatial_tables:
+
+        # 删除表
+        if table.name not in db_tables_names:
+            StructurePrint().print("空间表减少！")
+            sys_session.delete(table)
+        # 修改表
+        else:
+            layer: Layer = pg_ds.GetLayerByName(table.name)
+            l_name = layer.GetName()
+
+            # 只注册public的空间表,其他表空间的表名会有.
+            if layer.GetName().__contains__("."):
+                continue
+
+            if layer.GetName().__contains__("_vacuate_"):
+                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")
+                sys_session.delete(table)
+                continue
+
+            columns = table.relate_columns
+            columns_names = [column.name for column in columns]
+            feature_defn: FeatureDefn = layer.GetLayerDefn()
+            db_columns_names = []
+
+            # 增加列
+            for i in range(feature_defn.GetFieldCount()):
+                field_defn: FieldDefn = feature_defn.GetFieldDefn(i)
+                field_name = field_defn.GetName().lower()
+                db_columns_names.append(field_name)
+
+                if field_name not in columns_names:
+                    StructurePrint().print("{}空间表属性增加！".format(table.name))
+                    field_alias = field_name if field_defn.GetAlternativeName() is None or field_defn.GetAlternativeName().__eq__(
+                        "") else field_defn.GetAlternativeName()
+                    column = Columns(guid=uuid.uuid1().__str__(), table_guid=table.guid,
+                                     name=field_name, alias=field_alias, create_time=this_time,
+                                     update_time=this_time)
+                    sys_session.add(column)
+
+            # 删除列
+            for column in columns:
+                if column.name not in db_columns_names:
+                    StructurePrint().print("{}空间表属性减少！".format(table.name))
+                    sys_session.delete(column)
+
+            # 范围统计和数量统计以100w为界限
+            query_count_layer: Layer = pg_ds.ExecuteSQL(
+                '''SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public."{}"'::regclass'''.format(
+                    l_name))
+            feature_count = query_count_layer.GetFeature(0).GetField("ec")
+            # 要素少于100w可以精确统计
+            if feature_count < 1000000:
+                feature_count = layer.GetFeatureCount()
+                ext = layer.GetExtent()
+
+            else:
+                query_ext_layer: Layer = pg_ds.ExecuteSQL(
+                    "select geometry(ST_EstimatedExtent('public', '{}','{}'))".format(l_name,
+                                                                                      layer.GetGeometryColumn()))
+                ext = query_ext_layer.GetExtent()
+            if ext[0] < 360:
+                ext = [round(e, 6) for e in ext]
+            else:
+                ext = [round(e, 2) for e in ext]
+            extent = "{},{},{},{}".format(ext[0], ext[1], ext[2], ext[3])
+
+            # 修改要素量
+            if not table.feature_count.__eq__(feature_count):
+                StructurePrint().print("{}空间表要素！".format(table.name))
+                sys_session.query(Table).filter_by(guid=table.guid).update({"feature_count": feature_count,
+                                                               "extent": extent})
+
+
+def add_common_table(data_session,sys_session,database_guid,real_common_tables_name,origin_common_tables_name,this_time,db_tuple):
+    for table_name in real_common_tables_name:
+        if table_name not in origin_common_tables_name:
+            StructurePrint().print("{}非空间表增加！".format(table_name))
+            table_guid = uuid.uuid1().__str__()
+
+
+            # 没有权限的表跳过
+            if not SQLUtil.check_table_privilege(table_name, "SELECT", db_tuple[0], data_session):
+                StructurePrint().print("用户{}对表{}没有select权限！".format(db_tuple[0], table_name), "warn")
+                continue
+
+            count = data_session.execute('select count(*) from "{}"'.format(table_name)).fetchone()[0]
+
+            table = Table(guid=table_guid,
+                          database_guid=database_guid,
+                          name=table_name, create_time=this_time, update_time=this_time,
+                          table_type=0,
+                          feature_count=count
+                          )
+
+            sys_session.add(table)
+
+            sql = '''
+               SELECT
+                   a.attnum,
+                   a.attname AS field
+               FROM
+                   pg_class c,
+                   pg_attribute a,
+                   pg_type t
+               WHERE
+                   c.relname = '{}'
+                   and a.attnum > 0
+                   and a.attrelid = c.oid
+                   and a.atttypid = t.oid
+               ORDER BY a.attnum 
+               '''.format(table_name)
+
+            cols = data_session.execute(sql).fetchall()
+            for col in cols:
+                column = Columns(guid=uuid.uuid1().__str__(), table_guid=table_guid,
+                                 name=col[1], create_time=this_time, update_time=this_time)
+                sys_session.add(column)
+
+            # 删除不存在的表
+            for n in origin_common_tables_name:
+                if n not in real_common_tables_name:
+                    tables = Table.query.filter_by(name=n).filter_by(database_guid=database_guid).all()
+                    for table in tables:
+                        sys_session.delete(table)
+
+def edit_common_table(data_session,sys_session,database_guid,real_common_tables_name,origin_common_tables_name,this_time,db_tuple):
+    for table_name in origin_common_tables_name:
+        tables = sys_session.query(Table).filter_by(name=table_name).filter_by(database_guid=database_guid).all()
+        for table in tables:
+            if table_name not in real_common_tables_name:
+                StructurePrint().print("{}非空间表减少！".format(table_name))
+                sys_session.delete(table)
+            # 修改表
+            else:
+
+                # 没有权限的表删除
+                if not SQLUtil.check_table_privilege(table_name, "SELECT", db_tuple[0], data_session):
+                    StructurePrint().print("用户{}对表{}没有select权限！".format(db_tuple[0], table_name), "warn")
+                    sys_session.delete(table)
+                    continue
+
+                columns = table.relate_columns
+                columns_names = [column.name for column in columns]
+
+                sql = '''
+                   SELECT
+                       a.attnum,
+                       a.attname AS field
+                   FROM
+                       pg_class c,
+                       pg_attribute a,
+                       pg_type t
+                   WHERE
+                       c.relname = '{}'
+                       and a.attnum > 0
+                       and a.attrelid = c.oid
+                       and a.atttypid = t.oid
+                   ORDER BY a.attnum 
+                   '''.format(table_name)
+
+                cols = data_session.execute(sql).fetchall()
+                real_cols_name = [col[1] for col in cols]
+
+                # 属性增加
+                for col in real_cols_name:
+                    if col not in columns_names:
+                        StructurePrint().print("{}表要素属性增加！".format(table_name))
+                        column = Columns(guid=uuid.uuid1().__str__(), table_guid=table.guid,
+                                         name=col, create_time=this_time, update_time=this_time)
+                        sys_session.add(column)
+
+                # 属性减少
+                for column in columns:
+                    if column.name not in real_cols_name:
+                        StructurePrint().print("{}表要素属性减少！".format(table_name))
+                        sys_session.delete(column)
+
+                # 修改要素量
+                # sql = 'select count(*) from "{}"'.format(table_name)
+                # count = data_session.execute(sql).fetchone()[0]
+
+                count = SQLUtil.get_table_count(table_name,data_session)
+
+                if not table.feature_count.__eq__(count):
+                    StructurePrint().print("{}表要素变化！".format(table_name))
+                    sys_session.query(Table).filter_by(guid=table.guid).update({"feature_count": count})
+
+
+def task_vacuate(table,task_guid):
+
+    sys_session = None
+    pg_session = None
+    pg_ds = None
+    vacuate_process = None
+    try:
+        sys_session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
+        sys_session.query(Table).filter_by(guid=table.guid).update(
+            {"is_vacuate": 2, "update_time": datetime.datetime.now()})
+        sys_session.commit()
+
+        database = sys_session.query(Database).filter_by(guid=table.database_guid).one_or_none()
+        pg_session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))
+
+        pg_ds: DataSource = PGUtil.open_pg_data_source(0, DES.decode(database.sqlalchemy_uri))
+
+        # 删除原有数据
+        tvs = sys_session.query(TableVacuate).filter_by(table_guid=table.guid).all()
+        for tv in tvs:
+            sys_session.delete(tv)
+            # try:
+            #     pg_ds.DeleteLayer(tv.name)
+            # except Exception as e :
+            #     StructurePrint().print("抽稀图层不存在！","warn")
+
+        # 创建抽稀过程
+        options = ["OVERWRITE=yes", "GEOMETRY_NAME={}".format(PGUtil.get_geo_column(table.name, pg_session)),
+                   "PRECISION=NO"]
+
+        layer = pg_ds.GetLayerByName(table.name)
+
+        vacuate_process: VacuateProcess = VacuateProcess(layer, table.guid, options, database.sqlalchemy_uri)
+
+        for feature in layer:
+            geo = feature.GetGeometryRef()
+            # 插入抽稀图层
+            if geo is not None:
+                vacuate_process.vacuate(geo, feature)
+
+        vacuate_process.set_vacuate_count()
+
+        # 新增
+        if configure.VACUATE_DB_URI:
+            user, passwd, host, port, datab = PGUtil.get_info_from_sqlachemy_uri(configure.VACUATE_DB_URI)
+        else:
+            user, passwd, host, port, datab = PGUtil.get_info_from_sqlachemy_uri(DES.decode(database.sqlalchemy_uri))
+        connectstr = "hostaddr={} port={} dbname='{}' user='{}' password='{}'".format(host, port, datab, user,
+                                                                                      passwd)
+        for l in range(vacuate_process.max_level):
+            lev = vacuate_process.t_grid_size.index(vacuate_process.this_gridsize[l])
+
+            table_vacuate = TableVacuate(guid=uuid.uuid1().__str__(),
+                                         table_guid=table.guid,
+                                         level=lev,
+                                         name=vacuate_process.vacuate_layers[l].GetName(),
+                                         pixel_distance=vacuate_process.this_gridsize[l],
+                                         connectstr=DES.encode(connectstr))
+            sys_session.add(table_vacuate)
+
+        sys_session.query(Task).filter_by(guid=task_guid).update({"state": 1, "update_time": datetime.datetime.now(),
+                                                                  "process": "精化完成"})
+        sys_session.query(Table).filter_by(guid=table.guid).update(
+            {"is_vacuate": 1, "update_time": datetime.datetime.now()})
+        sys_session.commit()
+
+    except Exception as e:
+        try:
+            sys_session.query(Task).filter_by(guid=task_guid).update(
+                {"state": -1, "update_time": datetime.datetime.now(),
+                 "process": "精化失败"})
+            sys_session.query(Table).filter_by(guid=table.guid).update(
+                {"is_vacuate": 0, "update_time": datetime.datetime.now()})
+
+            message = "{} {}".format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e.__str__())
+            task_process_guid = uuid.uuid1().__str__()
+            task_process = Process(guid=task_process_guid, message=message, time=datetime.datetime.now(),
+                                   task_guid=task_guid)
+            sys_session.add(task_process)
+            sys_session.commit()
+            if vacuate_process:
+                vacuate_process.rollback()
+
+            print(traceback.format_exc())
+        except Exception as ee:
+            print(traceback.format_exc())
+    finally:
+        if vacuate_process:
+            vacuate_process.end()
+        if sys_session:
+            sys_session.close()
+        if pg_session:
+            pg_session.close()
+        if pg_ds:
+            pg_ds.Destroy()
+
+
+class VacuateProcess:
+
+    max_level=0
+    fill_dict={}
+    vacuate_layers={}
+    vacuate_layers_gridsize={}
+    pg_ds_dict = {}
+    # 图层要素大于5W才抽稀
+    least_vacuate_count = VacuateConf.least_vacuate_count
+
+    extent=[]
+    is_spatial=False
+
+    lonlat_gridsize = VacuateConf.lonlat_gridsize
+    project_gridsize = VacuateConf.project_gridsize
+
+    # 该抽稀过程使用的grid_size
+    t_grid_size = []
+
+    # 该抽稀过程的抽稀网格
+    this_gridsize=[]
+
+
+    def __init__(self,layer:Layer,table_guid, options,sqlalchemy_uri):
+
+        #是空间图层才初始化
+        if layer.GetExtent()[0] > 0 or layer.GetExtent()[0] < 0:
+
+            self.is_spatial=True
+
+            # 判断需要抽稀多少级
+
+            lc = layer.GetFeatureCount()
+            extent = layer.GetExtent()
+            self.extent=extent
+
+            #判断疏密程度
+            p_x = (extent[1]-extent[0])/10.0
+            p_y = (extent[3] - extent[2]) / 10.0
+            fill_precent=0
+            StructurePrint().print("判断疏密")
+            for ix in range(10):
+                for iy in range(10):
+                    grid_extent = [extent[0]+ix*p_x,extent[0]+ix*p_x+p_x,extent[2]+iy*p_y,extent[2]+iy*p_y+p_y]
+                    poly = GeometryAdapter.envelop_2_polygon(grid_extent)
+
+                    layer.SetSpatialFilter(None)
+                    layer.SetSpatialFilter(poly)
+                    layer.ResetReading()
+                    if layer.GetNextFeature():
+                        fill_precent += 1
+
+            print(fill_precent)
+            StructurePrint().print("判断疏密结束")
+
+            layer.SetSpatialFilter(None)
+            layer.ResetReading()
+            # 固有疏密程度
+            original_density=8
+
+
+            # 额外一层
+            # self.this_gridsize.append(0.000075)
+            # self.max_level += 1
+            ######
+
+            if extent[0]>180:
+                self.t_grid_size=self.project_gridsize
+            else:
+                self.t_grid_size = self.lonlat_gridsize
+
+            for grid_size in self.t_grid_size:
+                # 最少抽稀个数
+                if lc > self.least_vacuate_count:
+                    # 网格数至少大于
+                    if ((extent[1] - extent[0]) * (extent[3] - extent[2])) / (grid_size**2)>self.least_vacuate_count:
+                        # 要素数量大于网格数量
+                        # 要考虑图层的疏密程度，original_density*(100.0/fill_precent) 为疏密指数
+                        if lc * original_density * (100.0/fill_precent)>((extent[1] - extent[0])*(extent[3] - extent[2]))/(grid_size**2) :
+                            print(grid_size)
+                            self.this_gridsize.append(grid_size)
+                            self.max_level += 1
+
+
+
+            # 创建抽稀ds
+            for l in range(self.max_level):
+                # pg_ds_l: DataSource = PGUtil.open_pg_data_source(1, DES.decode(sqlalchemy_uri))
+                if configure.VACUATE_DB_URI:
+                    pg_ds_l: DataSource = PGUtil.open_pg_data_source(1, configure.VACUATE_DB_URI)
+                else:
+                    pg_ds_l: DataSource = PGUtil.open_pg_data_source(1, DES.decode(sqlalchemy_uri))
+                pg_ds_l.StartTransaction()
+                self.pg_ds_dict[l] = pg_ds_l
+
+            # 生成抽稀图层
+            options = options[1:]
+            options.append("OVERWRITE=yes")
+            options.append("LAUNDER=no")
+
+            schema = layer.schema
+            # 增加统计字段
+            schema.append(ogr.FieldDefn("_dcigrid_count_", ogr.OFTInteger))
+            schema.append(ogr.FieldDefn("_dcigrid_name_", ogr.OFTString))
+
+            for l in range(self.max_level):
+                this_grid_len = self.this_gridsize[l]
+
+                self.vacuate_layers_gridsize[l] = this_grid_len
+
+                pg = self.pg_ds_dict[l]
+
+                grid_name = str(this_grid_len)
+                if this_grid_len<1:
+                    grid_name = str(this_grid_len).split(".")[-1]
+                    if this_grid_len.__eq__(0.00008):
+                        grid_name = "00008"
+
+                # 抽稀图层是点面混合的
+                # 抽稀表有固定的命名规则
+                # 抽稀表一定要覆盖
+
+
+                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)
+                self.vacuate_layers[l] = vl
+
+        else:
+            pass
+
+
+    def vacuate(self,g,feature):
+
+        if self.is_spatial:
+
+            # 插入到所有抽稀图层中
+            for level in range(self.max_level):
+
+                center: Geometry = g.Centroid()
+
+                extent = g.GetEnvelope()
+                long_extent= extent[1]-extent[0]
+                lat_extent = extent[3]-extent[2]
+
+                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)
+                col = int((center.GetX() - self.extent[0]) / this_grid_len)
+                key = "{}.{}.{}".format(level, row, col)
+
+                if not self.fill_dict.get(key):
+                    self.fill_dict[key] = 0
+                if self.fill_dict[key] == 0:
+
+                    vacuate_layer: Layer = self.vacuate_layers.get(level)
+                    feat = ogr.Feature(vacuate_layer.GetLayerDefn())
+                    # 如果图形比网格小，直接存储其中心点
+                    if this_grid_len>long_extent and this_grid_len>lat_extent:
+                        feat.SetGeometry(center)
+                    else:
+                        feat.SetGeometry(g)
+
+                    # 复制旧feature属性
+                    field_dict = feature.items()
+                    for field_name in field_dict:
+                        feat.SetField(field_name, field_dict[field_name])
+                    feat.SetField("_dcigrid_name_",".".join(key.split(".")[1:]))
+
+                    vacuate_layer.CreateFeature(feat)
+                    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)
+
+                    # 复制旧feature属性
+                    field_dict = feature.items()
+                    for field_name in field_dict:
+                        feat.SetField(field_name, field_dict[field_name])
+                    feat.SetField("_dcigrid_name_",".".join(key.split(".")[1:]))
+
+                    vacuate_layer.CreateFeature(feat)
+                    self.fill_dict[key] += 1
+                else:
+                    self.fill_dict[key] += 1
+
+    def set_vacuate_count(self):
+        if self.is_spatial:
+            # 插入到所有抽稀图层中
+            for level in range(self.max_level):
+                vacuate_layer: Layer = self.vacuate_layers.get(level)
+                for feat in vacuate_layer:
+                    key = "{}.{}".format(level,feat.GetField("_dcigrid_name_"))
+                    feat.SetField("_dcigrid_count_",self.fill_dict.get(key))
+                    vacuate_layer.SetFeature(feat)
+
+    def end(self):
+        for pg in self.pg_ds_dict.values():
+            pg.Destroy()
+
+    def rollback(self):
+        for pg in self.pg_ds_dict.values():
+            pg.RollbackTransaction()

@@ -11,6 +11,8 @@ from . import service_exist_type
 from . import service_list
 from . import service_list
 from . import service_delete
 from . import service_delete
 from . import service_state
 from . import service_state
+from . import service_info
+from . import service_edit
 import os
 import os
 from flask import send_from_directory
 from flask import send_from_directory
 
 
@@ -40,7 +42,7 @@ class DataManager(BlueprintApi):
         return service_exist_type.Api().result
         return service_exist_type.Api().result
 
 
     @staticmethod
     @staticmethod
-    @bp.route('/State', methods=['GET'])
+    @bp.route('/State', methods=['POST'])
     @swag_from(service_state.Api.api_doc)
     @swag_from(service_state.Api.api_doc)
     def api_service_state():
     def api_service_state():
         """
         """
@@ -57,6 +59,25 @@ class DataManager(BlueprintApi):
         """
         """
         return service_list.Api().result
         return service_list.Api().result
 
 
+    @staticmethod
+    @bp.route('/Info', methods=['POST'])
+    @swag_from(service_info.Api.api_doc)
+    def api_service_info():
+        """
+        服务Info
+        """
+        return service_info.Api().result
+
+    @staticmethod
+    @bp.route('/Edit', methods=['POST'])
+    @swag_from(service_edit.Api.api_doc)
+    def api_service_edit():
+        """
+        服务Edit
+        """
+        return service_edit.Api().result
+
+
 
 
     @staticmethod
     @staticmethod
     @bp.route('/Delete', methods=['POST'])
     @bp.route('/Delete', methods=['POST'])

@@ -19,8 +19,7 @@ class Api(ApiTemplate):
 
 
 
 
             if ServiceCatalog.query.filter_by(name=self.para.get("name"),
             if ServiceCatalog.query.filter_by(name=self.para.get("name"),
-                                       pguid=self.para.get("pguid"),
-                                       database_guid=self.para.get("database_guid")).one_or_none():
+                                       pguid=self.para.get("pguid")).one_or_none():
                 res["msg"]="目录已经存在！"
                 res["msg"]="目录已经存在！"
                 return res
                 return res
 
 

@@ -38,11 +38,6 @@ class Api(ApiTemplate):
          "in": "formData",
          "in": "formData",
          "type": "string",
          "type": "string",
          "description":"目录guid","required": "true"},
          "description":"目录guid","required": "true"},
-        {"name": "database_guid",
-         "in": "formData",
-         "type": "string",
-         "description": "数据库guid", "required": "true"},
-
     ],
     ],
     "responses":{
     "responses":{
         200:{
         200:{

@@ -52,11 +52,6 @@ class Api(ApiTemplate):
     
     
     "tags":["服务目录接口"],
     "tags":["服务目录接口"],
     "parameters":[
     "parameters":[
-        {"name": "database_guid",
-         "in": "formData",
-         "type": "string",
-         "description": "数据库guid", "required": "true"},
-    
     ],
     ],
     "responses":{
     "responses":{
         200:{
         200:{

@@ -21,7 +21,6 @@ class Api(ApiTemplate):
                 catalog_guids = [c.guid for c in ServiceCatalog.query.filter(ServiceCatalog.path.like("%" + cata.guid + "%")).all()]
                 catalog_guids = [c.guid for c in ServiceCatalog.query.filter(ServiceCatalog.path.like("%" + cata.guid + "%")).all()]
                 service_count = Service.query.filter(Service.catalog_guid.in_(catalog_guids)).count()
                 service_count = Service.query.filter(Service.catalog_guid.in_(catalog_guids)).count()
                 cata_json ={}
                 cata_json ={}
-                cata_json["database_guid"]=cata.database_guid
                 cata_json["description"] = cata.description
                 cata_json["description"] = cata.description
                 cata_json["guid"] = cata.guid
                 cata_json["guid"] = cata.guid
                 cata_json["name"] = cata.name
                 cata_json["name"] = cata.name
@@ -41,11 +40,6 @@ class Api(ApiTemplate):
     
     
     "tags":["服务目录接口"],
     "tags":["服务目录接口"],
     "parameters":[
     "parameters":[
-        {"name": "database_guid",
-         "in": "formData",
-         "type": "string",
-         "description": "数据库guid", "required": "true"},
-    
     ],
     ],
     "responses":{
     "responses":{
         200:{
         200:{

@@ -15,7 +15,8 @@ from . import image_tile,image_wms
 from . import image_service_list
 from . import image_service_list
 from . import image_tile_mask
 from . import image_tile_mask
 
 
-
+from . import image_delete
+from . import image_cancle
 from . import image_register,image_list,image_info,image_edit,image_overview
 from . import image_register,image_list,image_info,image_edit,image_overview
 from . import image_tag_create,image_tag_delete,image_tag_list
 from . import image_tag_create,image_tag_delete,image_tag_list
 
 
@@ -34,12 +35,31 @@ class DataManager(BlueprintApi):
         """
         """
         return image_register.Api().result
         return image_register.Api().result
 
 
+
+    @staticmethod
+    @bp.route('/Delete', methods=['POST'])
+    @swag_from(image_delete.Api.api_doc)
+    def api_image_delete():
+        """
+        影像删除
+        """
+        return image_delete.Api().result
+
+    @staticmethod
+    @bp.route('/Cancle', methods=['POST'])
+    @swag_from(image_cancle.Api.api_doc)
+    def api_image_cancle():
+        """
+        影像取消注册
+        """
+        return image_cancle.Api().result
+
     @staticmethod
     @staticmethod
     @bp.route('/Edit', methods=['POST'])
     @bp.route('/Edit', methods=['POST'])
     @swag_from(image_edit.Api.api_doc)
     @swag_from(image_edit.Api.api_doc)
     def api_image_edit():
     def api_image_edit():
         """
         """
-        影像Info
+        影像Edit
         """
         """
         return image_edit.Api().result
         return image_edit.Api().result
 
 
@@ -129,7 +149,7 @@ class DataManager(BlueprintApi):
         return data_list.Api().result
         return data_list.Api().result
 
 
     @staticmethod
     @staticmethod
-    @bp.route('/Capabilities', methods=['POST'])
+    @bp.route('/Capabilities', methods=['GET','POST'])
     @swag_from(capabilities.Api.api_doc)
     @swag_from(capabilities.Api.api_doc)
     def capabilities():
     def capabilities():
         """
         """
@@ -156,6 +176,17 @@ class DataManager(BlueprintApi):
         """
         """
         return image_tile.Api(guid,l,y,z).result
         return image_tile.Api(guid,l,y,z).result
 
 
+
+
+    # @staticmethod
+    # @bp.route('/<service_name>/WMTS', methods=['GET'])
+    # @swag_from(image_tile.Api.api_doc)
+    # def api_image_tile(service_name):
+    #     """
+    #     切片服务
+    #     """
+    #     return image_tile.Api(service_name).result
+
     @staticmethod
     @staticmethod
     @bp.route('/Tile', methods=['GET','POST'])
     @bp.route('/Tile', methods=['GET','POST'])
     @swag_from(image_tile.Api.api_doc)
     @swag_from(image_tile.Api.api_doc)

@@ -6,489 +6,297 @@
 
 
 from flask import Response
 from flask import Response
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ApiTemplate import ApiTemplate
+from .models import ImageService
+from app.models import Service,TileScheme
+import json
+import configure
+
+
 class Api(ApiTemplate):
 class Api(ApiTemplate):
 
 
-    api_name = "影像数据列表"
+    api_name = "影像能力文档"
 
 
     def process(self):
     def process(self):
 
 
-        x = '''<Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:gml="http://www.opengis.net/gml" xsi:schemaLocation="http://www.opengis.net/wmts/1.0 http://schemas.opengis.net/wmts/1.0/wmtsGetCapabilities_response.xsd" version="1.0.0">
-            <!--  Service Identification  -->
-            <ows:ServiceIdentification>
-            <ows:Title>localimage</ows:Title>
-            <ows:ServiceType>OGC WMTS</ows:ServiceType>
-            <ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion>
-            </ows:ServiceIdentification>
-            <!--  Operations Metadata  -->
-            <ows:OperationsMetadata>
-            <ows:Operation name="GetCapabilities">
-            <ows:DCP>
-            <ows:HTTP>
-            <ows:Get xlink:href="http://172.26.99.160:8840/API/Image/Capabilities">
-            <ows:Constraint name="GetEncoding">
-            <ows:AllowedValues>
-            <ows:Value>RESTful</ows:Value>
-            </ows:AllowedValues>
-            </ows:Constraint>
-            </ows:Get>
-            <!--  add KVP binding in 10.1  -->
-            <ows:Get xlink:href="http://172.26.99.160:8840/API/Image/TileMany?">
-            <ows:Constraint name="GetEncoding">
-            <ows:AllowedValues>
-            <ows:Value>KVP</ows:Value>
-            </ows:AllowedValues>
-            </ows:Constraint>
-            </ows:Get>
-            </ows:HTTP>
-            </ows:DCP>
-            </ows:Operation>
-            <ows:Operation name="GetTile">
-            <ows:DCP>
-            <ows:HTTP>
-            <ows:Get xlink:href="http://172.26.99.160:8840/API/Image/TileMany">
-            <ows:Constraint name="GetEncoding">
-            <ows:AllowedValues>
-            <ows:Value>RESTful</ows:Value>
-            </ows:AllowedValues>
-            </ows:Constraint>
-            </ows:Get>
-            <ows:Get xlink:href="http://172.26.99.160:8840/API/Image/TileMany?">
-            <ows:Constraint name="GetEncoding">
-            <ows:AllowedValues>
-            <ows:Value>KVP</ows:Value>
-            </ows:AllowedValues>
-            </ows:Constraint>
-            </ows:Get>
-            </ows:HTTP>
-            </ows:DCP>
-            </ows:Operation>
-            </ows:OperationsMetadata>
-            <Contents>
-            <!-- Layer -->
-            <Layer>
-            <ows:Title>changde</ows:Title>
-            <ows:Identifier>changde</ows:Identifier>
-            <ows:BoundingBox crs="urn:ogc:def:crs:EPSG::4490">
-            <ows:LowerCorner>111.604613312 28.9170588759</ows:LowerCorner>
-            <ows:UpperCorner>111.751508603 29.079435995</ows:UpperCorner>
-            </ows:BoundingBox>
-            <ows:WGS84BoundingBox crs="urn:ogc:def:crs:OGC:2:84">
-            <ows:LowerCorner>111.604613312 28.9170588759</ows:LowerCorner>
-            <ows:UpperCorner>111.751508603 29.079435995</ows:UpperCorner>
-            </ows:WGS84BoundingBox>
-            <Style isDefault="true">
-            <ows:Title>Default Style</ows:Title>
-            <ows:Identifier>default</ows:Identifier>
-            </Style>
-            <Format>image/png</Format>
-            <TileMatrixSetLink>
-            <TileMatrixSet>default028mm</TileMatrixSet>
-            </TileMatrixSetLink>
-            <TileMatrixSetLink>
-            <TileMatrixSet>nativeTileMatrixSet</TileMatrixSet>
-            </TileMatrixSetLink>
-            <ResourceURL format="image/png" resourceType="tile" template="http://172.26.99.160:8840/API/Image/TileMany/{TileMatrix}/{TileRow}/{TileCol}?format=image/png"/>
-            </Layer>
-            <!-- TileMatrixSet -->
-            <TileMatrixSet>
-            <ows:Title>Default TileMatrix using 0.28mm</ows:Title>
-            <ows:Abstract>The tile matrix set that has scale values calculated based on the dpi defined by OGC specification (dpi assumes 0.28mm as the physical distance of a pixel).</ows:Abstract>
-            <ows:Identifier>default028mm</ows:Identifier>
-            <ows:SupportedCRS>urn:ogc:def:crs:EPSG::4490</ows:SupportedCRS>
-            <TileMatrix>
-            <ows:Identifier>0</ows:Identifier>
-            <ScaleDenominator>5.584552725961496E8</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>1</ows:Identifier>
-            <ScaleDenominator>2.792276362980748E8</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>2</ows:Identifier>
-            <ScaleDenominator>1.396138181490374E8</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>3</ows:Identifier>
-            <ScaleDenominator>6.98069090745187E7</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>4</ows:Identifier>
-            <ScaleDenominator>3.490345453725935E7</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>5</ows:Identifier>
-            <ScaleDenominator>1.7451727268629674E7</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>6</ows:Identifier>
-            <ScaleDenominator>8725863.634314837</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>7</ows:Identifier>
-            <ScaleDenominator>4362931.8171574185</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>8</ows:Identifier>
-            <ScaleDenominator>2181465.9085787092</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>2</MatrixWidth>
-            <MatrixHeight>2</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>9</ows:Identifier>
-            <ScaleDenominator>1090732.9542893546</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>3</MatrixWidth>
-            <MatrixHeight>3</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>10</ows:Identifier>
-            <ScaleDenominator>545366.4771446773</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>6</MatrixWidth>
-            <MatrixHeight>6</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>11</ows:Identifier>
-            <ScaleDenominator>272683.23857233865</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>11</MatrixWidth>
-            <MatrixHeight>11</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>12</ows:Identifier>
-            <ScaleDenominator>136341.61928616933</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>21</MatrixWidth>
-            <MatrixHeight>20</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>13</ows:Identifier>
-            <ScaleDenominator>68170.80964308466</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>42</MatrixWidth>
-            <MatrixHeight>40</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>14</ows:Identifier>
-            <ScaleDenominator>34085.40482154233</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>83</MatrixWidth>
-            <MatrixHeight>80</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>15</ows:Identifier>
-            <ScaleDenominator>17042.702410771166</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>166</MatrixWidth>
-            <MatrixHeight>158</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>16</ows:Identifier>
-            <ScaleDenominator>8521.351205385583</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>331</MatrixWidth>
-            <MatrixHeight>314</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>17</ows:Identifier>
-            <ScaleDenominator>4260.6756026927915</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>661</MatrixWidth>
-            <MatrixHeight>627</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>18</ows:Identifier>
-            <ScaleDenominator>2130.3378013463957</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1321</MatrixWidth>
-            <MatrixHeight>1254</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>19</ows:Identifier>
-            <ScaleDenominator>1065.1689006731979</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>2642</MatrixWidth>
-            <MatrixHeight>2508</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>20</ows:Identifier>
-            <ScaleDenominator>532.5844503365989</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>5283</MatrixWidth>
-            <MatrixHeight>5014</MatrixHeight>
-            </TileMatrix>
-            </TileMatrixSet>
-            <TileMatrixSet>
-            <ows:Title>Native TiledMapService TileMatrixSet</ows:Title>
-            <ows:Abstract>the tile matrix set that has scale values calculated based on the dpi defined by ArcGIS Server tiled map service. The current tile dpi is 96</ows:Abstract>
-            <ows:Identifier>nativeTileMatrixSet</ows:Identifier>
-            <ows:SupportedCRS>urn:ogc:def:crs:EPSG::4490</ows:SupportedCRS>
-            <TileMatrix>
-            <ows:Identifier>0</ows:Identifier>
-            <ScaleDenominator>5.909951861175001E8</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>1</ows:Identifier>
-            <ScaleDenominator>2.9549759305875003E8</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>2</ows:Identifier>
-            <ScaleDenominator>1.4774879652937502E8</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>3</ows:Identifier>
-            <ScaleDenominator>7.387439826468751E7</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>4</ows:Identifier>
-            <ScaleDenominator>3.6937199132343754E7</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>5</ows:Identifier>
-            <ScaleDenominator>1.8468599566171877E7</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>6</ows:Identifier>
-            <ScaleDenominator>9234299.783085939</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>7</ows:Identifier>
-            <ScaleDenominator>4617149.891542969</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1</MatrixWidth>
-            <MatrixHeight>1</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>8</ows:Identifier>
-            <ScaleDenominator>2308574.9457714846</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>2</MatrixWidth>
-            <MatrixHeight>2</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>9</ows:Identifier>
-            <ScaleDenominator>1154287.4728857423</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>3</MatrixWidth>
-            <MatrixHeight>3</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>10</ows:Identifier>
-            <ScaleDenominator>577143.7364428712</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>6</MatrixWidth>
-            <MatrixHeight>6</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>11</ows:Identifier>
-            <ScaleDenominator>288571.8682214356</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>11</MatrixWidth>
-            <MatrixHeight>11</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>12</ows:Identifier>
-            <ScaleDenominator>144285.9341107178</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>21</MatrixWidth>
-            <MatrixHeight>20</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>13</ows:Identifier>
-            <ScaleDenominator>72142.9670553589</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>42</MatrixWidth>
-            <MatrixHeight>40</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>14</ows:Identifier>
-            <ScaleDenominator>36071.48352767945</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>83</MatrixWidth>
-            <MatrixHeight>80</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>15</ows:Identifier>
-            <ScaleDenominator>18035.741763839724</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>166</MatrixWidth>
-            <MatrixHeight>158</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>16</ows:Identifier>
-            <ScaleDenominator>9017.870881919862</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>331</MatrixWidth>
-            <MatrixHeight>314</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>17</ows:Identifier>
-            <ScaleDenominator>4508.935440959931</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>661</MatrixWidth>
-            <MatrixHeight>627</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>18</ows:Identifier>
-            <ScaleDenominator>2254.4677204799655</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>1321</MatrixWidth>
-            <MatrixHeight>1254</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>19</ows:Identifier>
-            <ScaleDenominator>1127.2338602399827</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>2642</MatrixWidth>
-            <MatrixHeight>2508</MatrixHeight>
-            </TileMatrix>
-            <TileMatrix>
-            <ows:Identifier>20</ows:Identifier>
-            <ScaleDenominator>563.6169301199914</ScaleDenominator>
-            <TopLeftCorner>90.0 -180.0</TopLeftCorner>
-            <TileWidth>256</TileWidth>
-            <TileHeight>256</TileHeight>
-            <MatrixWidth>5283</MatrixWidth>
-            <MatrixHeight>5014</MatrixHeight>
-            </TileMatrix>
-            </TileMatrixSet>
-            </Contents>
-            <ServiceMetadataURL xlink:href="http://172.26.99.160:8840/API/Image/Capabilities"/>
-            </Capabilities>'''
+        guid = self.para.get("guid")
+        image_service:ImageService = ImageService.query.filter_by(guid=guid).one_or_none()
+        if not image_service:
+            raise Exception("服务不存在！")
+        service = Service.query.filter_by(guid=image_service.service_guid).one_or_none()
+
+        if service.type.__eq__("ImageWMS"):
+            xml =  self.get_wms_capabilities(image_service)
+
+        elif service.type.__eq__("ImageWMTS"):
+            #arcgis能加载
+            xml = self.get_wmts_capabilities(image_service,service)
+        else:
+            xml = ""
 
 
-        r = Response(response=x, status=200, mimetype="application/xml")
+        r = Response(response=xml, status=200, mimetype="application/xml")
         r.headers["Content-Type"] = "text/xml; charset=utf-8"
         r.headers["Content-Type"] = "text/xml; charset=utf-8"
         return r
         return r
 
 
+    def get_wms_capabilities(self,image_service:ImageService):
+
+        xml = '''<?xml version="1.0" encoding="utf-8" ?>
+        <WMS_Capabilities version="1.2.0">
+            <Service>
+                <Name>WMS</Name>
+                <Title>{service_title}</Title>
+                <Abstract>{abstract}</Abstract>
+                <Keywords>GIMS</Keywords>
+                <OnlineResource/>
+                <Fees>none</Fees>
+                <AccessConstraints>none</AccessConstraints>
+            </Service>
+            <Capability>
+                <Request>
+                    <GetCapabilities>
+                        <Format>text/xml</Format>
+                        <DCPType>
+                            <HTTP>
+                                <Get>
+                                    <OnlineResource xlink:href="{url}" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink"/>
+                                </Get>
+                            </HTTP>
+                        </DCPType>
+                    </GetCapabilities>
+                    <GetMap>
+                        <Format>png</Format>
+                        <Format>jpeg</Format>
+                        <Format>gif</Format>
+                        <Format>image/png</Format>
+                        <Format>image/jpeg</Format>
+                        <Format>image/gif</Format>
+                        <DCPType>
+                            <HTTP>
+                                <Get>
+                                    <OnlineResource xlink:href="{url}" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink"/>
+                                </Get>
+                            </HTTP>
+                        </DCPType>
+                    </GetMap>
+                    <Map>
+                        <Format>
+                            <PNG/>
+                            <GIF/>
+                            <JPG/>
+                        </Format>
+                        <DCPType>
+                            <HTTP>
+                                <Get onlineResource="{url}"/>
+                            </HTTP>
+                        </DCPType>
+                    </Map>
+                    <Capabilities>
+                        <Format>
+                            <WMS_XML/>
+                        </Format>
+                        <DCPType>
+                            <HTTP>
+                                <Get onlineResource="{url}"/>
+                            </HTTP>
+                        </DCPType>
+                    </Capabilities>
+                    <FeatureInfo>
+                        <Format>
+                            <XML/>
+                            <MIME/>
+                        </Format>
+                        <DCPType>
+                            <HTTP>
+                                <Get onlineResource="{url}"/>
+                            </HTTP>
+                        </DCPType>
+                    </FeatureInfo>
+                </Request>
+                <Exception>
+                    <Format>
+                        <WMS_XML/>
+                        <INIMAGE/>
+                        <BLANK/>
+                    </Format>
+                </Exception>
+                <Layer>
+                    <Name>{service_name}</Name>
+                    <Title>{service_title}</Title>
+                    <CRS>{crs}</CRS>
+                    <BoundingBox CRS="{crs}" maxx="{maxx}" maxy="{maxy}" minx="{minx}" miny="{miny}"/>
+                    <Layer queryable="1">
+                        <CRS>{crs}</CRS>
+                        <Name>{layer_name}</Name>
+                        <Title>{layer_title}</Title>
+                        <BoundingBox CRS="{crs}" maxx="{maxx}" maxy="{maxy}" minx="{minx}" miny="{miny}"/>
+                    </Layer>
+                </Layer>
+            </Capability>
+        </WMS_Capabilities>'''
+
+        extent = json.loads(image_service.extent)
+        xml = xml.format(service_title=image_service.name,
+                         service_name=image_service.name,
+                         abstract= "None" ,
+                         crs="ESPG:4326",
+                         layer_name=image_service.name,
+                         layer_title=image_service.name,
+                         maxx=extent[2],
+                         maxy = extent[3],
+                         minx = extent[0],
+                         miny = extent[1],
+                         url="http://{}/API/Service/Image/WMS?guid={}".format(configure.deploy_ip_host,image_service.guid))
+        return xml
+
+    def get_wmts_capabilities(self, image_service: ImageService,service:Service):
+        tile_scheme:TileScheme = TileScheme.query.filter_by(guid = image_service.scheme_guid).one_or_none()
+        if not tile_scheme:
+            raise Exception("切片方案不存在！")
+
+        xml = '''<Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:gml="http://www.opengis.net/gml" xsi:schemaLocation="http://www.opengis.net/wmts/1.0 http://schemas.opengis.net/wmts/1.0/wmtsGetCapabilities_response.xsd" version="1.0.0">
+             <!--  Service Identification  -->
+             <ows:ServiceIdentification>
+             <ows:Title>{title}</ows:Title>
+             <ows:ServiceType>OGC WMTS</ows:ServiceType>
+             <ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion>
+             </ows:ServiceIdentification>
+             
+             <!--  Operations Metadata  -->
+             <ows:OperationsMetadata>
+             <ows:Operation name="GetCapabilities">
+             <ows:DCP>
+             <ows:HTTP>
+             <ows:Get xlink:href="{capabilities_url}">
+             <ows:Constraint name="GetEncoding">
+             <ows:AllowedValues>
+             <ows:Value>RESTful</ows:Value>
+             </ows:AllowedValues>
+             </ows:Constraint>
+             </ows:Get>
+             
+             <!--  add KVP binding in 10.1  -->
+             <ows:Get xlink:href="{tile_url}?">
+             <ows:Constraint name="GetEncoding">
+             <ows:AllowedValues>
+             <ows:Value>KVP</ows:Value>
+             </ows:AllowedValues>
+             </ows:Constraint>
+             </ows:Get>
+             </ows:HTTP>
+             </ows:DCP>
+             </ows:Operation>
+             <ows:Operation name="GetTile">
+             <ows:DCP>
+             <ows:HTTP>
+             <ows:Get xlink:href="{tile_url}">
+             <ows:Constraint name="GetEncoding">
+             <ows:AllowedValues>
+             <ows:Value>RESTful</ows:Value>
+             </ows:AllowedValues>
+             </ows:Constraint>
+             </ows:Get>
+             <ows:Get xlink:href="{tile_url}?">
+             <ows:Constraint name="GetEncoding">
+             <ows:AllowedValues>
+             <ows:Value>KVP</ows:Value>
+             </ows:AllowedValues>
+             </ows:Constraint>
+             </ows:Get>
+             </ows:HTTP>
+             </ows:DCP>
+             </ows:Operation>
+             </ows:OperationsMetadata>
+             
+             <Contents>
+             
+             <!-- Layer -->
+             
+             
+             <Layer>
+             <ows:Title>{title}</ows:Title>
+             <ows:Identifier>{title}</ows:Identifier>
+             <ows:BoundingBox crs="{crs}">
+             <ows:LowerCorner>{xmin} {ymin}</ows:LowerCorner>
+             <ows:UpperCorner>{xmax} {ymax}</ows:UpperCorner>
+             </ows:BoundingBox>
+             
+             <Style isDefault="true">
+             <ows:Title>Default Style</ows:Title>
+             <ows:Identifier>default</ows:Identifier>
+             </Style>
+             <Format>image/png</Format>
+             <TileMatrixSetLink>
+             <TileMatrixSet>{tile_name}</TileMatrixSet>
+             </TileMatrixSetLink>
+             
+             <ResourceURL format="image/png" resourceType="tile" template="{tile_url}"/>
+             
+             </Layer>
+             
+             <!-- TileMatrixSet -->
+             
+             
+             <TileMatrixSet>
+             
+             <TileMatrix>
+             <ows:Title>{tile_title}</ows:Title>
+             <ows:Abstract>{tile_description}</ows:Abstract>
+             <ows:Identifier>{tile_name}</ows:Identifier>
+             <ows:SupportedCRS>{crs}</ows:SupportedCRS>
+             
+             {tile_matrix}
+             
+             </TileMatrix>
+             
+             </TileMatrixSet>
+             
+             
+             </Contents>
+             <ServiceMetadataURL xlink:href="{capabilities_url}"/>
+             </Capabilities>'''
+
+
+
+
+        tile_matrix_each = '''
+             <TileMatrix>
+             <ows:Identifier>{lev}</ows:Identifier>
+             <ScaleDenominator>{scale}</ScaleDenominator>
+             <TopLeftCorner>{top_left}</TopLeftCorner>
+             <TileWidth>{cols}</TileWidth>
+             <TileHeight>{rows}</TileHeight>
+             </TileMatrix>
+        '''
+
+        tile_matrix = ""
+        top_left = tile_scheme.top_left
+        for level in json.loads(tile_scheme.levels):
+            tile_matrix = "{}{}".format(tile_matrix,tile_matrix_each.format(lev=level["level"],
+                                                                            scale=level["scale"],
+                                                                            top_left=top_left,
+                                                                            cols=tile_scheme.cols,
+                                                                            rows=tile_scheme.rows))
+
+        extent = json.loads(image_service.extent)
+
+        xml = xml.format(capabilities_url = "http://{}/API/Service/Image/Capabilities?guid={}".format(configure.deploy_ip_host,image_service.guid),
+                         tile_url = "http://{}/API/Service/Image/Tile?guid={}".format(configure.deploy_ip_host,image_service.guid),
+                         crs = tile_scheme.crs,
+                         xmin = extent[0],
+                         ymin = extent[1],
+                         xmax = extent[2],
+                         ymax = extent[3],
+                         # TileMatrix = "{TileMatrix}",
+                         # TileRow = "{TileRow}",
+                         # TileCol = "{TileCol}",
+                         guid = image_service.guid,
+                         title = service.title,
+                         tile_title = tile_scheme.name,
+                         tile_name = tile_scheme.name,
+                         tile_description = tile_scheme.description,
+                         tile_matrix=tile_matrix
+                         )
 
 
+        return xml
 
 
 
 
     api_doc = {
     api_doc = {

@@ -13,6 +13,7 @@ from app.modules.service.image.util.ThriftConnect import ThriftConnect
 import os
 import os
 from app.models import db
 from app.models import db
 from app.modules.service.image.models import Image
 from app.modules.service.image.models import Image
+from .util.ImageType import ImageType
 
 
 class Api(ApiTemplate):
 class Api(ApiTemplate):
 
 
@@ -50,21 +51,16 @@ class Api(ApiTemplate):
                     if file_path.lower().endswith("tiff") or file_path.lower().endswith("tif") or file_path.lower().endswith("img"):
                     if file_path.lower().endswith("tiff") or file_path.lower().endswith("tif") or file_path.lower().endswith("img"):
 
 
                         exist_image: Image = Image.query.filter_by(path=os.path.normpath(file_info.get("path")),
                         exist_image: Image = Image.query.filter_by(path=os.path.normpath(file_info.get("path")),
-                                                            size=file_info.get("size")).one_or_none()
+                                                            size=file_info.get("real_size")).one_or_none()
                         file_info["exist"] = False
                         file_info["exist"] = False
                         if exist_image:
                         if exist_image:
                             if exist_image.server.__contains__(data_server):
                             if exist_image.server.__contains__(data_server):
                                 file_info["exist"] = True
                                 file_info["exist"] = True
 
 
-                    if file_path.lower().endswith("tiff") or file_path.lower().endswith("tif"):
-                        file_info["type"] = "tif"
-                        data_list.append(file_info)
-                    elif file_path.lower().endswith("img"):
-                        file_info["type"] = "img"
-                        data_list.append(file_info)
-                    elif os.path.isdir(file_path):
-                        file_info["type"] = "dir"
-                        data_list.append(file_info)
+
+                    file_info["type"] = ImageType.get_type(file_path)
+                    data_list.append(file_info)
+
 
 
                 data_list_sorted = sorted(data_list, key=lambda x: x["name"])
                 data_list_sorted = sorted(data_list, key=lambda x: x["name"])
                 res["data"] = data_list_sorted
                 res["data"] = data_list_sorted
@@ -76,8 +72,8 @@ class Api(ApiTemplate):
 
 
                 for inf in info:
                 for inf in info:
                     if inf["path"].lower().endswith("tiff") or inf["path"].lower().endswith("tif") or inf["path"].lower().endswith("img"):
                     if inf["path"].lower().endswith("tiff") or inf["path"].lower().endswith("tif") or inf["path"].lower().endswith("img"):
-                        dd = os.path.normpath(inf.get("path"))
-                        exist_image = Image.query.filter_by(path=os.path.normpath(inf.get("path")),
+
+                        exist_image = Image.query.filter_by(path=inf.get("path"),
                                                             size=inf.get("real_size")).one_or_none()
                                                             size=inf.get("real_size")).one_or_none()
                         inf["exist"] = False
                         inf["exist"] = False
                         if exist_image:
                         if exist_image:

+# coding=utf-8
+#author:        4N
+#createtime:    2021/7/19
+#email:         nheweijun@sina.com
+
+
+from osgeo import gdal,ogr,osr
+from osgeo.gdal import Dataset,Band
+from app.util.component.ApiTemplate import ApiTemplate
+from app.modules.service.image.util.ThriftConnect import ThriftConnect
+import json
+from .models import Image
+import datetime
+from app.models import  db
+import uuid
+import os
+from .models import ImageTag
+import math
+
+class Api(ApiTemplate):
+
+    api_name = "注册影像数据"
+
+    def process(self):
+
+        #可以注册一个目录
+        #返回结果
+        res = {}
+
+        try:
+            data_server = self.para.get("data_server")
+            paths = json.loads(self.para.get("paths"))
+
+            for path in paths:
+
+                exist_image:Image = Image.query.filter_by(path=path.get("path"),
+                                                    size=path.get("real_size")).one_or_none()
+                if exist_image:
+                    servers = exist_image.server.split(",")
+                    leave_servers = [ser for ser in servers if not ser.__eq__(data_server)]
+                    if len(leave_servers) ==0:
+                        db.session.delete(exist_image)
+                    else:
+                        Image.query.filter_by(path=path.get("path"),
+                                              size=path.get("real_size")).update({"server":",".join(leave_servers),
+                                                                                  "update_time":datetime.datetime.now()})
+                else:
+                    raise Exception("数据不存在！")
+
+            db.session.commit()
+            res["result"] = True
+
+        except Exception as e:
+            raise e
+
+        return res
+
+
+    api_doc = {
+        "tags": ["影像接口"],
+        "parameters": [
+            {"name": "data_server",
+             "in": "formData",
+             "type": "string",
+             "description": "data_server"},
+            {"name": "paths",
+             "in": "formData",
+             "type": "string",
+             "description": "paths"},
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
+    }
+
+

@@ -8,7 +8,7 @@
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ModelVisitor import ModelVisitor
 from app.util.component.ModelVisitor import ModelVisitor
 
 
-from app.modules.service.image.models import Image,db
+from app.modules.service.image.models import Image,db,ImageTag
 from sqlalchemy import or_,and_
 from sqlalchemy import or_,and_
 import datetime
 import datetime
 class Api(ApiTemplate):
 class Api(ApiTemplate):
@@ -22,10 +22,24 @@ class Api(ApiTemplate):
         try:
         try:
             para = self.para
             para = self.para
             guid = self.para.get("guid")
             guid = self.para.get("guid")
-            image = Image.query.filter_by(guid=guid).one_or_none()
+            tag_guids = self.para.get("tag_guids")
+
+            image = Image.query.filter_by(guid=guid)
+            this_time = datetime.datetime.now()
+
             del para["guid"]
             del para["guid"]
-            para["update_time"] = datetime.datetime.now()
-            image.update(para)
+            del para["tag_guids"]
+
+            if para or tag_guids:
+                para["update_time"] = this_time
+                image.update(para)
+
+            if tag_guids:
+                tags = ImageTag.query.filter(ImageTag.guid.in_(tag_guids.split(","))).all()
+                img = Image.query.filter_by(guid=guid).one_or_none()
+                img.image_tags = tags
+
+
             db.session.commit()
             db.session.commit()
 
 
             res["result"] = True
             res["result"] = True
@@ -38,6 +52,9 @@ class Api(ApiTemplate):
     api_doc = {
     api_doc = {
         "tags": ["影像接口"],
         "tags": ["影像接口"],
         "parameters": [
         "parameters": [
+            {"name": "guid",
+             "in": "formData",
+             "type": "string"},
             {"name": "alias",
             {"name": "alias",
              "in": "formData",
              "in": "formData",
              "type": "string"},
              "type": "string"},
@@ -47,6 +64,15 @@ class Api(ApiTemplate):
             {"name": "region",
             {"name": "region",
              "in": "formData",
              "in": "formData",
              "type": "string", "description": "所属区域"},
              "type": "string", "description": "所属区域"},
+            {"name": "satellite",
+             "in": "formData",
+             "type": "string", "description": "卫星类型"},
+            {"name": "epsg",
+             "in": "formData",
+             "type": "string", "description": "空间参考"},
+            {"name": "tag_guids",
+             "in": "formData",
+             "type": "string", "description": "tags"},
         ],
         ],
         "responses": {
         "responses": {
             200: {
             200: {

@@ -9,6 +9,7 @@ from app.util.component.ModelVisitor import ModelVisitor
 
 
 from app.modules.service.image.models import Image,ImageTag
 from app.modules.service.image.models import Image,ImageTag
 from sqlalchemy import or_,and_
 from sqlalchemy import or_,and_
+from app.util.component.FileProcess import FileProcess
 class Api(ApiTemplate):
 class Api(ApiTemplate):
 
 
     api_name = "影像数据Info"
     api_name = "影像数据Info"
@@ -24,11 +25,18 @@ class Api(ApiTemplate):
             image = Image.query.filter_by(guid=guid).one_or_none()
             image = Image.query.filter_by(guid=guid).one_or_none()
             if not image:
             if not image:
                 raise Exception("数据不存在！")
                 raise Exception("数据不存在！")
-            tags:ImageTag = image.image_tags.all()
-            tag_names = [tag.name for tag in tags]
+            tags:ImageTag = image.image_tags
+            # tag_names = [tag.name for tag in tags]
 
 
             res["data"] = ModelVisitor.object_to_json(image)
             res["data"] = ModelVisitor.object_to_json(image)
-            res["data"]["tag"] = ",".join(tag_names)
+
+            #格式化数据
+
+            res["data"]["size"] = FileProcess.get_text_size(res["data"]["size"])
+            res["data"]["cell_x_size"] = round(res["data"]["cell_x_size"],3)
+            res["data"]["cell_y_size"] = round(res["data"]["cell_y_size"], 3)
+
+            res["data"]["image_tags"] = ModelVisitor.objects_to_jsonarray(tags)
             res["result"] = True
             res["result"] = True
         except Exception as e:
         except Exception as e:
             raise e
             raise e

@@ -6,7 +6,7 @@
 
 
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ModelVisitor import ModelVisitor
 from app.util.component.ModelVisitor import ModelVisitor
-
+from app.util.component.FileProcess import FileProcess
 from app.modules.service.image.models import Image,ImageTag
 from app.modules.service.image.models import Image,ImageTag
 from sqlalchemy import or_,and_
 from sqlalchemy import or_,and_
 class Api(ApiTemplate):
 class Api(ApiTemplate):
@@ -23,9 +23,13 @@ class Api(ApiTemplate):
 
 
             alias = self.para.get("alias")
             alias = self.para.get("alias")
             name = self.para.get("name")
             name = self.para.get("name")
+            band = self.para.get("band")
+            region = self.para.get("region")
             tag_guid = self.para.get("tag_guid")
             tag_guid = self.para.get("tag_guid")
 
 
-            images = Image.query
+            type = self.para.get("type")
+
+            images = Image.query.order_by(Image.update_time.desc())
 
 
             # 并集
             # 并集
             if alias and name:
             if alias and name:
@@ -35,16 +39,33 @@ class Api(ApiTemplate):
                     images = images.filter(Image.alias.like("%" + alias + "%"))
                     images = images.filter(Image.alias.like("%" + alias + "%"))
                 if name:
                 if name:
                     images = images.filter(Image.name.like("%" + name + "%"))
                     images = images.filter(Image.name.like("%" + name + "%"))
+            if band:
+                images = images.filter(Image.band_view.like("%" + str(band) + "%"))
+
+            if type:
+                images = images.filter_by(type=type)
+
+            if region:
+                images = images.filter(Image.region.in_(region.split(",")))
+
             if tag_guid:
             if tag_guid:
                 tag:ImageTag = ImageTag.query.filter_by(guid=tag_guid).one_or_none()
                 tag:ImageTag = ImageTag.query.filter_by(guid=tag_guid).one_or_none()
                 images_guid = [img.guid for img in tag.images.all()]
                 images_guid = [img.guid for img in tag.images.all()]
                 images = images.filter(Image.guid.in_(images_guid))
                 images = images.filter(Image.guid.in_(images_guid))
 
 
 
 
-            images = images.limit(page_size).offset(page_index).all()
+            res["data"] = {}
+            res["data"]["count"] = images.count()
+            imgs = images.limit(page_size).offset(page_index * page_size).all()
+            res["data"]["list"] = ModelVisitor.objects_to_jsonarray(imgs)
 
 
-            res["data"] = ModelVisitor.objects_to_jsonarray(images)
+            #格式化数据
+            for info in res["data"]["list"]:
+                info["size"] = FileProcess.get_text_size(info["size"])
+                info["cell_x_size"] = round(info["cell_x_size"],3)
+                info["cell_y_size"] = round(info["cell_y_size"], 3)
             res["result"] = True
             res["result"] = True
+
         except Exception as e:
         except Exception as e:
             raise e
             raise e
 
 
@@ -68,6 +89,18 @@ class Api(ApiTemplate):
             {"name": "name",
             {"name": "name",
              "in": "formData",
              "in": "formData",
              "type": "string"},
              "type": "string"},
+            {"name": "ym",
+             "in": "formData",
+             "type": "string"},
+            {"name": "region",
+             "in": "formData",
+             "type": "string"},
+            {"name": "type",
+             "in": "formData",
+             "type": "string"},
+            {"name": "band",
+             "in": "formData",
+             "type": "string"},
             {"name": "tag_guid",
             {"name": "tag_guid",
              "in": "formData",
              "in": "formData",
              "type": "string"},
              "type": "string"},

@@ -8,9 +8,9 @@ from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.StructuredPrint import StructurePrint
 from app.util.component.StructuredPrint import StructurePrint
 
 
 from app.modules.service.image.models import Image
 from app.modules.service.image.models import Image
-from sqlalchemy import or_
+
 import random
 import random
-from .image_wms import Api as WMSApi
+
 import numpy
 import numpy
 import json
 import json
 from flask import Response
 from flask import Response
@@ -18,6 +18,8 @@ from kazoo.client import KazooClient
 import configure
 import configure
 import traceback
 import traceback
 
 
+from .util.ImageData import ImageData
+from .util.Opencv import Opencv
 
 
 class Api(ApiTemplate):
 class Api(ApiTemplate):
 
 
@@ -44,6 +46,12 @@ class Api(ApiTemplate):
 
 
 
 
             guid = self.para.get("guid")
             guid = self.para.get("guid")
+
+
+            width = int(self.para.get("width") if self.para.get("width") else 512)
+            height = int(self.para.get("height") if self.para.get("height") else 512)
+            format = self.para.get("format") if self.para.get("format") else "image/jpeg"
+
             image = Image.query.filter_by(guid=guid).one_or_none()
             image = Image.query.filter_by(guid=guid).one_or_none()
             # 该影像的服务器，随机选取一个
             # 该影像的服务器，随机选取一个
             image_servers = image.server.split(",")
             image_servers = image.server.split(",")
@@ -54,8 +62,6 @@ class Api(ApiTemplate):
             else:
             else:
                 image_server = "None"
                 image_server = "None"
 
 
-            wms_api = WMSApi()
-
             bands = json.loads(image.band_view)
             bands = json.loads(image.band_view)
 
 
             # bands = [1,2,3] if image.band_count>=3 else [1,1,1]
             # bands = [1,2,3] if image.band_count>=3 else [1,1,1]
@@ -70,18 +76,20 @@ class Api(ApiTemplate):
                 query_extent = [query_extent[0] - offset, query_extent[1], query_extent[2] + offset, query_extent[3]]
                 query_extent = [query_extent[0] - offset, query_extent[1], query_extent[2] + offset, query_extent[3]]
 
 
 
 
-            pixel_array_t = wms_api.get_data(image_server, image, query_extent, bands, 256, 256)
+            image_data = ImageData(image_server, image)
+
+            pixel_array_t = image_data.get_data(query_extent, bands, height, width)
 
 
+            pixel_array = numpy.zeros((height, width, 3), dtype=int)
 
 
-            pixel_array = numpy.zeros((256, 256, 3), dtype=int)
             for ii in [0, 1, 2]:
             for ii in [0, 1, 2]:
                 # opencv 颜色排序为GBR
                 # opencv 颜色排序为GBR
                 pixel_array[:, :, 2 - ii] = pixel_array_t[:, :, ii]
                 pixel_array[:, :, 2 - ii] = pixel_array_t[:, :, ii]
 
 
             # 将图片生成在内存中,然后直接返回response
             # 将图片生成在内存中,然后直接返回response
-            im_data = wms_api.create_by_opencv("image/jpeg", pixel_array, 30)
+            im_data = Opencv.create_image(format, pixel_array, 30)
 
 
-            return Response(im_data, mimetype="image/jpeg")
+            return Response(im_data, mimetype=format)
 
 
         except Exception as e:
         except Exception as e:
             StructurePrint().print(traceback.format_exc())
             StructurePrint().print(traceback.format_exc())
@@ -96,6 +104,16 @@ class Api(ApiTemplate):
             {"name": "guid",
             {"name": "guid",
              "in": "formData",
              "in": "formData",
              "type": "string"},
              "type": "string"},
+            {"name": "height",
+             "in": "formData",
+             "type": "string"},
+            {"name": "width",
+             "in": "formData",
+             "type": "string"},
+            {"name": "format",
+             "in": "formData",
+             "type": "string",
+             "enum":["image/jpeg","image/png"]},
         ],
         ],
         "responses": {
         "responses": {
             200: {
             200: {
@@ -107,4 +125,3 @@ class Api(ApiTemplate):
         }
         }
     }
     }
 
 
-

@@ -16,6 +16,7 @@ import uuid
 import os
 import os
 from .models import ImageTag
 from .models import ImageTag
 import math
 import math
+from .util.ImageType import ImageType
 
 
 class Api(ApiTemplate):
 class Api(ApiTemplate):
 
 
@@ -117,7 +118,8 @@ class Api(ApiTemplate):
                     if exist_image.server.__contains__(data_server):
                     if exist_image.server.__contains__(data_server):
                         pass
                         pass
                     else:
                     else:
-                        exist_image.update({"server":"{},{}".format(exist_image.server,data_server)})
+                        Image.query.filter_by(path=os.path.normpath(info.get("path")),
+                                              size=info.get("size")).update({"server":"{},{}".format(exist_image.server,data_server)})
                 else:
                 else:
                     img:Image = Image(guid= uuid.uuid1().__str__(),
                     img:Image = Image(guid= uuid.uuid1().__str__(),
                                   overview_count=info.get("overview_count"),
                                   overview_count=info.get("overview_count"),
@@ -136,7 +138,10 @@ class Api(ApiTemplate):
                                   sr_wkt = info.get("sr_wkt"),
                                   sr_wkt = info.get("sr_wkt"),
                                   sr_proj4= info.get("sr_proj4"),
                                   sr_proj4= info.get("sr_proj4"),
                                   band_count=info.get("band_count"),
                                   band_count=info.get("band_count"),
-                                  create_time=this_time
+                                  band_view = "[1,2,3]" if info.get("band_count")>=3 else "[1,1,1]",
+                                  create_time=this_time,
+                                  update_time=this_time,
+                                  type = ImageType.get_type(info.get("path"))
                                   )
                                   )
                     for tag in tags:
                     for tag in tags:
                         img.image_tags.append(tag)
                         img.image_tags.append(tag)

@@ -25,8 +25,13 @@ class Api(ApiTemplate):
             else :
             else :
                 if not zoo.connected:
                 if not zoo.connected:
                     zoo.start()
                     zoo.start()
-            res["data"] = zoo.get_children("/rpc")
-            res["data"].append("本地服务器")
+            sers = zoo.get_children("/rpc")
+            res["data"] = []
+            for p in sers:
+                bl = str( zoo.get("/rpc/{}".format(p))[0] , encoding = "utf-8")
+                res["data"].append({"name": p, "belong": bl})
+
+            res["data"].append({"name":"本地服务器","belong":""})
             res["result"] = True
             res["result"] = True
         except Exception as e:
         except Exception as e:
             raise e
             raise e

@@ -8,6 +8,11 @@ from app.models import db
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ApiTemplate import ApiTemplate
 from app.models import Service
 from app.models import Service
 import datetime
 import datetime
+import json
+from .image_service_register import Api  as RegisterApi
+import configure
+
+
 class Api(ApiTemplate):
 class Api(ApiTemplate):
 
 
     api_name = "修改影像服务"
     api_name = "修改影像服务"
@@ -20,40 +25,97 @@ class Api(ApiTemplate):
         try:
         try:
 
 
             guid = self.para.get("guid")
             guid = self.para.get("guid")
-            service = Service.query.filter_by(guid=guid).one_or_none()
+            service = Service.query.filter_by(guid=guid)
             this_time = datetime.datetime.now()
             this_time = datetime.datetime.now()
+            image_guids = self.para.get("image_guids")
 
 
-
-            service_update = {"upate_time":this_time}
-            image_service = {"upate_time":this_time}
+            service_update = {}
+            image_update = {}
             for key in self.para.keys():
             for key in self.para.keys():
-                if key in ["name","alias","state","description","catalog_guid"]:
+                if key in ["name","title","state","description","catalog_guid"]:
                     service_update[key] = self.para.get(key)
                     service_update[key] = self.para.get(key)
                 if key in ["name","scheme_guid"]:
                 if key in ["name","scheme_guid"]:
-                    image_service[key] = self.para.get(key)
+                    image_update[key] = self.para.get(key)
+
+
+
+            image_service = ImageService.query.filter_by(guid=Service.query.filter_by(guid=guid).one_or_none().service_guid)
 
 
-            image_service = ImageService.query.filter_by(guid=service.service_guid).one_or_none()
 
 
-            service.update(service_update)
-            image_service.update(image_service)
+            #修改影像
+            if image_guids:
+                image_service_exetent = []
+                imgservice:ImageService = image_service.one_or_none()
+                imgservice.images = []
+
+                for g in image_guids.split(","):
+                    image = Image.query.filter_by(guid=g).one_or_none()
+                    if image:
+                        image_extent = json.loads(image.extent)
+                        if not image_service_exetent:
+                            image_service_exetent = image_extent
+                        else:
+                            image_service_exetent[0] = min(image_extent[0], image_service_exetent[0])
+                            image_service_exetent[1] = min(image_extent[1], image_service_exetent[1])
+                            image_service_exetent[2] = max(image_extent[2], image_service_exetent[2])
+                            image_service_exetent[3] = max(image_extent[3], image_service_exetent[3])
+                        imgservice.images.append(image)
+
+                    image_update["extent"] = json.dumps(image_service_exetent)
+
+            if service_update or image_update:
+                service_update["update_time"] = this_time
+                if image_guids:
+                    register_api = RegisterApi()
+                    overview_file = register_api.get_overview(service, image_service)
+                    service_update["overview"] = "http://{}/API/Service/Overview/{}".format(configure.deploy_ip_host, overview_file)
+
+                service.update(service_update)
+            if image_update:
+                image_service.update(image_update)
 
 
             db.session.commit()
             db.session.commit()
 
 
             res["result"] = True
             res["result"] = True
         except Exception as e:
         except Exception as e:
+            db.session.rollback()
             raise e
             raise e
 
 
         return res
         return res
 
 
+
     api_doc = {
     api_doc = {
         "tags": ["影像接口"],
         "tags": ["影像接口"],
         "parameters": [
         "parameters": [
+
             {"name": "guid",
             {"name": "guid",
              "in": "formData",
              "in": "formData",
-             "type": "string"},
+             "type": "string",
+             "description": "[WMS,WMTS,影像WMS,影像WMTS,guid]"},
+
             {"name": "name",
             {"name": "name",
              "in": "formData",
              "in": "formData",
-             "type": "string"},
+             "type": "string",
+             "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
+
+            {"name": "title",
+             "in": "formData",
+             "type": "string",
+             "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
+            {"name": "description",
+             "in": "formData",
+             "type": "string",
+             "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
+
+            {"name": "catalog_guid",
+             "in": "formData",
+             "type": "string",
+             "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
+
+
+            {"name": "image_guids",
+             "in": "formData",
+             "type": "string","description":"修改该服务的影像，用逗号相隔"},
         ],
         ],
         "responses": {
         "responses": {
             200: {
             200: {

@@ -39,10 +39,13 @@ class Api(ApiTemplate):
                 if name:
                 if name:
                     services = services.filter(ImageService.name.like("%" + name + "%"))
                     services = services.filter(ImageService.name.like("%" + name + "%"))
 
 
-            services = services.limit(page_size).offset(page_index).all()
 
 
-            res["data"] = ModelVisitor.objects_to_jsonarray(services)
+            res["data"] = {}
+            res["data"]["count"] = services.count()
+            services = services.limit(page_size).offset(page_index * page_size).all()
+            res["data"]["list"] = ModelVisitor.objects_to_jsonarray(services)
             res["result"] = True
             res["result"] = True
+
         except Exception as e:
         except Exception as e:
             raise e
             raise e
 
 

@@ -12,7 +12,7 @@ from app.util.component.FileProcess import FileProcess
 import os
 import os
 import json
 import json
 import datetime
 import datetime
-from .image_wms import Api  as Api2
+from .image_wms import Api  as RealApi
 import cv2
 import cv2
 import configure
 import configure
 
 
@@ -62,7 +62,7 @@ class Api(ApiTemplate):
             service = Service(
             service = Service(
                 guid = service_guid,
                 guid = service_guid,
                 name = self.para.get("name"),
                 name = self.para.get("name"),
-                alias = self.para.get("alias"),
+                title = self.para.get("title"),
                 state = 1,
                 state = 1,
                 create_time = this_time,
                 create_time = this_time,
                 update_time = this_time,
                 update_time = this_time,
@@ -93,7 +93,7 @@ class Api(ApiTemplate):
 
 
     def get_overview(self,service,image_service):
     def get_overview(self,service,image_service):
 
 
-        api = Api2()
+        api = RealApi()
 
 
 
 
         query_extent = json.loads(image_service.extent)
         query_extent = json.loads(image_service.extent)
@@ -106,7 +106,7 @@ class Api(ApiTemplate):
 
 
         bbox = ",".join([str(x) for x in query_extent])
         bbox = ",".join([str(x) for x in query_extent])
 
 
-        api.para = {"guid":image_service.guid,"bbox":bbox,"overview":1}
+        api.para = {"guid":image_service.guid,"bbox":bbox,"overview":1,"width":512,"height":512}
         res = api.process()
         res = api.process()
         dir_path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "overview")
         dir_path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "overview")
         gid = uuid.uuid1().__str__()
         gid = uuid.uuid1().__str__()
@@ -128,7 +128,7 @@ class Api(ApiTemplate):
              "type": "string",
              "type": "string",
              "required": "true",
              "required": "true",
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
-            {"name": "alias",
+            {"name": "title",
              "in": "formData",
              "in": "formData",
              "type": "string",
              "type": "string",
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
@@ -139,7 +139,7 @@ class Api(ApiTemplate):
             {"name": "type",
             {"name": "type",
              "in": "formData",
              "in": "formData",
              "type": "string",
              "type": "string",
-             "enum": ["WMS/WFS","WMTS","MTS","ImageWMS","ImageWMTS"],
+             "enum": ["WMS/WFS","WMTS","TMS","ImageWMS","ImageWMTS"],
              "required": "true",
              "required": "true",
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
             {"name": "catalog_guid",
             {"name": "catalog_guid",

@@ -19,8 +19,12 @@ class Api(ApiTemplate):
         res = {}
         res = {}
         try:
         try:
             image_tags = ImageTag.query.all()
             image_tags = ImageTag.query.all()
-            res["data"] = ModelVisitor.objects_to_jsonarray(image_tags)
+
+            res["data"] = {}
+            res["data"]["count"] = ImageTag.query.count()
+            res["data"]["list"] = ModelVisitor.objects_to_jsonarray(image_tags)
             res["result"] = True
             res["result"] = True
+
         except Exception as e:
         except Exception as e:
             raise e
             raise e
         return res
         return res

@@ -10,9 +10,7 @@ from osgeo.gdal import *
 from numpy import ndarray
 from numpy import ndarray
 import numpy
 import numpy
 from flask import Response
 from flask import Response
-import io
-import os
-from PIL import Image
+from .util.ImageData import ImageData
 
 
 import time
 import time
 import cv2
 import cv2
@@ -28,8 +26,9 @@ from app.modules.service.image.util.ThriftConnect import ThriftConnect,ThriftPoo
 import gzip
 import gzip
 import random
 import random
 import copy
 import copy
-
-
+from .util.Opencv import Opencv
+from .util.Cache import Cache
+from .util.MyThread import MyThread
 
 
 class Api(ApiTemplate):
 class Api(ApiTemplate):
 
 
@@ -51,7 +50,7 @@ class Api(ApiTemplate):
             if parameter.get("guid"):
             if parameter.get("guid"):
                 self.guid = parameter.get("guid")
                 self.guid = parameter.get("guid")
 
 
-            image_service_info, zoo, servers = self.cache_data()
+            image_service_info, zoo, servers = Cache.cache_data(self.guid)
 
 
             # bands = [1, 2, 3]
             # bands = [1, 2, 3]
 
 
@@ -75,6 +74,11 @@ class Api(ApiTemplate):
 
 
             height, width = 256,256
             height, width = 256,256
 
 
+
+            re = parameter.get("request")
+            if re and re.__eq__("GetCapabilities"):
+                return self.get_capabilities(image_service_info["service"])
+
             # 多线程获取分布式数据
             # 多线程获取分布式数据
 
 
             intersect_image = [im for im in image_service_info["images"] if self.determin_intersect(json.loads(im.extent),extent)]
             intersect_image = [im for im in image_service_info["images"] if self.determin_intersect(json.loads(im.extent),extent)]
@@ -99,8 +103,10 @@ class Api(ApiTemplate):
 
 
                     bands = json.loads(image.band_view)
                     bands = json.loads(image.band_view)
 
 
-                    thread: MyThread = MyThread(self.get_data,
-                                                args=(image_server, image, extent, bands, height, width))
+                    image_data = ImageData(image_server,image)
+
+                    thread: MyThread = MyThread(image_data.get_data,args=(extent, bands, height, width))
+
                     thread.start()
                     thread.start()
                     thread_list.append(thread)
                     thread_list.append(thread)
 
 
@@ -139,7 +145,9 @@ class Api(ApiTemplate):
                     image_server = "None"
                     image_server = "None"
                 # image_server = image_servers[0]
                 # image_server = image_servers[0]
                 bands = json.loads(image.band_view)
                 bands = json.loads(image.band_view)
-                pixel_array_t:numpy.ndarray = self.get_data(image_server, image, extent, bands, height, width)
+
+                image_data = ImageData(image_server, image)
+                pixel_array_t: numpy.ndarray = image_data.get_data(extent, bands, height, width)
                 pixel_array = numpy.zeros((height, width, 3), dtype=int)
                 pixel_array = numpy.zeros((height, width, 3), dtype=int)
 
 
                 for ii in [0, 1, 2]:
                 for ii in [0, 1, 2]:
@@ -152,7 +160,7 @@ class Api(ApiTemplate):
 
 
 
 
             # 将图片生成在内存中,然后直接返回response
             # 将图片生成在内存中,然后直接返回response
-            im_data = self.create_by_opencv(image_type, pixel_array, quality)
+            im_data = Opencv.create_image(image_type, pixel_array, quality)
             return Response(im_data, mimetype=image_type.lower())
             return Response(im_data, mimetype=image_type.lower())
 
 
 
 
@@ -162,382 +170,15 @@ class Api(ApiTemplate):
             result["message"] = e.__str__()
             result["message"] = e.__str__()
             return result
             return result
 
 
-    def cache_data(self):
-
-        from app import GLOBAL_DIC
-
-        # 缓存zookeeper
-        zoo = GLOBAL_DIC.get("zookeeper")
-        if zoo is None:
-            zoo: KazooClient = KazooClient(hosts=configure.zookeeper, timeout=100)
-            zoo.start()
-            GLOBAL_DIC["zookeeper"] = zoo
-        else:
-            if not zoo.connected:
-                zoo.start()
-
-        # 缓存数据服务器
-        servers = GLOBAL_DIC.get("servers")
-        if servers is None:
-            servers = zoo.get_children("/rpc")
-            servers.append("本地服务器")
-            GLOBAL_DIC["servers"] = servers
-            GLOBAL_DIC["servers_updatetime"] = time.time()
-        else:
-            servers = GLOBAL_DIC.get("servers")
-
-        # 更新缓存
-        if time.time() - GLOBAL_DIC["servers_updatetime"] > 10:
-            servers = zoo.get_children("/rpc")
-            servers.append("本地服务器")
-            GLOBAL_DIC["servers"] = servers
-            GLOBAL_DIC["servers_updatetime"] = time.time()
-
-
-        # 缓存服务信息
-        image_service_info = GLOBAL_DIC.get(self.guid)
-        if image_service_info is None or time.time() - GLOBAL_DIC.get("service_updatetime") > 20:
-            image_service: ImageService = ImageService.query.filter_by(guid=self.guid).one_or_none()
-            images = image_service.images.all()
-            scheme: TileScheme = TileScheme.query.filter_by(guid=image_service.scheme_guid).one_or_none()
-            GLOBAL_DIC[self.guid] = {"service": image_service, "images": images, "scheme": json.loads(scheme.parameter)}
-            GLOBAL_DIC["service_updatetime"] = time.time()
-            image_service_info = GLOBAL_DIC[self.guid]
-
-        else:
-            image_service_info = GLOBAL_DIC[self.guid]
-
-        return image_service_info,zoo,servers
-
-    def determine_level(self, xysize, origin_extent, extent, max_level):
-        '''
-        根据范围判断调用金字塔的哪一层
-        :param xysize:
-        :param origin_extent:
-        :param extent:
-        :param max_level:
-        :return:
-        '''
-        x = xysize[0]
-        y = xysize[1]
-        level = -1
-        pixel = x * y * (((extent[2] - extent[0]) * (extent[3] - extent[1])) / (
-                (origin_extent[2] - origin_extent[0]) * (origin_extent[3] - origin_extent[1])))
-        while pixel > 100000 and level < max_level - 1:
-            level += 1
-            x = x / 2
-            y = y / 2
-            pixel = x * y * (((extent[2] - extent[0]) * (extent[3] - extent[1])) / (
-                    (origin_extent[2] - origin_extent[0]) * (origin_extent[3] - origin_extent[1])))
-        return level
-
-
-    def create_by_opencv(self, image_type, pixel_array, quality):
-
-        if image_type.__eq__("image/jpeg") or image_type.__eq__("image/jpg"):
-            r, buf = cv2.imencode(".jpg", pixel_array, [cv2.IMWRITE_JPEG_QUALITY, quality])
-            # r, buf = cv2.imencode(".jpg", pixel_array)
-            image_out = buf.tobytes()
-        else:
-            height, width = pixel_array[:, :, 0].shape
-            four = numpy.zeros((height, width), dtype=int) + 255
-            four[pixel_array[:, :, 0] == 65536] = 0
-            r, buf = cv2.imencode(".png", numpy.dstack((pixel_array, four)))
-            image_out = buf.tobytes()
-        return image_out
-
-    def get_data(self,image_server, image, extent, bands, height, width):
-
-        if image_server.__eq__("本地服务器"):
-            data = self.get_local_wms_data2(image, extent, bands, height, width)
-        elif image_server.__eq__("None"):
-            data = numpy.zeros((height, width, 3), dtype=int) + 65536
-        else:
-            data = self.get_remote_wms_data(image_server,image, extent, bands, height, width)
-        return data
-
-    def get_remote_wms_data(self, image_server,image, extent, bands, height, width):
-        '''
-        通过RPC获取远程数据
-        :param image:
-        :param extent:
-        :param bands:
-        :return:
-        '''
-
-        #需要做thrift连接的缓存，连接池
-        thrift_connect = ThriftConnect(image_server)
-        image_extent = image.extent
-
-        data = thrift_connect.client.getData(image.path, extent, json.loads(image_extent), bands, width, height)
-
-        thrift_connect.close()
-
-        data = gzip.decompress(data)
-        data = numpy.frombuffer(data, dtype='int64')
-        data = data.reshape((height, width, 3))
-
-        return data
-
-
-    def get_remote_wms_data_cpp(self, image_server,image, extent, bands, height, width):
-        '''
-        通过RPC获取远程数据
-        :param image:
-        :param extent:
-        :param bands:
-        :return:
-        '''
-
-        #需要做thrift连接的缓存，连接池
-        thrift_connect = ThriftConnect(image_server)
-        image_extent = image.extent
-
-        data = thrift_connect.client.getData(image.path, extent, json.loads(image_extent), bands, width, height)
-
-        thrift_connect.close()
-
-        return data
-
-    def get_remote_wms_data_client(self,image_server,image, extent, bands, height, width):
-        '''
-        通过RPC获取远程数据
-        :param image:
-        :param extent:
-        :param bands:
-        :return:
-        '''
-        from app import GLOBAL_DIC
-
-        # 缓存thrift_pool
-        thrift_pool = GLOBAL_DIC.get(image_server)
-        if thrift_pool is None:
-            thrift_pool = ThriftPool(image_server)
-            GLOBAL_DIC["image_server"] = thrift_pool
-        image_extent = image.extent
-
-        client,transport = thrift_pool.get_client()
-        transport.open()
-        data = client.getData(image.path, extent, json.loads(image_extent), bands, width, height)
-        transport.close()
-        data = gzip.decompress(data)
-        data = numpy.frombuffer(data, dtype='int64')
-        data = data.reshape((height, width, 3))
-
-        return data
-
-    # def get_remote_wms_data_c(self, image_server,image, extent, bands, height, width):
-    #     '''
-    #     通过RPC获取远程数据
-    #     :param image:
-    #     :param extent:
-    #     :param bands:
-    #     :return:
-    #     '''
-    #
-    #     #需要做thrift连接的缓存，连接池
-    #     thrift_connect = ThriftConnect_C(image_server)
-    #     image_extent = image.extent
-    #
-    #     data = thrift_connect.client.getData(image.path, extent, json.loads(image_extent), bands, width, height)
-    #
-    #     thrift_connect.close()
-    #
-    #     data = gzip.decompress(data)
-    #     data = numpy.frombuffer(data, dtype='int64')
-    #
-    #
-    #     data = data.reshape((height, width, 3))
-    #
-    #     return data
-
-
-    def get_local_wms_data(self, image, extent, bands, height, width):
-        '''
-        获取本地数据
-        :param image:
-        :param extent:
-        :param bands:
-        :return:
-        '''
-        pixel_array = numpy.zeros((height, width, 3), dtype=int)
-        ceng = 0
-        img: Dataset = gdal.Open(image.path, 0)
-
-
-
-        for band in bands:
-
-            # 自决定金字塔等级
-            xysize = [img.RasterXSize, img.RasterYSize]
-
-            origin_extent = json.loads(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((height, width), 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, width, height)
-
-
-                # 部分相交
-                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]) / (width * 1.0)
-                    out_grid_y = (extent[3] - extent[1]) / (height * 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))
+    def get_capabilities(self):
+        return {}
 
 
-                    # 相交部分在出图的哪个位置
 
 
-                    overview_raster: ndarray = overview.ReadAsArray(off_x, off_y, x_g, y_g, out_x_g,
-                                                                    out_y_g)
-
-                    dat = numpy.zeros((height, width), 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
-        return pixel_array
-
-    def get_local_wms_data2(self, image, extent, bands, height, width):
-        '''
-        获取本地数据
-        :param image:
-        :param extent:
-        :param bands:
-        :return:
-        '''
-        pixel_array = numpy.zeros((height, width, 3), dtype=int)
-        ceng = 0
-        img: Dataset = gdal.Open(image.path, 0)
-
-        origin_extent = json.loads(image.extent)
-
-        # 超出空间范围
-        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((height, width,3), dtype=int) + 65536
-        # 空间范围相交
-        else:
-
-            ox = img.RasterXSize
-            oy = img.RasterYSize
-
-            # 网格大小
-            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 = img.ReadRaster(off_x, off_y, x_g, y_g,256,256,band_list=[1,2,3])
-                img.ReadAsArray()
-            # 部分相交
-            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]) / (width * 1.0)
-                out_grid_y = (extent[3] - extent[1]) / (height * 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 = img.ReadAsArray(off_x, off_y, x_g, y_g, out_x_g,
-                                                                out_y_g)
-
-                dat = numpy.zeros((height, width,3), 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 empty
 
 
     def determin_intersect(self, extent1, extent2):
     def determin_intersect(self, extent1, extent2):
         if extent2[2] < extent1[0] or extent2[0] > extent1[2] or extent2[1] > extent1[
         if extent2[2] < extent1[0] or extent2[0] > extent1[2] or extent2[1] > extent1[
@@ -580,18 +221,5 @@ class Api(ApiTemplate):
         }
         }
     }
     }
 
 
-class MyThread(Thread):
-    def __init__(self,func,args=()):
-        super(MyThread,self).__init__()
-        self.func = func
-        self.args = args
-    def run(self):
-        self.result = self.func(*self.args)
-    def get_result(self):
-        try:
-            return self.result
-        except Exception:
-            return None
-
 
 
 
 

@@ -5,25 +5,17 @@
 
 
 from app.util import *
 from app.util import *
 import traceback
 import traceback
-from osgeo import gdal
-from osgeo.gdal import *
-from numpy import ndarray
 import numpy
 import numpy
 from flask import Response
 from flask import Response
 import random
 import random
-import time
-import cv2
 from app.modules.service.image.models import ImageService
 from app.modules.service.image.models import ImageService
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ApiTemplate import ApiTemplate
-from app.util.component.GeometryAdapter import GeometryAdapter
-from app.modules.service.image.util.ThriftConnect import ThriftConnect,ThriftPool
 from app.util.component.ParameterUtil import ParameterUtil
 from app.util.component.ParameterUtil import ParameterUtil
 import json
 import json
-from kazoo.client import KazooClient
-
 from threading import Thread
 from threading import Thread
-from flask import current_app
-import gzip
+from .util.ImageData import ImageData
+from .util.Cache import Cache
+from .util.Opencv import Opencv
 
 
 class Api(ApiTemplate):
 class Api(ApiTemplate):
 
 
@@ -45,7 +37,7 @@ class Api(ApiTemplate):
             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
 
 
-            image_service_info, zoo, servers = self.cache_data()
+            image_service_info, zoo, servers = Cache.cache_data(self.guid)
 
 
             re = parameter.get("request")
             re = parameter.get("request")
             if re and re.__eq__("GetCapabilities"):
             if re and re.__eq__("GetCapabilities"):
@@ -78,7 +70,10 @@ class Api(ApiTemplate):
                     else:
                     else:
                         image_server = "None"
                         image_server = "None"
                     bands = json.loads(image.band_view)
                     bands = json.loads(image.band_view)
-                    thread: MyThread = MyThread(self.get_data, args=(image_server,image,extent,bands,height,width))
+
+                    image_data = ImageData(image_server, image)
+
+                    thread: MyThread = MyThread(image_data.get_data, args=(extent,bands,height,width))
                     thread.start()
                     thread.start()
                     thread_list.append(thread)
                     thread_list.append(thread)
 
 
@@ -116,7 +111,11 @@ class Api(ApiTemplate):
                     image_server = "None"
                     image_server = "None"
 
 
                 bands = json.loads(image.band_view)
                 bands = json.loads(image.band_view)
-                pixel_array_t = self.get_data(image_server,image,extent,bands,height,width)
+
+                image_data = ImageData(image_server, image)
+
+                pixel_array_t = image_data.get_data(extent,bands,height,width)
+
                 pixel_array = numpy.zeros((height, width, 3), dtype=int)
                 pixel_array = numpy.zeros((height, width, 3), dtype=int)
                 for ii in [0, 1, 2]:
                 for ii in [0, 1, 2]:
                     # opencv 颜色排序为GBR
                     # opencv 颜色排序为GBR
@@ -126,7 +125,7 @@ class Api(ApiTemplate):
                 pixel_array = numpy.zeros((height, width, 3), dtype=int)+65536
                 pixel_array = numpy.zeros((height, width, 3), dtype=int)+65536
 
 
             # 将图片生成在内存中,然后直接返回response
             # 将图片生成在内存中,然后直接返回response
-            im_data = self.create_by_opencv(image_type, pixel_array, quality)
+            im_data = Opencv.create_image(image_type, pixel_array, quality)
 
 
             if self.para.get("overview"):
             if self.para.get("overview"):
                 return pixel_array
                 return pixel_array
@@ -139,251 +138,6 @@ class Api(ApiTemplate):
             return result
             return result
 
 
 
 
-    def cache_data(self):
-
-        from app import GLOBAL_DIC
-
-        # 缓存zookeeper
-        zoo = GLOBAL_DIC.get("zookeeper")
-        if zoo is None:
-            zoo: KazooClient = KazooClient(hosts=configure.zookeeper, timeout=100)
-            zoo.start()
-            GLOBAL_DIC["zookeeper"] = zoo
-        else:
-            if not zoo.connected:
-                zoo.start()
-
-        # 缓存数据服务器
-        servers = GLOBAL_DIC.get("servers")
-        if servers is None:
-            servers = zoo.get_children("/rpc")
-            servers.append("本地服务器")
-            GLOBAL_DIC["servers"] = servers
-            GLOBAL_DIC["servers_updatetime"] = time.time()
-        else:
-            servers = GLOBAL_DIC.get("servers")
-
-        # 更新缓存
-        if time.time() - GLOBAL_DIC["servers_updatetime"] > 10:
-            servers = zoo.get_children("/rpc")
-            servers.append("本地服务器")
-            GLOBAL_DIC["servers"] = servers
-            GLOBAL_DIC["servers_updatetime"] = time.time()
-
-
-        # 缓存服务信息
-        image_service_info = GLOBAL_DIC.get(self.guid)
-        if image_service_info is None or time.time() - GLOBAL_DIC.get("service_updatetime") > 20:
-            image_service: ImageService = ImageService.query.filter_by(guid=self.guid).one_or_none()
-            images = image_service.images.all()
-            GLOBAL_DIC[self.guid] = {"service": image_service, "images": images}
-            GLOBAL_DIC["service_updatetime"] = time.time()
-            image_service_info = GLOBAL_DIC[self.guid]
-
-        else:
-            image_service_info = GLOBAL_DIC[self.guid]
-
-        return image_service_info,zoo,servers
-
-
-
-    def determine_level(self,xysize,origin_extent,extent,max_level):
-        '''
-        根据范围判断调用金字塔的哪一层
-        :param xysize:
-        :param origin_extent:
-        :param extent:
-        :param max_level:
-        :return:
-        '''
-        x = xysize[0]
-        y = xysize[1]
-        level = -1
-        pixel = x*y * (((extent[2]-extent[0])*(extent[3]-extent[1]))/((origin_extent[2]-origin_extent[0])*(origin_extent[3]-origin_extent[1])))
-        while pixel>100000 and level<max_level-1:
-            level+=1
-            x=x/2
-            y=y/2
-            pixel = x * y * (((extent[2] - extent[0]) * (extent[3] - extent[1])) / (
-                    (origin_extent[2] - origin_extent[0]) * (origin_extent[3] - origin_extent[1])))
-        return level
-
-    def create_by_opencv(self,image_type, pixel_array, quality):
-
-        if image_type.__eq__("image/jpeg") or image_type.__eq__("image/jpg"):
-            r, buf = cv2.imencode(".jpg", pixel_array, [cv2.IMWRITE_JPEG_QUALITY, quality])
-            image_out = buf.tobytes()
-        else:
-            height, width = pixel_array[:, :, 0].shape
-            four = numpy.zeros((height,width), dtype=int) + 255
-            four[pixel_array[:, :, 0] == 65536] = 0
-            r, buf = cv2.imencode(".png", numpy.dstack((pixel_array, four)))
-            image_out = buf.tobytes()
-        return image_out
-
-    def get_data(self,image_server, image, extent, bands, height, width):
-
-        if image_server.__eq__("本地服务器"):
-            data = self.get_local_wms_data(image, extent, bands, height, width)
-        elif image_server.__eq__("None"):
-            data = numpy.zeros((height, width, 3), dtype=int) + 65536
-        else:
-            data = self.get_remote_wms_data(image_server,image, extent, bands, height, width)
-        return data
-
-
-
-    def get_remote_wms_data(self,image_server,image,extent,bands,height,width):
-        '''
-        通过RPC获取远程数据
-        :param image:
-        :param extent:
-        :param bands:
-        :return:
-        '''
-        thrift_connect = ThriftConnect(image_server)
-        image_extent = image.extent
-
-        data = thrift_connect.client.getData(image.path, extent, json.loads(image_extent), bands,width,height)
-
-        thrift_connect.close()
-        # current_app.logger.info("time {}".format(time.time() - t1))
-        data = gzip.decompress(data)
-        data = numpy.frombuffer(data, dtype='int64')
-        data = data.reshape((height,width, 3))
-
-        return data
-
-    def get_remote_wms_data_client(self,image_server,image, extent, bands, height, width):
-        '''
-        通过RPC获取远程数据
-        :param image:
-        :param extent:
-        :param bands:
-        :return:
-        '''
-        from app import GLOBAL_DIC
-
-        # 缓存thrift_pool
-        thrift_pool = GLOBAL_DIC.get(image_server)
-        if thrift_pool is None:
-            thrift_pool = ThriftPool(image_server)
-            GLOBAL_DIC["image_server"] = thrift_pool
-        client = thrift_pool.get_client()
-
-        image_extent = image.extent
-
-        data = client.getData(image.path, extent, json.loads(image_extent), bands, width, height)
-
-        data = gzip.decompress(data)
-        data = numpy.frombuffer(data, dtype='int64')
-        data = data.reshape((height, width, 3))
-
-        return data
-
-    def get_local_wms_data(self,image,extent,bands,height,width):
-        '''
-        获取本地数据
-        :param image:
-        :param extent:
-        :param bands:
-        :return:
-        '''
-        pixel_array = numpy.zeros((height,width, 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 = json.loads(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((height,width), 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, width,height)
-
-
-                # 部分相交
-                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]) / (width * 1.0)
-                    out_grid_y = (extent[3] - extent[1]) / (height * 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((height,width), 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
-        return pixel_array
 
 
     def determin_intersect(self, extent1, extent2):
     def determin_intersect(self, extent1, extent2):
         if extent2[2] < extent1[0] or extent2[0] > extent1[2] or extent2[1] > extent1[
         if extent2[2] < extent1[0] or extent2[0] > extent1[2] or extent2[1] > extent1[
@@ -478,6 +232,7 @@ class Api(ApiTemplate):
                     <Title>{service_title}</Title>
                     <Title>{service_title}</Title>
                     <CRS>{crs}</CRS>
                     <CRS>{crs}</CRS>
                     <BoundingBox CRS="{crs}" maxx="{maxx}" maxy="{maxy}" minx="{minx}" miny="{miny}"/>
                     <BoundingBox CRS="{crs}" maxx="{maxx}" maxy="{maxy}" minx="{minx}" miny="{miny}"/>
+                    
                     <Layer queryable="1">
                     <Layer queryable="1">
                         <CRS>{crs}</CRS>
                         <CRS>{crs}</CRS>
                         <Name>{layer_name}</Name>
                         <Name>{layer_name}</Name>
@@ -499,7 +254,7 @@ class Api(ApiTemplate):
                          maxy = extent[3],
                          maxy = extent[3],
                          minx = extent[0],
                          minx = extent[0],
                          miny = extent[1],
                          miny = extent[1],
-                         url="http://{}/API/Image/WMS?guid={}".format(configure.deploy_ip_host,image_service.guid))
+                         url="http://{}/API/Service/Image/WMS?guid={}".format(configure.deploy_ip_host,image_service.guid))
 
 
 
 
         r = Response(response=xml, status=200, mimetype="application/xml")
         r = Response(response=xml, status=200, mimetype="application/xml")

+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/24
+#email:         nheweijun@sina.com
+
+import traceback
+
+import numpy
+from flask import Response
+import random
+
+from app.modules.service.image.models import ImageService,Image
+from app.util.component.ApiTemplate import ApiTemplate
+
+from app.util.component.ParameterUtil import ParameterUtil
+import json
+
+from .util.MyThread import MyThread
+from .util.ImageData import ImageData
+from .util.Opencv import Opencv
+from .util.Cache import Cache
+
+
+class Api(ApiTemplate):
+
+    api_name = "发布服务时预览"
+
+    def process(self):
+
+
+        result = {}
+        parameter: dict = self.para
+
+        try:
+
+            parameter = ParameterUtil.to_lower(parameter)
+
+            image_guids = parameter.get("image_guids")
+
+            bbox = parameter.get("bbox")
+            width = int(parameter.get("width")) if parameter.get("width") else 256
+            height = int(parameter.get("height")) if parameter.get("height") else 256
+            image_type = parameter.get("format") if parameter.get("format") else "image/png"
+            quality = int(parameter.get("quality")) if parameter.get("quality") else 30
+
+            image_service_info ,zoo, servers = Cache.cache_data(None)
+
+            extent = [float(x) for x in bbox.split(",")]
+
+            images = Image.query.filter(Image.guid.in_(image_guids.split(","))).all()
+
+            intersect_image = [im for im in images if self.determin_intersect(json.loads(im.extent),extent)]
+
+            if len(intersect_image)>1:
+
+                # 结果矩阵
+                empty_list = [numpy.zeros((height,width), dtype=int) + 65536,
+                              numpy.zeros((height,width), dtype=int) + 65536,
+                              numpy.zeros((height,width), dtype=int) + 65536]
+
+                pixel_array = numpy.zeros((height,width,3), dtype=int)
+                thread_list = []
+
+                for image in intersect_image:
+                    #该影像的服务器，随机选取一个
+                    image_servers = image.server.split(",")
+                    image_servers = [ser for ser in image_servers if ser in servers]
+                    if len(image_servers)>0:
+                        indx = int(random.random() * len(image_servers))
+                        image_server = image_servers[indx]
+                    else:
+                        image_server = "None"
+                    bands = json.loads(image.band_view)
+
+                    image_data = ImageData(image_server, image)
+
+                    thread: MyThread = MyThread(image_data.get_data, args=(extent,bands,height,width))
+                    thread.start()
+                    thread_list.append(thread)
+
+
+                for thread in thread_list:
+                    thread.join()
+                    data = thread.get_result()
+
+                    # 掩膜在中央接口生成,合图
+                    mask = numpy.zeros((height,width), dtype=int)
+                    mask2 = numpy.zeros((height,width), dtype=int)
+                    jizhun = data[:, :, 0]
+                    mask[jizhun == 65536] = 1
+                    mask[jizhun != 65536] = 0
+                    mask2[jizhun == 65536] = 0
+                    mask2[jizhun != 65536] = 1
+                    # 掩膜计算
+                    for i, d in enumerate(empty_list):
+                        empty_list[i] = empty_list[i] * mask + data[:, :, i] * mask2
+
+                for ii in [0, 1, 2]:
+                    # opencv 颜色排序为GBR
+                    pixel_array[:, :, 2 - ii] = empty_list[ii]
+
+
+            elif len(intersect_image)==1:
+                # 该影像的服务器，随机选取一个
+                image = intersect_image[0]
+                image_servers = image.server.split(",")
+                image_servers = [ser for ser in image_servers if ser in servers]
+                if len(image_servers) > 0:
+                    indx = int(random.random() * len(image_servers))
+                    image_server = image_servers[indx]
+                else:
+                    image_server = "None"
+
+                bands = json.loads(image.band_view)
+
+                image_data = ImageData(image_server, image)
+
+                pixel_array_t = image_data.get_data(extent,bands,height,width)
+                pixel_array = numpy.zeros((height, width, 3), dtype=int)
+                for ii in [0, 1, 2]:
+                    # opencv 颜色排序为GBR
+                    pixel_array[:, :, 2 - ii] = pixel_array_t[:, :, ii]
+            else:
+                # 结果矩阵
+                pixel_array = numpy.zeros((height, width, 3), dtype=int)+65536
+
+            # 将图片生成在内存中,然后直接返回response
+            im_data = Opencv.create_image(image_type, pixel_array, quality)
+
+            if self.para.get("overview"):
+                return pixel_array
+            return Response(im_data, mimetype=image_type.lower())
+
+        except Exception as e:
+            print(traceback.format_exc())
+            result["state"] = -1
+            result["message"] = e.__str__()
+            return result
+
+    def determin_intersect(self, extent1, extent2):
+        if extent2[2] < extent1[0] or extent2[0] > extent1[2] or extent2[1] > extent1[
+            3] or extent2[3] < extent1[1]:
+            return False
+        else:
+            return True
+
+    api_doc = {
+        "tags": ["影像接口"],
+        "parameters": [
+            {"name": "guid",
+             "in": "query",
+             "type": "string"},
+            {"name": "bbox",
+             "in": "query",
+             "type": "string"},
+            {"name": "width",
+             "in": "query",
+             "type": "string"},
+            {"name": "height",
+             "in": "query",
+             "type": "string"},
+            {"name": "format",
+             "in": "query",
+             "type": "string"},
+            {"name": "quality",
+             "in": "query",
+             "type": "string"}
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
+    }
+
+
+
+
+

@@ -17,30 +17,34 @@ class Image(db.Model):
     guid = Column(String(256), primary_key=True)
     guid = Column(String(256), primary_key=True)
     name = Column(String)
     name = Column(String)
     alias = Column(String)
     alias = Column(String)
-    raster_y_size = Column(Integer)
-    raster_x_size = Column(Integer)
-    overview_count = Column(Integer)
-    extent = Column(String)
+    raster_y_size = Column(Integer)#图像y 分辨率
+    raster_x_size = Column(Integer)#图像x 分辨率
+    overview_count = Column(Integer)#金字塔等级
+    extent = Column(String)#范围
     # geo_origin_extent = Column(String)
     # geo_origin_extent = Column(String)
-    null_value = Column(Integer)
+    null_value = Column(Integer)#空值
     available = Column(Integer)#影像是否可用，不可用可能在创建金字塔中
     available = Column(Integer)#影像是否可用，不可用可能在创建金字塔中
-    band_count = Column(Integer)
-    band_view = Column(String)
+    band_count = Column(Integer)#波段数
+    band_view = Column(String)#波段设置
     path = Column(String)
     path = Column(String)
     server = Column(String)
     server = Column(String)
 
 
     size = Column(Float)
     size = Column(Float)
     #坐标wkt
     #坐标wkt
-    sr_wkt = Column(Text)
-    sr_proj4 = Column(Text)
-    epsg = Column(Integer)
+    sr_wkt = Column(Text) #坐标wkt
+    sr_proj4 = Column(Text)#坐标proj
+    epsg = Column(Integer)#坐标epsg
     create_time = Column(DateTime)
     create_time = Column(DateTime)
     update_time = Column(DateTime)
     update_time = Column(DateTime)
-    cell_x_size = Column(Float)
-    cell_y_size = Column(Float)
+    cell_x_size = Column(Float)#像元x大小
+    cell_y_size = Column(Float)#像元y大小
     region = Column(Text)
     region = Column(Text)
-    #年份
-    ym = Column(String(256))
+
+    ym = Column(String(256))#时间年份
+
+    satellite = Column(String)#卫星类型
+    type = Column(String(128))
+
 
 
 dmap_image_rel = db.Table('dmap_image_rel',
 dmap_image_rel = db.Table('dmap_image_rel',
     Column('image_guid',String, ForeignKey('dmap_image.guid')),
     Column('image_guid',String, ForeignKey('dmap_image.guid')),

-# coding=utf-8
-#author:        4N
-#createtime:    2021/9/26
-#email:         nheweijun@sina.com
-
-from app.modules.service.image.tutorial2.ttypes import RasterData
-
-from thrift.transport import TSocket
-from thrift.transport import TTransport
-from thrift.protocol import TBinaryProtocol
-from app.modules.service.image.ImageDataService import ImageDataService
-from app.modules.service.image.tutorial2 import Calculator
-
-from struct import Struct
-
-host = "192.168.184.246"
-port = 9090
-transport: TSocket = TSocket.TSocket(host, port)
-transport = TTransport.TBufferedTransport(transport)
-protocol = TBinaryProtocol.TBinaryProtocol(transport)
-
-client = Calculator.Client(protocol)
-
-
-transport.open()
-
-test = client.getData("江南_01.tif",[1340.27, -1911.31, 4351.79, 5410.6],[1340.27, -1911.31, 4351.79, 5410.6],[3,2,1],768,768)
-print(type(test))
-
-
-

+# coding=utf-8
+#author:        4N
+#createtime:    2021/10/18
+#email:         nheweijun@sina.com
+
+
+from kazoo.client import KazooClient
+import configure
+import time
+from app.modules.service.image.models import ImageService,Image
+from app.models import TileScheme
+import json
+class Cache:
+
+    @classmethod
+    def cache_data(cls,guid):
+
+        from app import GLOBAL_DIC
+
+        # 缓存zookeeper
+        zoo = GLOBAL_DIC.get("zookeeper")
+        if zoo is None:
+            zoo: KazooClient = KazooClient(hosts=configure.zookeeper, timeout=100)
+            zoo.start()
+            GLOBAL_DIC["zookeeper"] = zoo
+        else:
+            if not zoo.connected:
+                zoo.start()
+
+        # 缓存数据服务器
+        servers = GLOBAL_DIC.get("servers")
+        if servers is None:
+            servers = zoo.get_children("/rpc")
+            servers.append("本地服务器")
+            GLOBAL_DIC["servers"] = servers
+            GLOBAL_DIC["servers_updatetime"] = time.time()
+        else:
+            servers = GLOBAL_DIC.get("servers")
+
+        # 更新缓存
+        if time.time() - GLOBAL_DIC["servers_updatetime"] > 10:
+            servers = zoo.get_children("/rpc")
+            servers.append("本地服务器")
+            GLOBAL_DIC["servers"] = servers
+            GLOBAL_DIC["servers_updatetime"] = time.time()
+
+
+        # 缓存服务信息
+        if guid:
+            image_service_info = GLOBAL_DIC.get(guid)
+            if image_service_info is None or time.time() - GLOBAL_DIC.get("service_updatetime") > 20:
+                image_service: ImageService = ImageService.query.filter_by(guid=guid).one_or_none()
+                images = image_service.images.all()
+
+                if image_service.scheme_guid:
+                    scheme: TileScheme = TileScheme.query.filter_by(guid=image_service.scheme_guid).one_or_none()
+                    GLOBAL_DIC[guid] = {"service": image_service, "images": images,
+                                             "scheme": json.loads(scheme.parameter)}
+                else:
+
+                    GLOBAL_DIC[guid] = {"service": image_service, "images": images}
+                GLOBAL_DIC["service_updatetime"] = time.time()
+                image_service_info = GLOBAL_DIC[guid]
+
+            else:
+                image_service_info = GLOBAL_DIC[guid]
+        else:
+            image_service_info = None
+
+        return image_service_info,zoo,servers

+# coding=utf-8
+#author:        4N
+#createtime:    2021/10/15
+#email:         nheweijun@sina.com
+
+from app.util import *
+from osgeo import gdal
+from osgeo.gdal import *
+from numpy import ndarray
+import numpy
+from app.modules.service.image.util.ThriftConnect import ThriftConnect,ThriftPool
+import json
+import gzip
+
+class ImageData:
+
+
+    def __init__(self,image_server,image):
+        self.image_server = image_server
+        self.image = image
+
+
+    def get_data(self, extent, bands, height, width):
+        if self.image_server.__eq__("本地服务器"):
+            data = self.get_local_wms_data(extent, bands, height, width)
+        elif self.image_server.__eq__("None"):
+            data = numpy.zeros((height, width, 3), dtype=int) + 65536
+        else:
+            data = self.get_remote_wms_data(extent, bands, height, width)
+        return data
+
+
+    def get_remote_wms_data(self, extent, bands, height, width):
+        '''
+        通过RPC获取远程数据
+        :param image:
+        :param extent:
+        :param bands:
+        :return:
+        '''
+
+        # 需要做thrift连接的缓存，连接池
+        thrift_connect = ThriftConnect(self.image_server)
+        image_extent = self.image.extent
+
+        data = thrift_connect.client.getData(self.image.path, extent, json.loads(image_extent), bands, width, height)
+
+        thrift_connect.close()
+
+        data = gzip.decompress(data)
+        data = numpy.frombuffer(data, dtype='int64')
+        data = data.reshape((height, width, 3))
+
+        return data
+
+
+    def get_remote_wms_data_cpp(self, image_server, image, extent, bands, height, width):
+        '''
+        通过RPC获取远程数据
+        :param image:
+        :param extent:
+        :param bands:
+        :return:
+        '''
+
+        # 需要做thrift连接的缓存，连接池
+        thrift_connect = ThriftConnect(image_server)
+        image_extent = image.extent
+
+        data = thrift_connect.client.getData(image.path, extent, json.loads(image_extent), bands, width, height)
+
+        thrift_connect.close()
+
+        return data
+
+
+    def get_local_wms_data(self, extent, bands, height, width):
+        '''
+        获取本地数据
+        :param image:
+        :param extent:
+        :param bands:
+        :return:
+        '''
+
+        img: Dataset = gdal.Open(self.image.path, 0)
+
+        origin_extent = json.loads(self.image.extent)
+
+        # 超出空间范围
+        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((height, width, 3), dtype=int) + 65536
+        # 空间范围相交
+        else:
+
+            ox = img.RasterXSize
+            oy = img.RasterYSize
+
+            # 网格大小
+            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 = img.ReadRaster(off_x, off_y, x_g, y_g, 256, 256, band_list = bands)
+                img.ReadAsArray()
+            # 部分相交
+            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]) / (width * 1.0)
+                out_grid_y = (extent[3] - extent[1]) / (height * 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 = img.ReadAsArray(off_x, off_y, x_g, y_g, out_x_g,
+                                                           out_y_g)
+
+                dat = numpy.zeros((height, width, 3), 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 empty
+

+# coding=utf-8
+#author:        4N
+#createtime:    2021/10/18
+#email:         nheweijun@sina.com
+import os
+
+class ImageType:
+
+    @classmethod
+    def get_type(cls,path):
+
+        if os.path.isdir(path):
+            type = "dir"
+        elif path.lower().endswith(".tiff") or path.lower().endswith(".tif"):
+            type = "tif"
+        elif path.lower().endswith(".img"):
+            type = "img"
+        else:
+            type = None
+        return type
+
+
+if __name__ == '__main__':
+    print(ImageType.get_type("/da/d/ftif"))

+# coding=utf-8
+#author:        4N
+#createtime:    2021/10/18
+#email:         nheweijun@sina.com
+
+from threading import Thread
+class MyThread(Thread):
+    def __init__(self,func,args=()):
+        super(MyThread,self).__init__()
+        self.func = func
+        self.args = args
+    def run(self):
+        self.result = self.func(*self.args)
+    def get_result(self):
+        try:
+            return self.result
+        except Exception:
+            return None

+# coding=utf-8
+#author:        4N
+#createtime:    2021/10/18
+#email:         nheweijun@sina.com
+import cv2
+import numpy
+
+class Opencv:
+
+    @classmethod
+    def create_image(cls,image_type, pixel_array, quality):
+
+        if image_type.__eq__("image/jpeg") or image_type.__eq__("image/jpg"):
+            r, buf = cv2.imencode(".jpg", pixel_array, [cv2.IMWRITE_JPEG_QUALITY, quality])
+            image_out = buf.tobytes()
+        else:
+            height, width = pixel_array[:, :, 0].shape
+            four = numpy.zeros((height,width), dtype=int) + 255
+            four[pixel_array[:, :, 0] == 65536] = 0
+            r, buf = cv2.imencode(".png", numpy.dstack((pixel_array, four)))
+            image_out = buf.tobytes()
+        return image_out

@@ -13,6 +13,7 @@ from . import scheme_delete
 from . import scheme_edit
 from . import scheme_edit
 from . import scheme_list
 from . import scheme_list
 from . import scheme_resolve
 from . import scheme_resolve
+from . import scheme_info
 
 
 class SchemeManager(BlueprintApi):
 class SchemeManager(BlueprintApi):
 
 
@@ -57,6 +58,15 @@ class SchemeManager(BlueprintApi):
         """
         """
         return scheme_list.Api().result
         return scheme_list.Api().result
 
 
+    @staticmethod
+    @bp.route('/Info', methods=['POST'])
+    @swag_from(scheme_info.Api.api_doc)
+    def api_scheme_info():
+        """
+         切片方案Info
+        """
+        return scheme_info.Api().result
+
 
 
     @staticmethod
     @staticmethod
     @bp.route('/Resolve', methods=['POST'])
     @bp.route('/Resolve', methods=['POST'])

+<?xml version="1.0" encoding="utf-8" ?>
+<TileCacheInfo xmlns:typens="http://www.esri.com/schemas/ArcGIS/10.1" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="typens:TileCacheInfo">
+	<SpatialReference xsi:type="typens:GeographicCoordinateSystem">
+		<WKT>GEOGCS[&quot;GCS_China_Geodetic_Coordinate_System_2000&quot;,DATUM[&quot;D_China_2000&quot;,SPHEROID[&quot;CGCS2000&quot;,6378137.0,298.257222101]],PRIMEM[&quot;Greenwich&quot;,0.0],UNIT[&quot;Degree&quot;,0.0174532925199433],AUTHORITY[&quot;EPSG&quot;,4490]]</WKT>
+		<XOrigin>-400</XOrigin>
+		<YOrigin>-400</YOrigin>
+		<XYScale>11258999068426.24</XYScale>
+		<ZOrigin>0</ZOrigin>
+		<ZScale>1</ZScale>
+		<MOrigin>-100000</MOrigin>
+		<MScale>10000</MScale>
+		<XYTolerance>8.98315284119521e-009</XYTolerance>
+		<ZTolerance>2</ZTolerance>
+		<MTolerance>0.001</MTolerance>
+		<HighPrecision>true</HighPrecision>
+		<LeftLongitude>-180</LeftLongitude>
+		<WKID>4490</WKID>
+		<LatestWKID>4490</LatestWKID>
+	</SpatialReference>
+	<TileOrigin xsi:type="typens:PointN">
+		<X>-180</X>
+		<Y>90</Y>
+	</TileOrigin>
+	<TileCols>256</TileCols>
+	<TileRows>256</TileRows>
+	<DPI>96</DPI>
+	<PreciseDPI>96</PreciseDPI>
+	<LODInfos xsi:type="typens:ArrayOfLODInfo">
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>0</LevelID>
+			<Scale>295497593.05875003</Scale>
+			<Resolution>0.70312500000000022</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>1</LevelID>
+			<Scale>147748796.52937502</Scale>
+			<Resolution>0.35156250000000011</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>2</LevelID>
+			<Scale>73874398.264687508</Scale>
+			<Resolution>0.17578125000000006</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>3</LevelID>
+			<Scale>36937199.132343754</Scale>
+			<Resolution>0.087890625000000028</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>4</LevelID>
+			<Scale>18468599.566171877</Scale>
+			<Resolution>0.043945312500000014</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>5</LevelID>
+			<Scale>9234299.7830859385</Scale>
+			<Resolution>0.021972656250000007</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>6</LevelID>
+			<Scale>4617149.8915429693</Scale>
+			<Resolution>0.010986328125000003</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>7</LevelID>
+			<Scale>2308574.9457714846</Scale>
+			<Resolution>0.0054931640625000017</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>8</LevelID>
+			<Scale>1154287.4728857423</Scale>
+			<Resolution>0.0027465820312500009</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>9</LevelID>
+			<Scale>577143.73644287116</Scale>
+			<Resolution>0.0013732910156250004</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>10</LevelID>
+			<Scale>288571.86822143558</Scale>
+			<Resolution>0.00068664550781250022</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>11</LevelID>
+			<Scale>144285.93411071779</Scale>
+			<Resolution>0.00034332275390625011</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>12</LevelID>
+			<Scale>72142.967055358895</Scale>
+			<Resolution>0.00017166137695312505</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>13</LevelID>
+			<Scale>36071.483527679447</Scale>
+			<Resolution>8.5830688476562527e-005</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>14</LevelID>
+			<Scale>18035.741763839724</Scale>
+			<Resolution>4.2915344238281264e-005</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>15</LevelID>
+			<Scale>9017.8708819198619</Scale>
+			<Resolution>2.1457672119140632e-005</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>16</LevelID>
+			<Scale>4508.9354409599309</Scale>
+			<Resolution>1.0728836059570316e-005</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>17</LevelID>
+			<Scale>2254.4677204799655</Scale>
+			<Resolution>5.3644180297851579e-006</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>18</LevelID>
+			<Scale>1127.2338602399827</Scale>
+			<Resolution>2.682209014892579e-006</Resolution>
+		</LODInfo>
+		<LODInfo xsi:type="typens:LODInfo">
+			<LevelID>19</LevelID>
+			<Scale>563.61693011999137</Scale>
+			<Resolution>1.3411045074462895e-006</Resolution>
+		</LODInfo>
+	</LODInfos>
+</TileCacheInfo>

@@ -24,15 +24,15 @@ class Api(ApiTemplate):
             # extent = [float(x) for x in  data.get("extent").split(",")] if data.get("extent") else [0,0,0,0]
             # extent = [float(x) for x in  data.get("extent").split(",")] if data.get("extent") else [0,0,0,0]
             # top_left = [float(x) for x in data.get("top_left").split(",")] if data.get("top_left") else [0, 0]
             # top_left = [float(x) for x in data.get("top_left").split(",")] if data.get("top_left") else [0, 0]
 
 
-            paramenter = {}
+            parameter = {}
             for l_dict in json.loads(data.get("levels")):
             for l_dict in json.loads(data.get("levels")):
-                paramenter[str(l_dict["level"])] = {"resolution":l_dict["resolution"],"scale":l_dict["scale"]}
-            paramenter["cols"] = int(data.get("cols"))
-            paramenter["rows"] = int(data.get("rows"))
-            paramenter["dpi"] = int(data.get("dpi"))
-            paramenter["wkt"] = data.get("crs_wkt")
-            paramenter["x"] = eval(data.get("top_left").split(",")[0])
-            paramenter["y"] = eval(data.get("top_left").split(",")[1])
+                parameter[str(l_dict["level"])] = {"resolution":l_dict["resolution"],"scale":l_dict["scale"]}
+            parameter["cols"] = int(data.get("cols"))
+            parameter["rows"] = int(data.get("rows"))
+            parameter["dpi"] = int(data.get("dpi"))
+            parameter["wkt"] = data.get("crs_wkt")
+            parameter["x"] = eval(data.get("top_left").split(",")[0])
+            parameter["y"] = eval(data.get("top_left").split(",")[1])
 
 
 
 
             guid = uuid.uuid1().__str__()
             guid = uuid.uuid1().__str__()
@@ -55,7 +55,7 @@ class Api(ApiTemplate):
                 rows = int(data.get("rows")),
                 rows = int(data.get("rows")),
                 cols = int(data.get("cols")),
                 cols = int(data.get("cols")),
                 update_time = datetime.datetime.now(),
                 update_time = datetime.datetime.now(),
-                parameter=json.dumps(paramenter)
+                parameter=json.dumps(parameter)
             )
             )
 
 
             db.session.add(tile_scheme)
             db.session.add(tile_scheme)
@@ -77,6 +77,9 @@ class Api(ApiTemplate):
             {"name": "alias",
             {"name": "alias",
              "in": "formData",
              "in": "formData",
              "type": "string"},
              "type": "string"},
+            {"name": "description",
+             "in": "formData",
+             "type": "string"},
             {"name": "crs",
             {"name": "crs",
              "in": "formData",
              "in": "formData",
              "type": "string"},
              "type": "string"},

@@ -8,7 +8,7 @@ import uuid
 from app.models import TileScheme,db
 from app.models import TileScheme,db
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ApiTemplate import ApiTemplate
 import datetime
 import datetime
-
+import json
 class Api(ApiTemplate):
 class Api(ApiTemplate):
     api_name = "修改方案"
     api_name = "修改方案"
 
 
@@ -30,9 +30,24 @@ class Api(ApiTemplate):
             update_dict = data
             update_dict = data
             update_dict["update_time"] = datetime.datetime.now()
             update_dict["update_time"] = datetime.datetime.now()
             del update_dict["guid"]
             del update_dict["guid"]
+            if update_dict:
+
+                TileScheme.query.filter_by(guid=guid).update(update_dict)
+                db.session.commit()
 
 
-            tile_scheme.update(update_dict)
-            db.session.commit()
+                #更新parameter
+                tile_scheme: TileScheme = TileScheme.query.filter_by(guid=guid).one_or_none()
+                parameter = {}
+                for l_dict in json.loads(tile_scheme.levels):
+                    parameter[str(l_dict["level"])] = {"resolution": l_dict["resolution"], "scale": l_dict["scale"]}
+                parameter["cols"] = tile_scheme.cols
+                parameter["rows"] = tile_scheme.rows
+                parameter["dpi"] = tile_scheme.dpi
+                parameter["wkt"] = tile_scheme.crs_wkt
+                parameter["x"] = eval(tile_scheme.top_left.split(",")[0])
+                parameter["y"] = eval(tile_scheme.top_left.split(",")[1])
+                TileScheme.query.filter_by(guid=guid).update({"parameter":json.dumps(parameter)})
+                db.session.commit()
 
 
             res["data"] = guid
             res["data"] = guid
             res["result"] = True
             res["result"] = True
@@ -54,6 +69,9 @@ class Api(ApiTemplate):
             {"name": "alias",
             {"name": "alias",
              "in": "formData",
              "in": "formData",
              "type": "string"},
              "type": "string"},
+            {"name": "description",
+             "in": "formData",
+             "type": "string"},
             {"name": "crs",
             {"name": "crs",
              "in": "formData",
              "in": "formData",
              "type": "string"},
              "type": "string"},

+# coding=utf-8
+#author:        4N
+#createtime:    2021/9/16
+#email:         nheweijun@sina.com
+
+
+import uuid
+from app.models import TileScheme,db
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ModelVisitor import ModelVisitor
+from sqlalchemy import or_
+import datetime
+
+class Api(ApiTemplate):
+    api_name = "切片方案Info"
+
+    def process(self):
+
+        # 返回结果
+        res = {}
+
+        try:
+            # 业务逻辑
+
+            guid = self.para.get("guid")
+            scheme = TileScheme.query.filter_by(guid=guid).one_or_none()
+            if not scheme:
+                raise Exception("数据不存在！")
+            res["data"] = ModelVisitor.object_to_json(scheme)
+            res["result"] = True
+
+        except Exception as e:
+            raise e
+
+        return res
+
+    api_doc = {
+
+        "tags": ["方案接口"],
+        "parameters": [
+            {"name": "guid",
+             "in": "formData",
+             "type": "string"},
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
+    }

@@ -27,7 +27,7 @@ class Api(ApiTemplate):
 
 
             alias = self.para.get("alias")
             alias = self.para.get("alias")
             name = self.para.get("name")
             name = self.para.get("name")
-            schemes = TileScheme.query
+            schemes = TileScheme.query.order_by(TileScheme.update_time.desc())
 
 
             # 并集
             # 并集
             if alias and name:
             if alias and name:
@@ -38,9 +38,10 @@ class Api(ApiTemplate):
                 if name:
                 if name:
                     schemes = schemes.filter(TileScheme.name.like("%" + name + "%"))
                     schemes = schemes.filter(TileScheme.name.like("%" + name + "%"))
 
 
-            schemes = schemes.limit(page_size).offset(page_index).all()
-
-            res["data"] = ModelVisitor.objects_to_jsonarray(schemes)
+            res["data"] = {}
+            res["data"]["count"] = schemes.count()
+            schemes = schemes.limit(page_size).offset(page_index * page_size).all()
+            res["data"]["list"] = ModelVisitor.objects_to_jsonarray(schemes)
             res["result"] = True
             res["result"] = True
 
 
         except Exception as e:
         except Exception as e:

@@ -7,22 +7,26 @@
 
 
 
 
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.ApiTemplate import ApiTemplate
+from app.models import Service
 
 
 class Api(ApiTemplate):
 class Api(ApiTemplate):
     api_name = "修改服务"
     api_name = "修改服务"
     def process(self):
     def process(self):
         res = {}
         res = {}
         try:
         try:
+            service = Service.query.filter_by(guid=self.para.get("guid")).one_or_none()
+            if not service:
+                raise Exception("服务不存在！")
 
 
-            if self.para.get("type")in ["ImageWMTS","ImageWMS"]:
-                from app.modules.service.image.image_service_edit import Api as Api2
-            elif self.para.get("type").__eq__("WMS/WFS"):
-                from app.modules.service.wms.wms_edit import Api as Api2
-            elif self.para.get("type") in ["WMTS","MTS"]:
-                from app.modules.service.wmts.wmts_edit import Api as Api2
+            if service.type in ["ImageWMTS","ImageWMS"]:
+                from app.modules.service.image.image_service_edit import Api as RealApi
+            elif service.type in ["WMS/WFS"]:
+                from app.modules.service.wms.wms_edit import Api as RealApi
+            elif service.type in ["WMTS","TMS"]:
+                from app.modules.service.wmts.wmts_edit import Api as RealApi
             else:
             else:
                 return res
                 return res
-            api = Api2()
+            api = RealApi()
             api.para = self.para
             api.para = self.para
             res = api.process()
             res = api.process()
 
 
@@ -35,13 +39,23 @@ class Api(ApiTemplate):
         "tags": ["服务接口"],
         "tags": ["服务接口"],
         "parameters": [
         "parameters": [
 
 
+            {"name": "guid",
+             "in": "formData",
+             "type": "string",
+             "description": "[WMS,WMTS,影像WMS,影像WMTS,guid]"},
+
+            # {"name": "type",
+            #  "in": "formData",
+            #  "type": "string",
+            #  "enum": ["WMS/WFS", "WMTS", "TMS", "ImageWMS", "ImageWMTS"],
+            #  "required": "true",
+            #  "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
 
 
             {"name": "name",
             {"name": "name",
              "in": "formData",
              "in": "formData",
              "type": "string",
              "type": "string",
-             "required": "true",
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
-            {"name": "alias",
+            {"name": "title",
              "in": "formData",
              "in": "formData",
              "type": "string",
              "type": "string",
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
@@ -56,7 +70,7 @@ class Api(ApiTemplate):
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
 
 
             # 影像参数
             # 影像参数
-            {"name": "guids",
+            {"name": "image_guids",
              "in": "formData",
              "in": "formData",
              "type": "string",
              "type": "string",
              "description": "[影像WMS,影像WMTS]影像guids，以英文逗号相隔"},
              "description": "[影像WMS,影像WMTS]影像guids，以英文逗号相隔"},

@@ -15,19 +15,34 @@ class Api(ApiTemplate):
         try:
         try:
             guid = self.para.get("guid")
             guid = self.para.get("guid")
             service = Service.query.filter_by(guid=guid).one_or_none()
             service = Service.query.filter_by(guid=guid).one_or_none()
+            if not service:
+                raise Exception("服务不存在！")
+            res["data"] = {}
 
 
             if service.type in ["ImageWMS","ImageWMTS"]:
             if service.type in ["ImageWMS","ImageWMTS"]:
                 from app.modules.service.image.models import ImageService
                 from app.modules.service.image.models import ImageService
-                speci_service = ImageService.query.filter_by(guid=guid).one_or_none()
-            elif service.type.__eq__("WMTS") or service.type.__eq__("MTS"):
+                speci_service = ImageService.query.filter_by(guid=service.service_guid).one_or_none()
+                relate_images = speci_service.images.all()
+                res["data"]["speci_service"] = ModelVisitor.object_to_json(speci_service)
+
+                res["data"]["speci_service"]["images"] = [{"name":im["name"],"guid":im["guid"]} for im in ModelVisitor.objects_to_jsonarray(relate_images)]
+                res["data"]["speci_service"]["images"] = sorted(res["data"]["speci_service"]["images"], key=lambda x: x["name"])
+
+            elif service.type.__eq__("WMTS") or service.type.__eq__("TMS"):
                 from app.modules.service.wmts.models import WMTS
                 from app.modules.service.wmts.models import WMTS
-                speci_service = WMTS.query.filter_by(guid=guid).one_or_none()
+                speci_service = WMTS.query.filter_by(guid=service.service_guid).one_or_none()
+
+                res["data"]["speci_service"] = ModelVisitor.object_to_json(speci_service)
+
             elif service.type.__eq__("WMS/WFS"):
             elif service.type.__eq__("WMS/WFS"):
                 from app.modules.service.wms.models import WMS
                 from app.modules.service.wms.models import WMS
-                speci_service = WMS.query.filter_by(guid=guid).one_or_none()
+                speci_service = WMS.query.filter_by(guid=service.service_guid).one_or_none()
+                res["data"]["speci_service"] = ModelVisitor.object_to_json(speci_service)
             else:
             else:
-                speci_service = {}
-            res["data"] = ModelVisitor.object_to_json(speci_service)
+                res["data"] = {}
+
+            res["data"]["service"] = ModelVisitor.object_to_json(service)
+
         except Exception as e:
         except Exception as e:
             raise e
             raise e
         return res
         return res

@@ -22,31 +22,31 @@ class Api(ApiTemplate):
             page_index = int(self.para.get("page_index", "0"))
             page_index = int(self.para.get("page_index", "0"))
             page_size = int(self.para.get("page_size", "10"))
             page_size = int(self.para.get("page_size", "10"))
 
 
-            alias = self.para.get("alias")
+            title = self.para.get("title")
             name = self.para.get("name")
             name = self.para.get("name")
             type = self.para.get("type")
             type = self.para.get("type")
 
 
             catalog_guid = self.para.get("catalog_guid")
             catalog_guid = self.para.get("catalog_guid")
 
 
-            services = Service.query
+            services = Service.query.order_by(Service.update_time.desc())
             if type:
             if type:
                 services = services.filter_by(type=type)
                 services = services.filter_by(type=type)
 
 
             if catalog_guid:
             if catalog_guid:
                 services = services.filter_by(catalog_guid=catalog_guid)
                 services = services.filter_by(catalog_guid=catalog_guid)
             # 并集
             # 并集
-            if alias and name:
+            if title and name:
                 services = services.filter(
                 services = services.filter(
-                    or_(Service.alias.like("%" + alias + "%"), Service.name.like("%" + name + "%")))
+                    or_(Service.title.like("%" + title + "%"), Service.name.like("%" + name + "%")))
             else:
             else:
-                if alias:
-                    services = services.filter(Service.alias.like("%" + alias + "%"))
+                if title:
+                    services = services.filter(Service.title.like("%" + title + "%"))
                 if name:
                 if name:
                     services = services.filter(Service.name.like("%" + name + "%"))
                     services = services.filter(Service.name.like("%" + name + "%"))
-
-            services = services.limit(page_size).offset(page_index).all()
-
-            res["data"] = ModelVisitor.objects_to_jsonarray(services)
+            res["data"] = {}
+            res["data"]["count"] = services.count()
+            services = services.limit(page_size).offset(page_index * page_size).all()
+            res["data"]["list"] = ModelVisitor.objects_to_jsonarray(services)
             res["result"] = True
             res["result"] = True
 
 
 
 
@@ -66,10 +66,10 @@ class Api(ApiTemplate):
              "in": "formData",
              "in": "formData",
              "type": "int",
              "type": "int",
              "description": "页大小"},
              "description": "页大小"},
-            {"name": "alias",
+            {"name": "title",
              "in": "formData",
              "in": "formData",
              "type": "string",
              "type": "string",
-             "description": "服务别名"},
+             "description": "服务标题"},
             {"name": "name",
             {"name": "name",
              "in": "formData",
              "in": "formData",
              "type": "string",
              "type": "string",

@@ -14,18 +14,15 @@ class Api(ApiTemplate):
             service = Service.query.filter_by(name=self.para.get("name")).one_or_none()
             service = Service.query.filter_by(name=self.para.get("name")).one_or_none()
             if service:
             if service:
                 raise Exception("服务已存在！")
                 raise Exception("服务已存在！")
-
-            if self.para.get("type").__eq__("ImageWMS"):
-                from app.modules.service.image.image_service_register import Api as Api2
-            elif self.para.get("type").__eq__("ImageWMTS"):
-                from app.modules.service.image.image_service_register import Api as Api2
+            if self.para.get("type").__eq__("ImageWMS") or self.para.get("type").__eq__("ImageWMTS"):
+                from app.modules.service.image.image_service_register import Api as RealApi
             elif self.para.get("type").__eq__("WMS"):
             elif self.para.get("type").__eq__("WMS"):
-                from app.modules.service.wms.wms_register import Api as Api2
-            elif self.para.get("type").__eq__("WMTS") or self.para.get("type").__eq__("MTS"):
-                from app.modules.service.wmts.wmts_register import Api as Api2
+                from app.modules.service.wms.wms_register import Api as RealApi
+            elif self.para.get("type").__eq__("WMTS") or self.para.get("type").__eq__("TMS"):
+                from app.modules.service.wmts.wmts_register import Api as RealApi
             else:
             else:
                 return res
                 return res
-            api = Api2()
+            api = RealApi()
             api.para = self.para
             api.para = self.para
             res = api.process()
             res = api.process()
         except Exception as e:
         except Exception as e:
@@ -43,7 +40,7 @@ class Api(ApiTemplate):
              "type": "string",
              "type": "string",
              "required": "true",
              "required": "true",
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
-            {"name": "alias",
+            {"name": "title",
              "in": "formData",
              "in": "formData",
              "type": "string",
              "type": "string",
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
@@ -54,7 +51,7 @@ class Api(ApiTemplate):
             {"name": "type",
             {"name": "type",
              "in": "formData",
              "in": "formData",
              "type": "string",
              "type": "string",
-             "enum":["WMS/WFS","WMTS","MTS","ImageWMS","ImageWMTS"],
+             "enum":["WMS/WFS","WMTS","TMS","ImageWMS","ImageWMTS"],
              "required": "true",
              "required": "true",
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
              "description": "[WMS,WMTS,影像WMS,影像WMTS]"},
             {"name": "catalog_guid",
             {"name": "catalog_guid",

@@ -17,12 +17,8 @@ class Api(ApiTemplate):
             state = int(self.para.get("state"))
             state = int(self.para.get("state"))
             Service.query.filter_by(guid=guid).update({"state":state})
             Service.query.filter_by(guid=guid).update({"state":state})
 
 
-
-            #更新缓存
-
-
-
             db.session.commit()
             db.session.commit()
+            res["result"] = True
         except Exception as e:
         except Exception as e:
             raise e
             raise e
         return res
         return res
@@ -35,7 +31,7 @@ class Api(ApiTemplate):
              "in": "formData",
              "in": "formData",
              "type": "string",
              "type": "string",
              "description": "guid"},
              "description": "guid"},
-            {"name": "stat",
+            {"name": "state",
              "in": "formData",
              "in": "formData",
              "type": "int",
              "type": "int",
              "description": "state"},
              "description": "state"},