ljh

@@ -37,13 +37,9 @@ SET (DMAP_SERVER_SRCS
   dmpserverregistry.cpp
   python/dmppythonutils.cpp
   python/dmpserverwrapper.cpp
-<<<<<<< Updated upstream
-=======
-  #dmppgsqlutils.cpp
->>>>>>> Stashed changes
   dmphttpbase.cpp
   dmphttputils.cpp
-  dmptilethumbnail.cpp
+ 
 )
 
 SET (DMAP_SERVER_HDRS
@@ -75,7 +71,7 @@ SET (DMAP_SERVER_HDRS
   python/dmppythonutils.h
   dmphttpbase.h
   dmphttputils.h
-  dmptilethumbnail.h
+  
 )
 
 #############################################################

@@ -17,21 +17,10 @@
 #include <sstream>
 #include <fstream>
 #include <math.h>
-#include "dmptilethumbnail.h"
 #include "dmptilelayer.h"
-
-<<<<<<< Updated upstream
-
 #include <iostream>
 #include "dmplogger.h"
-
-#include <math.h>
-#include "dmptilethumbnail.h"
 #include "dmptilelayer.h"
-=======
->>>>>>> Stashed changes
-
-
 
 DmpServerManager::DmpServerManager()
 {
@@ -62,7 +51,6 @@ DmpServerManager::~DmpServerManager()
 void DmpServerManager::init(const boost::filesystem::path &modulePath)
 {
     serverRegistry_->init(modulePath);
-<<<<<<< Updated upstream
     if(!loadServices())
     {
         std::cout << "加载服务失败!" << std::endl;
@@ -138,14 +126,7 @@ bool DmpServerManager::publish(const std::string& serverName, const std::string&
         delete project;
         return false;
     }
-    projects_[serviceName] = project;
-    //增加缩略图处理
-    if(serverName=="tileserver")
-    {
-        DmpTileLayer *tileLayer = static_cast<DmpTileLayer *>(project->getLayer());
-        DmpTileThumbnail::ctreatWmtsThumbnail(tileLayer);
-    }
-    
+    projects_[serviceName] = project; 
     return true;
 }
 

@@ -41,9 +41,7 @@ public:
     bool loadServices();
     //初始化加载服务
     bool initServices(const std::string& serverName, const std::string& serviceName, const std::string& title, int capabilities, const std::string& projectData);
-    // bool ctreatTmsThumbnail() ;
-    // bool ctreatWmtsThumbnail() ;
-    // bool BufferCopy(cairo_surface_t *pClsCSFrom, cairo_surface_t *pClsCSTo,cairo_t *cr,int x,int y);
+    
 
 private:
     typedef std::map<std::string, DmpProject*, ci_less> ProjectMap;

@@ -34,7 +34,7 @@ class SERVER_EXPORT DmpService
     virtual std::string name() const = 0;
     virtual std::string version() const = 0;
     virtual std::string description() const = 0;
-    virtual bool validate() { return true; }
+    virtual bool validate(std::string &filePath) { return true; }
     virtual bool allowMethod(DmpServerRequest::Method) const { return true; }
     virtual void executeRequest(const DmpServerContext &context) = 0; 
 };

-/**************************************************************************
-* file:              dmptilethumbnail.cpp
-
-* Author:            lijiahuan
-* Date:              2021-12-23 15:33:50
-* Email:             jiahuanl@chinadci.com
-* copyright:         广州城市信息研究所有限公司
-***************************************************************************/
-#include "dmptilethumbnail.h"
-#include <iostream>
-#include <string>
-#include <map>
-#include <memory>
-#include <math.h>
-
-
-bool DmpTileThumbnail::ctreatWmtsThumbnail(DmpTileLayer *tileLayer)
-{
-   
-   std::string path = tileLayer->getDataSource();
-   path="/mnt/d/Code/tiles/qgis";
-   std::string vendor=tileLayer->getVendor();
-   std::string format=tileLayer->getFormat();
-
-   DmpRectangle rectangle=tileLayer->extent();
-   std::string lowerPoint=std::to_string(rectangle.xmin())+" "+std::to_string(rectangle.ymin());
-   std::string upperPoint=std::to_string(rectangle.xmax())+" "+std::to_string(rectangle.ymax());
-   Point minPoin{.x=107.78981494180618,.y=18.870480519260582};
-   Point maxPoin{.x=120.43553603935675,.y=25.999868757737033};
-
-   int tileMatrix=6;
-   Point origin{.x=-400,.y=400};
-   double resolution=0.02197265625009295*256;
-   int minCol=floor(abs(origin.x-minPoin.x)/resolution);
-   int minRow=floor(abs(origin.y-minPoin.y)/resolution);
-   int maxCol=floor(abs(origin.x-maxPoin.x)/resolution);
-   int maxRow=floor(abs(origin.y-maxPoin.y)/resolution);
-   int width=maxCol-minCol;
-   int heigth=minRow-maxRow;
-   cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 256*(width+1), 256*(heigth+1));
-   cairo_t *cr =cairo_create (surface);
-   
-   for( int i = 0 ; i <= width ; i++ )
-   {
-       for(int j=0;j<=heigth;j++)
-       {  
-           char* buff;
-           int length;
-           getTile(maxRow+j,minCol+i,tileMatrix,format,buff,length);        
-        //    std::string filepath=path+"/"+std::to_string(tileMatrix)+"/"+std::to_string(minCol+i)+"/"+std::to_string(maxRow+j)+".png";          
-        //    cairo_surface_t*  image = cairo_image_surface_create_from_png( filepath.c_str());
-
-           st_png_data* pPngData;
-           pPngData->pdata=(unsigned char*)buff;
-           pPngData->length=length;
-           cairo_surface_t*  image1 = cairo_image_surface_create_from_png_stream(cairo_read_func_mine,&pPngData);
-
-           BufferCopy(image1,surface,cr,0,0);
-           cairo_surface_write_to_png (surface, "./wmts1.png");
-           BufferCopy(image1,surface,cr,i*256,j*256);
-       }
-   }
- 
-   cairo_destroy (cr);
-   cairo_surface_write_to_png (surface, "./wmts.png");
-   cairo_surface_destroy (surface);
-   return true;
-}
-bool DmpTileThumbnail::ctreatTmsThumbnail()
-{
-   std::string path="/mnt/d/Code/tiles/qgis";
-   std::string vendor="QGIS";
-   Point origin{.x=-400,.y=400};
-   Point minPoin{.x=107.78981494180618,.y=18.870480519260582};
-   Point maxPoin{.x=120.43553603935675,.y=25.999868757737033};
-   double resolution=0.02197265625009295*256;
-   //    int minCol=floor(abs(origin.x-minPoin.x)/resolution);
-   //    int minRow=floor(abs(origin.y-minPoin.y)/resolution);
-   //    int maxCol=floor(abs(origin.x-maxPoin.x)/resolution);
-   //    int maxRow=floor(abs(origin.y-maxPoin.y)/resolution);
-   int minCol=51;
-   int minRow=28;
-   int maxCol=53;
-   int maxRow=27;
-   int width=maxCol-minCol;
-   int heigth=minRow-maxRow;
-   cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 256*(width+1), 256*(heigth+1));
-   cairo_t *cr =cairo_create (surface);
-   for( int i = 0 ; i <= width ; i++ )
-   {
-       for(int j=0;j<=heigth;j++)
-       {          
-           std::string filepath=path+"/6/"+std::to_string(minCol+i)+"/"+std::to_string(maxRow+j)+".png";
-           cairo_surface_t*  image = cairo_image_surface_create_from_png( filepath.c_str());
-           
-           BufferCopy(image,surface,cr,i*256,j*256);
-       }
-   }
-   cairo_destroy (cr);
-   cairo_surface_write_to_png (surface, "./tms.png");
-   cairo_surface_destroy (surface);
-   return true;
-}
-bool DmpTileThumbnail::BufferCopy(cairo_surface_t *pClsCSFrom, cairo_surface_t *pClsCSTo, cairo_t *cr,int x,int y)
-{
-    if (pClsCSFrom == NULL||pClsCSTo == NULL)
-    {
-        return false;
-    }
-    if(cr==NULL)
-    {
-        cr =  cairo_create (pClsCSTo);
-    }
-    cairo_set_source_surface(cr, pClsCSFrom, x, y); 
-    cairo_paint(cr);
-   
-    return true;
-}
-void DmpTileThumbnail::getTile(int row, int col, int level,  std::string& format,char* refbuff,int length)
-{
-    int packSize = 128;
-    int rGroup = (int)row/packSize;
-    rGroup = rGroup * packSize;
-    int cGroup = (int)col/packSize;
-    cGroup = cGroup*packSize;
-    std::string path="/mnt/d/Code/tiles/gdmap/_alllayers";
-    std::string bundleBase =GetBundlePath(level,rGroup,cGroup);
-    std::string bundleFilePath = path+bundleBase + ".bundle";
-    std::string bundlxFilePath = path+bundleBase + ".bundlx";
-    
-    int index = packSize * (col - cGroup) + (row - rGroup);
-
-    //读取bundlx文件存储该切片的位置,计算偏移量
-    std::ifstream freadx(bundlxFilePath,  std::ifstream::binary); 
-    if(!freadx)   
-    {
-        
-        return;
-    }
-    freadx.seekg(16+5*index, freadx.beg);
-    char* buffer = new char[5];
-    freadx.read(buffer,5);
-    freadx.close();
-    
-    long offset = (long)(buffer[0]&0xff) 
-                    + (long)(buffer[1]&0xff) * 256 
-                    + (long)(buffer[2]&0xff) * 65536
-                    + (long)(buffer[3]&0xff) * 16777216
-                    + (long)(buffer[4]&0xff) * 4294967296L;
-    delete [] buffer;
-    //读取bundle文件获取切片
-    std::ifstream fread(bundleFilePath, std::ifstream::binary); 
-    if(!fread)   
-    {
-       
-        return;
-    }  
-    fread.seekg(offset, fread.beg);
-    char* buff = new char[4];
-    fread.read(buff, 4);
-    length = (long)(buff[0]&0xff) 
-                 + (long)(buff[1]&0xff) * 256 
-                 + (long)(buff[2]&0xff) * 65536
-                 + (long)(buff[3]&0xff) * 16777216;
-    delete[] buff;
-    char* imgBuffer = new char[length];
-    fread.read(imgBuffer, length);
-    fread.close();
-    refbuff=imgBuffer;
-    delete[] imgBuffer;
-}
-std::string DmpTileThumbnail::GetBundlePath(int level, int rGroup, int cGroup)
-{
-    std::string l = std::to_string(level);
-    int len = l.length();
-    if (len < 2)
-    {
-        for (int i = 0; i < 2 - len; i++)
-        {
-            l = "0" + l;
-        }
-    }
-    l = "L" + l;
-    std::string r =IntToHexStr(rGroup);
-    
-    int rLength = r.length();
-    if (rLength < 4)
-    {
-        for (int i = 0; i < 4 - rLength; i++)
-        {
-            r = "0" + r;
-        }
-    }
-    r = "R" + r;
-
-    std::string c = IntToHexStr(cGroup);
-    int cLength = c.length();
-    if (cLength < 4)
-    {
-        for (int i = 0; i < 4 - cLength; i++)
-        {
-            c = "0" + c;
-        }
-    }
-    c = "C" + c;
-    std::string rootPath;
-    std::string bundlePath = rootPath + "/"+l+"/"+r+c;
-    return bundlePath;
-}
-std::string DmpTileThumbnail::IntToFormatStr(const int num)
-    {
-        std::string str = std::to_string(num);    
-        if(num>=0 && num<10)
-        {
-            str = "0"+str;
-        }
-	    return str;
-    }
-
-std::string DmpTileThumbnail::IntToHexStr(const int num)
-    {
-        char* buffer = new char[8];
-        sprintf(buffer,"%x",num);
-        std::string str = std::string(buffer);
-        delete[] buffer;
-        return str;
-    }
-
-
-cairo_status_t DmpTileThumbnail::cairo_read_func_mine (void *closure, unsigned char *data, unsigned int length)
-{
-	st_png_data* pPngData = (st_png_data*)closure;
-	memcpy(data, pPngData->pdata + pPngData->length, length);
-	pPngData->length += length;
-	return CAIRO_STATUS_SUCCESS;
-}

-/**************************************************************************
-* file:              dmptilethumbnail.h
-
-* Author:            lijiahuan
-* Date:              2021-12-23 15:34:29
-* Email:             jiahuanl@chinadci.com
-* copyright:         广州城市信息研究所有限公司
-***************************************************************************/
-
-#ifndef __dmptilethumbnail_h__
-#define __dmptilethumbnail_h__
-#include <cairo/cairo.h>
-#include "dmptilelayer.h"
-// namespace tileserver 
-// { 
-    class  DmpTileThumbnail
-    {
-    public:
-       
-       static bool ctreatTmsThumbnail() ;
-       static bool ctreatWmtsThumbnail(DmpTileLayer *tileLayer);
-       static bool BufferCopy(cairo_surface_t *pClsCSFrom, cairo_surface_t *pClsCSTo,cairo_t *cr,int x,int y);
-       static void getTile(int row, int col, int level, std::string& format,char* refbuff,int length); 
-       static std::string GetBundlePath(int level, int rGroup, int cGroup);
-       static std::string IntToFormatStr(const int num);
-       static std::string IntToHexStr(const int num);
-       static cairo_status_t cairo_read_func_mine (void *closure, unsigned char *data, unsigned int length);
-       const int _packetSize = 128;
-       
-    };  
-    struct Point
-    {
-        double x;
-        double y;   
-    };
-    
-    struct st_png_data
-    {
-	    unsigned char* pdata;
-	    unsigned int length;
-    };
-// }    
-
-#endif // __dmptilethumbnail_h__

@@ -100,8 +100,10 @@ void DmpManagerApiHandler::regService(const DmpServerApiContext &context) const
                 int flag=context.manager()->publish(serverType, name, title, capabilities, project);
                 if(flag==1) {
                     LOGGER_INFO("服务发布成功");
+                    std::string url;
                     std::string http="http://"+context.request()->domain()+":"+context.request()->port();
-                    std::string url=http+"/DMap/Services/"+name+"/TileServer/tmsService?REQUEST=GetThumbnail";
+
+                    url=http+"/DMap/Services/"+name+"/TileServer/tmsService?REQUEST=GetThumbnail";
                     context.response()->write("{\"status\":\""+std::to_string(flag)+"\",\"url\":\""+url+"\",\"message\":\"Pulish service successful!\"}");
                     // std::string projData;
                     // DmpServerUtils::Base64Decode(project, &projData);
@@ -232,7 +234,7 @@ void DmpManagerApiHandler::reloadServices(const DmpServerApiContext &context) co
     {
         case DmpServerRequest::Method::GET_METHOD:
         {
-            if(context.manager()->LoadServices()) {
+            if(context.manager()->loadServices()) {
                 context.response()->write("{\"status\":\"true\",\"message\":\"重载服务成功\"}");
             }else{
                 context.response()->write("{\"status\":\"false\",\"message\":\"重载服务失败\"}");

@@ -3,7 +3,6 @@
 
 SET (TILESERVER_SRCS
   dmptileserver.cpp
-  #dmptilethumbnail.cpp
   wmts/dmpwmts.cpp
   wmts/dmpwmtsparameters.cpp
   wmts/dmptileproviderfactory.cpp
@@ -19,7 +18,6 @@ SET (TILESERVER_SRCS
 
 SET (TILESERVER_HDRS
   dmptileserver.h
-  #dmptilethumbnail.h
   wmts/dmpwmtsparameters.h
   wmts/dmptileprovider.h
   wmts/dmptileproviderfactory.h

@@ -12,7 +12,7 @@
 #include "wmts/dmpwmts.h"
 #include "tms/dmptms.h"
 #include "dmpserverresponse.h"
-#include "dmptilethumbnail.h"
+#include "dmptilelayer.h"
 
 namespace tileserver 
 {
@@ -100,13 +100,16 @@ void DmpTileServer::executeRequest(DmpServerRequest &request, DmpServerResponse
 }
 
 bool DmpTileServer::publish(const std::string &serviceName, const std::string &title, unsigned int capability, const DmpProject &project)
-{
+{  
+    //DmpTileLayer *tileLayer = static_cast<DmpTileLayer *>(project.getLayer());
+    //std::string filePath=tileLayer->getDataSource();
+    std::string filePath="/mnt/d";
     if(capability & DmpServiceType::WMTS) {
         DmpService* wmtsservice = getService("WMTSService");
         if(!wmtsservice) {
             return false;
         }
-        else if(!wmtsservice->validate())
+        else if(!wmtsservice->validate(filePath))
         {
            return false;
         }
@@ -116,17 +119,13 @@ bool DmpTileServer::publish(const std::string &serviceName, const std::string &t
         if(!tmsservice) {
             return false;
         }
-        else if(!tmsservice->validate())
+        else if(!tmsservice->validate(filePath))
         {
            return false;
         }
     }
     DmpServerProject* serverProject = new DmpServerProject(serviceName, title, &project);
     serverProjects_[serviceName] = serverProject;
-
-
-
-
     return true;
 }
 

@@ -23,7 +23,7 @@
 #include "dmpservice.h"
 #include "dmpserverutils.h"
 #include "dmpserverproject.h"
-#include<cairo/cairo.h>
+#include "dmptilelayer.h"
 
 namespace tileserver 
 {

@@ -29,10 +29,21 @@ namespace DmpTms
   {
     LOGGER_DEBUG("Destructing TmsService");
   }
-
-  void DmpTMSService::executeRequest(const DmpServerContext &context) 
+  bool DmpTMSService::validate(std::string &filePath) 
   {
-    
+    //判断切片路径
+    if(filePath.empty())
+    {
+      return false;
+    }
+    else  if (!(boost::filesystem::exists(filePath) && boost::filesystem::is_directory(filePath)))
+    {
+      return false;
+    }
+    return true;
+  }
+  void DmpTMSService::executeRequest(const DmpServerContext &context) 
+  {  
     if(context.request()->isRestful())
     {
       std::string path=context.request()->path();
@@ -75,11 +86,24 @@ namespace DmpTms
         return;
       }        
     }
-    else
+    else 
     {
-      context.response()->write("非TMS请求");
-    }
-    
+      std::string strQuery= context.request()->query();   
+      if(!strQuery.empty()&&std::strcmp(strQuery.c_str(),"REQUEST=GetThumbnail")==0)
+      {
+        //生成缩略图
+        const DmpProject *project = context.serverProject()->project();
+        DmpTileLayer *tileLayer = static_cast<DmpTileLayer *>(project->getLayer());
+        
+        DmpTmsTileProvider provider_=DmpTmsTileProvider("");
+        provider_.GetTileThumbnail(tileLayer,*context.response()); 
+      }
+      else
+      {
+        context.response()->write("非TMS请求");
+      }
+    } 
   }
+ 
 
 } // namespace DmpTms
\ No newline at end of file

@@ -23,8 +23,10 @@ namespace DmpTms
     std::string name() const override { return std::string("TMSService"); }
     std::string version() const override { return std::string("1.0.0"); }
     std::string description() const override { return std::string("TMS瓦片服务"); }
+    bool validate(std::string &filePath) override;
     bool allowMethod(DmpServerRequest::Method method) const override { return method == DmpServerRequest::GET_METHOD;}
     void executeRequest(const DmpServerContext &context) override;
+ 
   };
 }
 

@@ -8,6 +8,8 @@
 ***************************************************************************/
 #include "dmptmstileprovider.h"
 #include "dmpserverresponse.h"
+#include <math.h>
+#include "dmplogger.h"
 namespace DmpTms
 {
     DmpTmsTileProvider::DmpTmsTileProvider(const std::string& root_path)
@@ -43,4 +45,104 @@ namespace DmpTms
         }
         fread.close();
     }
+    void DmpTmsTileProvider::GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& respons)
+    {
+       int tilematrix=0;
+       std::string tilePath=dmpTileLayer->getDataSource();
+
+       //tilePath="/mnt/d/Code/tiles/qgis";
+       DmpRectangle rectangle=dmpTileLayer->extent();
+       
+       DmpPoint min=DmpPoint(rectangle.xmin(),rectangle.ymin());
+       DmpPoint max=DmpPoint(rectangle.xmax(),rectangle.ymax());
+       tilematrix=this->screenMatrixSet(min,max);
+       int xMinTile, yMinTile,xMaxTile,yMaxTile;
+       this->degToNum(tilematrix,min.x(),min.y(),xMinTile,yMinTile);
+       this->degToNum(tilematrix,max.x(),max.y(),xMaxTile,yMaxTile);
+       int heigth=abs(yMaxTile-yMinTile);
+       int width=abs(xMaxTile-xMinTile);
+
+       cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 256*(width+1), 256*(heigth+1));
+       cairo_t *cr =cairo_create (surface);
+       for( int i = 0 ; i <= width ; i++ )
+       {
+           for(int j=0;j<=heigth;j++)
+           {
+               std::string filepath=tilePath+"/"+std::to_string(tilematrix)+"/"+std::to_string(xMinTile+i)+"/"+std::to_string(yMaxTile+j)+".png";
+               cairo_surface_t*  image = cairo_image_surface_create_from_png( filepath.c_str());
+               this->BufferCopy(image,surface,cr,i*256,j*256);
+               //cairo_surface_write_to_png (surface, "./tms.png");
+               LOGGER_DEBUG(filepath);
+           }
+       }       
+       //cairo_surface_write_to_png (surface, "./tms.png");      
+       std::string responseData;
+       cairo_surface_write_to_png_stream(surface, cairo_write_func, &responseData);
+       respons.removeHeader("Content-Type");
+       respons.setHeader("Content-Type", "image/png"); 
+       respons.write(responseData); 
+       cairo_destroy (cr);
+       cairo_surface_destroy (surface);       
+    }  
+    //经纬度到瓦片
+    void DmpTmsTileProvider::degToNum(int zoom, double lon_deg, double lat_deg,int& x,int& y)
+    {
+        double n = pow(2.0, zoom);
+        double xtile = n * ((lon_deg + 180) / 360);
+	    //角度转弧度
+	    double lat_rad = lat_deg * RAD2DEG;
+	    double ytile = n * (1 - (log(tan(lat_rad) + (1 / cos(lat_rad))) / pi)) / 2;
+        
+	    x = (int)floor(xtile);
+	    y = (int)floor(ytile);
+    }
+    //瓦片到经纬度
+    // double* DmpTmsTileProvider::numToDeg(int zoom, int xtile, int ytile)
+    // {
+    //     double n = pow(2.0, zoom);
+	//     double lon_deg = double(xtile) / n * 360.0 - 180.0;
+	//     double lat_rad = atan(sinh(pi * (1 - 2 * ytile / n)));
+	//     double lat_deg = lat_rad * 180.0 / pi;
+    //     double lonlat[2] = {};
+	//     lonlat[0] = lon_deg;
+	//     lonlat[1] = lat_deg;
+    //     return lonlat;
+    // }  
+    bool DmpTmsTileProvider::BufferCopy(cairo_surface_t *pClsCSFrom, cairo_surface_t *pClsCSTo, cairo_t *cr,int x,int y)
+    {
+        if (pClsCSFrom == NULL||pClsCSTo == NULL)
+        {
+            return false;
+        }
+        if(cr==NULL)
+        {
+            cr =  cairo_create (pClsCSTo);
+        }
+        cairo_set_source_surface(cr, pClsCSFrom, x, y); 
+        cairo_paint(cr);
+        return true;
+    }
+    cairo_status_t DmpTmsTileProvider::cairo_write_func(void *pbuff, const unsigned char *data, unsigned int length)
+    {
+        std::string *responseData = (std::string *)pbuff;
+        responseData->append((char *)data, length);
+        return CAIRO_STATUS_SUCCESS;
+    }
+    int DmpTmsTileProvider::screenMatrixSet(DmpPoint min,DmpPoint max)
+    {
+        int iMatrixSet=4;
+        for( ; iMatrixSet<=20 ; iMatrixSet++ )
+        {
+            int xMinTile, yMinTile,xMaxTile,yMaxTile;
+            this->degToNum(iMatrixSet,min.x(),min.y(),xMinTile,yMinTile);
+            this->degToNum(iMatrixSet,max.x(),max.y(),xMaxTile,yMaxTile);
+            int heigth=abs(yMaxTile-yMinTile);
+            int width=abs(xMaxTile-xMinTile);
+            if((heigth+1)*(width+1)<9 && (heigth+2)*(width+2)>10)
+            {
+                break;
+            }
+        }               
+        return iMatrixSet;
+    }
 }
\ No newline at end of file

@@ -11,15 +11,25 @@
 
 #include <string>
 #include "dmpserverresponse.h"
+#include "dmptilelayer.h"
+#include "dmpproject.h"
 
 namespace DmpTms
 {
+  #define RAD2DEG pi/180.0
   class DmpTmsTileProvider 
   {
     public:      
       std::string ImageFormat() const;
       DmpTmsTileProvider(const std::string& root_path);
       void WriteTile(const int row, const int col, const int level, const std::string& format, DmpServerResponse& response) ;
+      void GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& respons);
+      const double pi = 3.141592653589793238463;
+      void degToNum(int zoom, double lon_deg, double lat_deg,int& x,int& y);
+      //double* numToDeg(int zoom, int xtile, int ytile);
+      bool BufferCopy(cairo_surface_t *pClsCSFrom, cairo_surface_t *pClsCSTo,cairo_t *cr,int x,int y);
+      static cairo_status_t cairo_write_func(void *pbuff, const unsigned char *data, unsigned int length);
+      int screenMatrixSet(DmpPoint min,DmpPoint max);
     protected:
       std::string file_rootPath;
   };

@@ -15,13 +15,10 @@
 #include "dmpserverresponse.h"
 #include "dmpcapabilitiesprovider.h"
 
-
-
 using namespace std;
 
 namespace DmpWmts
-{
-     
+{     
     class DmpCapabiliTilesOperation:public DmpCapabiliTilesProvider
     {
         private:

@@ -8,7 +8,12 @@
 ***************************************************************************/
 #include "dmpwmtsutils.h"
 #include "dmpesribundlev1provider.h"
+#include "dmptileproviderfactory.h"
 #include <iostream>
+#include "dmptilelayer.h"
+#include <math.h>
+#include <cairo/cairo.h>
+
 namespace DmpWmts
 {
     DmpEsriBundleV1Provider:: DmpEsriBundleV1Provider(const std::string& rootPath)
@@ -79,4 +84,101 @@ namespace DmpWmts
         }
         delete[] imgBuffer;
     }
+    void DmpEsriBundleV1Provider::GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& response)
+    {
+        std::string tilePath=dmpTileLayer->getDataSource();
+        DmpRectangle rectangle=dmpTileLayer->extent();
+        std::string format=dmpTileLayer->getFormat();
+        // std::string lowerPoint=std::to_string(rectangle.xmin())+" "+std::to_string(rectangle.ymin());
+        // std::string upperPoint=std::to_string(rectangle.xmax())+" "+std::to_string(rectangle.ymax());
+        DmpPoint min=DmpPoint(rectangle.xmin(),rectangle.ymin());
+        DmpPoint max=DmpPoint(rectangle.xmax(),rectangle.ymax());
+        std::vector<DmpTileMatrixSet*> tileMatrixSets;
+        dmpTileLayer->getTileMatrixSets(tileMatrixSets); 
+        double resolution;
+        DmpPoint origin;
+        int  iLevel,xMinTile,yMinTile, xMaxTile, yMaxTile,buffLen;
+        if(!TileProviderFactory::GetTileScale(dmpTileLayer,iLevel,xMinTile,yMinTile, xMaxTile, yMaxTile))
+        {
+            response.sendError(500, "缩略图范围错误:(");
+            return;
+        }
+        std::string buff;
+        GetTile(yMinTile,xMinTile,iLevel,buff,buffLen);
+         response.removeHeader("Content-Type"); 
+         std::string f = (format == "jpg") ? "image/jpg" : "image/png";     
+         response.setHeader("Content-Type", f);
+        response.write(buff);                 
+    }
+    
+    bool DmpEsriBundleV1Provider::GetTile(int row, int col, int level,std::string& refbuff,int& length )
+    {
+        int packSize = 128;
+        int rGroup = (int)row/packSize;
+        rGroup = rGroup * packSize;
+        int cGroup = (int)col/packSize;
+        cGroup = cGroup*packSize;
+        rootPath_="/mnt/d/Code/tiles/gdmap/_alllayers";
+        std::string bundleBase =GetBundlePath(level,rGroup,cGroup);
+        std::string bundleFilePath = bundleBase + ".bundle";
+        std::string bundlxFilePath = bundleBase + ".bundlx";
+
+        int index = packSize * (col - cGroup) + (row - rGroup);
+
+        //读取bundlx文件存储该切片的位置,计算偏移量
+        std::ifstream freadx(bundlxFilePath,  std::ifstream::binary); 
+        if(!freadx)   
+        {
+            return false;
+        }
+        freadx.seekg(16+5*index, freadx.beg);
+        char* buffer = new char[5];
+        freadx.read(buffer,5);
+        freadx.close();
+    
+        long offset = (long)(buffer[0]&0xff) 
+                    + (long)(buffer[1]&0xff) * 256 
+                    + (long)(buffer[2]&0xff) * 65536
+                    + (long)(buffer[3]&0xff) * 16777216
+                    + (long)(buffer[4]&0xff) * 4294967296L;
+        delete [] buffer;
+        //读取bundle文件获取切片
+        std::ifstream fread(bundleFilePath, std::ifstream::binary);
+        if(!fread)   
+        {
+            return false;
+        }
+        fread.seekg(offset, fread.beg);
+        char* buff = new char[4];
+        fread.read(buff, 4);
+        length = (long)(buff[0]&0xff) 
+                 + (long)(buff[1]&0xff) * 256 
+                 + (long)(buff[2]&0xff) * 65536
+                 + (long)(buff[3]&0xff) * 16777216;
+        delete[] buff;
+        char *imgBuffer = new char[length];
+        fread.read(imgBuffer, length);       
+        fread.close();
+        // cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 256, 256);
+        // cairo_t *cr =cairo_create (surface);
+        // st_png_data* pPngData;
+        // pPngData->pdata=(unsigned char*)buff;
+        // pPngData->length=length;
+        // cairo_surface_t *image = cairo_image_surface_create_from_png_stream (cairo_read_func,&pPngData);
+        
+        // TileProviderFactory::BufferCopy(image,surface,cr,0,0);
+        // cairo_surface_write_to_png (surface, "./wmts.png");
+        // cairo_destroy (cr);
+        // cairo_surface_destroy (surface);
+        delete[] imgBuffer;
+        return true;
+        
+    }
+    // cairo_status_t cairo_read_func (void *closure, unsigned char *data, unsigned int length,DmpServerResponse& response)
+    // {
+    //     st_png_data* pPngData = (st_png_data*)closure;
+	//     memcpy(data, pPngData->pdata + pPngData->length, length);
+	//     pPngData->length += length;
+	//     return CAIRO_STATUS_SUCCESS;
+    // }
 }
\ No newline at end of file

@@ -11,6 +11,9 @@
 #define __dmpesribundlev1provider_h__
 #include "dmptileprovider.h"
 #include "dmpabstractesribundleprovider.h"
+#include "dmptilelayer.h"
+#include "dmppoint.h"
+
 namespace DmpWmts
 {
     class DmpEsriBundleV1Provider : public DmpAbstractEsriBundleProvider
@@ -18,6 +21,14 @@ namespace DmpWmts
       public:
         DmpEsriBundleV1Provider(const std::string& rootPath);
         void WriteTile(const int row, const int col, const int level, const std::string& format, DmpServerResponse& response) override;
+        void GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& response) override;
+        bool GetTile(const int row,const int col,const int level,std::string& refbuff,int& length);
+        //static cairo_status_t cairo_read_func (void *closure, unsigned char *data, unsigned int length);
     };
+    // struct st_png_data
+    // {
+    //   unsigned char* pdata;
+	  //   unsigned int length;
+    // };
 }
 #endif //__dmpesribundlev1provider_h__

@@ -70,4 +70,8 @@ namespace DmpWmts
         }
         delete[] imgBuffer;
     }
+    void DmpEsriBundleV2Provider::GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& respons)
+    {
+
+    }
 }
\ No newline at end of file

@@ -11,6 +11,8 @@
 #define __dmpesribundlev2provider_h__
 #include "dmptileprovider.h"
 #include "dmpabstractesribundleprovider.h"
+#include "dmptilelayer.h"
+
 namespace DmpWmts
 {
     class DmpEsriBundleV2Provider : public DmpAbstractEsriBundleProvider
@@ -18,6 +20,7 @@ namespace DmpWmts
       public:
         DmpEsriBundleV2Provider(const std::string& rootPath);
         void WriteTile(const int row, const int col, const int level, const std::string& format, DmpServerResponse& response) override;
+        void GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& respons) override;
     };
 }
 

@@ -60,4 +60,8 @@ namespace DmpWmts
         }
         fread.close();
     }
+    void DmpEsriTileProvider::GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& respons)
+    {
+
+    }
 }
\ No newline at end of file

@@ -10,6 +10,8 @@
 #define __dmpesritileprovider_h__
 #include "dmptileprovider.h"
 #include <string>
+#include "dmptilelayer.h"
+
 
 namespace DmpWmts
 {
@@ -18,6 +20,7 @@ namespace DmpWmts
     public:
       DmpEsriTileProvider(const std::string& rootPath);
       void WriteTile(const int row, const int col, const int level, const std::string& format, DmpServerResponse& response) override;
+      void GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& respons) override;
     private:
       std::string IntToHex8Str(const int num);
   };

@@ -12,6 +12,7 @@
 
 #include <string>
 #include "dmpserverresponse.h"
+#include "dmptilelayer.h"
 
 namespace DmpWmts
 {
@@ -19,7 +20,8 @@ namespace DmpWmts
   {
     public:
       DmpTileProvider(const std::string& rootPath) { rootPath_ = rootPath ;}
-      virtual void WriteTile(const int row, const int col, const int level, const std::string& format, DmpServerResponse& respons) = 0;   
+      virtual void WriteTile(const int row, const int col, const int level, const std::string& format, DmpServerResponse& respons) = 0; 
+      virtual void GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& respons)=0;
     
     protected:
       std::string rootPath_;

@@ -59,6 +59,7 @@ namespace DmpWmts
     
     return provider;
   }
+
   int TileProviderFactory::StringToVector(std::string& strVector)
   {
         int iVector=-1;
@@ -80,14 +81,74 @@ namespace DmpWmts
         }        
         return iVector;
   } 
-  // CapabiliTileProviderFactory::CapabiliTileProviderFactory()
-  // {
-  // }
-  // std::shared_ptr<DmpCapabiliTilesProvider> CapabiliTileProviderFactory::GetProvider()
-  // {
-  //   std::shared_ptr<DmpCapabiliTilesProvider> provider;
-  //   provider = std::make_shared<DmpCapabiliTilesOperation>();
-    
-  //   return provider;
-  // }
+  int TileProviderFactory::screenTileMatrix(DmpPoint& min,DmpPoint& max,std::vector<DmpTileMatrixSet*>& tileMatrixSets,double& resolution,DmpPoint& origin)
+  {
+    int iLevel=-1;
+    for(auto iter=tileMatrixSets.cbegin();iter!=tileMatrixSets.cend();iter++)
+    { 
+        boost::property_tree::ptree ptLevels;
+        DmpPoint* pOrigin=(*iter)->tileOrigin();
+        std::vector<TileLevel*> tileLevels=(*iter)->tileLevels();
+        for(auto leviter=tileLevels.cbegin();leviter!=tileLevels.cend();leviter++)
+        {        
+          int id=(*leviter)->id;
+          double relus = (*leviter)->resolution;
+          relus=relus*256;
+          origin=DmpPoint(pOrigin->y(),pOrigin->x());
+          int xMinTile,yMinTile,xMaxTile,yMaxTile;
+          TileProviderFactory::PointToRowCol(min,origin,relus,xMinTile,yMinTile);
+          TileProviderFactory::PointToRowCol(max,origin,relus,xMaxTile,yMaxTile);
+          int heigth=abs(yMaxTile-yMinTile);
+          int width=abs(xMaxTile-xMinTile);
+          if((heigth+1)*(width+1)<9 && (heigth+2)*(width+2)>10)
+          {
+            iLevel=id;
+            resolution=relus;
+            break;
+          }
+        }        
+    }   
+    return iLevel;
+  }
+  //点坐标转行列号
+  void TileProviderFactory::PointToRowCol(DmpPoint& point,DmpPoint& origin,double resolution,int& xTile,int& yTile)
+  {
+    xTile=floor(abs(origin.x()-point.x())/resolution);
+    yTile=floor(abs(origin.y()-point.y())/resolution);
+  }
+  bool TileProviderFactory::GetTileScale(DmpTileLayer* dmpTileLayer,int& iLevel,int& xMinTile,int& yMinTile,int& xMaxTile,int& yMaxTile)
+  {
+    std::string tilePath=dmpTileLayer->getDataSource();
+    DmpRectangle rectangle=dmpTileLayer->extent();
+    DmpPoint min=DmpPoint(rectangle.xmin(),rectangle.ymin());
+    DmpPoint max=DmpPoint(rectangle.xmax(),rectangle.ymax());
+    std::vector<DmpTileMatrixSet*> tileMatrixSets;
+    dmpTileLayer->getTileMatrixSets(tileMatrixSets);
+    DmpPoint origin;
+    double resolution;
+    //筛选合适的切片层级
+    iLevel=TileProviderFactory::screenTileMatrix(min,max,tileMatrixSets,resolution,origin);
+    if(iLevel==-1)
+    {
+        return false;
+    }
+    // int xMinTile,yMinTile,xMaxTile,yMaxTile;
+    TileProviderFactory::PointToRowCol(min,origin,resolution,xMinTile,yMinTile);
+    TileProviderFactory::PointToRowCol(max,origin,resolution,xMaxTile,yMaxTile);
+    return true;
+  }
+  bool TileProviderFactory::BufferCopy(cairo_surface_t *pClsCSFrom, cairo_surface_t *pClsCSTo, cairo_t *cr,int x,int y)
+    {
+        if (pClsCSFrom == NULL||pClsCSTo == NULL)
+        {
+            return false;
+        }
+        if(cr==NULL)
+        {
+            cr =  cairo_create (pClsCSTo);
+        }
+        cairo_set_source_surface(cr, pClsCSFrom, x, y); 
+        cairo_paint(cr);
+        return true;
+    }
 }
\ No newline at end of file

@@ -13,6 +13,11 @@
 #include "dmptileprovider.h"
 #include "dmptilelayer.h"
 #include <memory>
+#include <cairo/cairo.h>
+#include "dmppoint.h"
+#include "dmptilelayer.h"
+#include "dmppoint.h"
+
 
 //#include "dmpcapabilitiesprovider.h"
 
@@ -33,8 +38,15 @@ namespace DmpWmts
   public:
     static std::shared_ptr<DmpTileProvider> GetProvider( DmpTileLayer* dmpTileLayer);
     static int StringToVector(std::string& strVector);
+    static bool BufferCopy(cairo_surface_t *pClsCSFrom, cairo_surface_t *pClsCSTo,cairo_t *cr,int x,int y);
+    static int screenTileMatrix(DmpPoint& min,DmpPoint& max,std::vector<DmpTileMatrixSet*>& tileMatrixSets,double& resolution,DmpPoint& origin);
+    static void PointToRowCol(DmpPoint& point,DmpPoint& origin,double resolution,int& xTile,int& yTile);
+    static bool GetTileScale(DmpTileLayer* dmpTileLayer,int& iLevel,int& xMinTile,int& yMinTile,int& xMaxTile,int& yMaxTile);
+    
   private:
     TileProviderFactory();
   };
+    
+  
 }
 #endif //__dmptileproviderfactory_h__

@@ -22,6 +22,7 @@
 #include "dmplogger.h"
 #include "dmptileproviderfactory.h"
 #include "dmpserverrequest.h"
+#include "dmpwmtsservice.h"
 #include "dmpwmts.h"
 #include "dmptilelayer.h"
 
@@ -39,9 +40,9 @@ namespace DmpWmts
   {
     LOGGER_DEBUG("Destructing WmtsService");
   }
-  bool DmpWMTSService::validate() 
+  bool DmpWMTSService::validate(std::string &filePath) 
   {
-    return false;
+    return true;
   }
   void DmpWMTSService::executeRequest(const DmpServerContext &context)
   {
@@ -79,6 +80,8 @@ namespace DmpWmts
     }
     else if(boost::iequals(req, "GetThumbnail"))
     {
+      std::shared_ptr<DmpTileProvider> provider = TileProviderFactory::GetProvider(tileLayer);
+      provider->GetTileThumbnail(tileLayer, *context.response());
     }
     else if (boost::iequals(req, "GetCapabilities"))
     {

@@ -24,7 +24,7 @@ namespace DmpWmts
     std::string name() const override { return std::string("WMTSService"); }
     std::string version() const override { return std::string("1.0.0"); }
     std::string description() const override { return std::string("WMTS瓦片服务"); }
-    bool validate() override;
+    bool validate(std::string &filePath) override;
     bool allowMethod(DmpServerRequest::Method method) const override { return method == DmpServerRequest::GET_METHOD;}
     void executeRequest(const DmpServerContext &context) override;
     

+/**************************************************************************
+* file:              dmpwmtsservice.cpp
+
+* Author:            wanzhongping
+* Date:              2021-07-28 11:34:16
+* Email:             zhongpingw@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpwmtsservice.h"
+
+// DmpWMTSService::DmpWMTSService()
+//    : DmpService()
+// {
+//   map_type_ = MapServerType::WMTS_SERVER;
+//    //AddProperty("tilePath","/usr/local/dmap4/gdmap/_alllayers");
+//    //AddProperty("tilePath","/mnt/d/Code/tiles/gdmap/_alllayers");
+//    //AddProperty("tileVersion","1");  
+// }
+// DmpWMTSService::~DmpWMTSService()
+// {
+// }
+// bool DmpWMTSService::Read(boost::property_tree::ptree &pt_node) 
+// {
+//   try {
+//     enabled_ = pt_node.get<bool>("enabled");
+//     capabilities_ = pt_node.get<std::string>("capabilities");
+
+//     //读取属性
+//     for (auto property : pt_node.get_child("properties"))
+//     {
+//       std::string key = property.first;
+//       std::string val = property.second.data();
+//       AddProperty(key, val);
+//     }
+       
+//   }
+//   catch(std::exception ex) {
+//     return false;
+//   }
+//   return true;
+// }
+// bool DmpWMTSService::Write(boost::property_tree::ptree &pt_node)
+// {
+//     pt_node.put("typeName", (int)map_type_);  
+//     pt_node.put("capabilities", capabilities_);
+//     pt_node.put("enabled", enabled_);
+
+//     boost::property_tree::ptree pt_subitem;
+//     std::map<std::string, std::string>::iterator iter = properties_.begin();
+//     while(iter != properties_.end())
+//     {
+//          pt_subitem.put(iter->first, iter->second);
+//          ++iter;
+//     }
+//     pt_node.put_child("properties", pt_subitem);
+
+//     return true;
+// }

+/**************************************************************************
+* file:              dmpwmtsservice.h
+
+* Author:            wanzhongping
+* Date:              2021-07-28 11:34:06
+* Email:             zhongpingw@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpwmtsservice_h__
+#define __dmpwmtsservice_h__
+#include "dmpservice.h"
+
+
+// class DmpWMTSService : public DmpService
+// {
+//   public:
+//     DmpWMTSService();
+//     virtual ~DmpWMTSService();
+//     virtual bool Read(boost::property_tree::ptree &pt_node) override;  
+//     virtual bool Write(boost::property_tree::ptree &pt_node) override;
+    
+    
+//   protected:
+//     std::string capabilities_;
+//     bool enabled_;
+// };
+
+#endif // __dmpwmtsservice_h__