Merge branch 'master' of http://gitlab.ctune.cn/DMapServer/DMapServer4.1

@@ -24,7 +24,7 @@ SET(DMAP_CORE_SRCS
   dmptilematrixset.cpp
   dmptilematrixset.cpp
   dmpvectordataprovider.cpp
   dmpvectordataprovider.cpp
   dmpvectorlayer.cpp
   dmpvectorlayer.cpp
-  dmpvectorthinlayer.cpp
+  dmpvectorvacuatelayer.cpp
   dmpvectorlayerrenderer.cpp
   dmpvectorlayerrenderer.cpp
   dmpxmlutils.cpp
   dmpxmlutils.cpp
 
 
@@ -76,7 +76,7 @@ SET(DMAP_CORE_HDRS
   dmptilematrixset.h
   dmptilematrixset.h
   dmpvectordataprovider.h
   dmpvectordataprovider.h
   dmpvectorlayer.h
   dmpvectorlayer.h
-  dmpvectorthinlayer.h
+  dmpvectorvacuatelayer.h
   dmpvectorlayerrenderer.h
   dmpvectorlayerrenderer.h
   dmpxmlutils.h
   dmpxmlutils.h
 
 

@@ -223,4 +223,115 @@ DmpMapLayer *DmpProject::getLayer() const
   {
   {
     return nullptr;
     return nullptr;
   }
   }
+}
+
+bool DmpProject::initVectorLayerVacuate(std::function<std::string(const std::string &)> getVacuateFun)
+{
+  try
+  {
+    std::string tableguids = "";
+    for (int i = 0; i < vectorLayers_.size(); i++)
+    {
+      DmpMapLayer *layer = vectorLayers_.at(i);
+      if (layer->type() == DmpMapLayerType::VectorLayer)
+      {
+        if (!tableguids.empty())
+        {
+          tableguids += ",";
+        }
+        tableguids += layer->id();
+      }
+    }
+
+    if (tableguids.empty())
+    {
+      return false;
+    }
+
+    std::string vacuateInfo = getVacuateFun(tableguids);
+    if (vacuateInfo.empty())
+    {
+      return false;
+    }
+
+    std::istringstream stream(vacuateInfo);
+    ptree pt;
+    read_json(stream, pt);
+    bool result = pt.get<bool>("result");
+    if (!result)
+    {
+      return false;
+    }
+
+    //图层
+    ptree pLayers = pt.get_child("data");
+    // for (BOOST_AUTO(pos, pLayers.begin()); pos != pLayers.end(); ++pos)
+    for (ptree::iterator pos = pLayers.begin(); pos != pLayers.end(); ++pos)
+    {
+      ptree pLayer = pos->second;
+      int vacuateCount = pLayer.get<int>("vacuate_count");
+      if (vacuateCount > 0)
+      {
+        std::string tableGuid = pLayer.get<std::string>("table_guid");
+        std::string tableName = pLayer.get<std::string>("table_name");
+
+        DmpMapLayer *layer = this->getLayer(tableName);
+        if (layer && layer->type() == DmpMapLayerType::VectorLayer)
+        {
+          DmpVectorLayer *vectorLayer = (DmpVectorLayer *)layer;
+          ptree ptableVacuates = pLayer.get_child("table_vacuate");
+          for (BOOST_AUTO(pos1, ptableVacuates.begin()); pos1 != ptableVacuates.end(); ++pos1)
+          {
+            ptree pVacuateLayer = pos1->second;
+            shared_ptr<DmpVectorVacuateLayer> vacuateLayer(new DmpVectorVacuateLayer());
+            std::string name = pVacuateLayer.get<std::string>("name");
+            std::string connectStr = pVacuateLayer.get<std::string>("connectstr");
+            double pixel_distance = pVacuateLayer.get<double>("pixel_distance");
+            vacuateLayer->Init(pixel_distance, name, connectStr);
+            vectorLayer->ApplendCurrentScaleTable(vacuateLayer);
+          }
+        }
+      }
+    }//for
+    return true;
+  }
+  catch (const std::exception &e)
+  {
+    std::cerr << e.what() << '\n';
+    return false;
+  }
+  return false;
+}
+
+std::shared_ptr<DmpRectangle>  DmpProject::GetExtent()
+{
+  shared_ptr<DmpRectangle> rect(new DmpRectangle());
+  for (size_t i = 0; i < this->vectorLayers_.size(); i++)
+  {
+      DmpMapLayer* layer = this->vectorLayers_.at(i);
+      DmpRectangle layerExtent = layer->extent();
+      rect->merge(layerExtent);
+  }
+  return rect;
+}
+
+bool DmpProject::initVectorLayerVacuate(DmpProject* project)
+{
+  if(!project) return false;
+  for (size_t i = 0; i < project->vectorLayers().size(); i++)
+  {
+    DmpMapLayer *layer = project->vectorLayers().at(i);
+    if (layer->type() == DmpMapLayerType::VectorLayer)
+    {
+      DmpVectorLayer *vectorLayer = (DmpVectorLayer *)layer;
+      DmpVectorLayer *thisVectorLayer = (DmpVectorLayer*)this->getLayer(layer->name());
+      for (size_t i0 = 0; i0 < vectorLayer->vacuateLayers().size(); i0++)
+      {
+          std::shared_ptr<DmpVectorVacuateLayer> pvectorVacuateLayer =  vectorLayer->vacuateLayers().at(i0);
+          thisVectorLayer->vacuateLayers().push_back(pvectorVacuateLayer->clone());
+      }
+      
+    }
+  }
+  return true;
 }
 }

@@ -16,6 +16,7 @@
 #include <boost/filesystem.hpp>
 #include <boost/filesystem.hpp>
 #include "dmpcoordinatereferencesystem.h"
 #include "dmpcoordinatereferencesystem.h"
 #include "dmpmaplayer.h"
 #include "dmpmaplayer.h"
+#include <memory>
 
 
 //配图文件
 //配图文件
 class CORE_EXPORT DmpProject
 class CORE_EXPORT DmpProject
@@ -27,6 +28,9 @@ class CORE_EXPORT DmpProject
     bool Read(const std::string &data);
     bool Read(const std::string &data);
     bool Write(const std::string &filename, const std::string &data);
     bool Write(const std::string &filename, const std::string &data);
     bool WritePtree(boost::property_tree::ptree& ptDoc);
     bool WritePtree(boost::property_tree::ptree& ptDoc);
+      //初始化矢量图层金字塔信息
+    bool initVectorLayerVacuate(std::function<std::string(const std::string &)> getVacuateFun);
+    bool initVectorLayerVacuate(DmpProject* project);
     std::string WriteXml();
     std::string WriteXml();
     std::string WriteJson();
     std::string WriteJson();
     DmpCoordinateReferenceSystem crs() const;
     DmpCoordinateReferenceSystem crs() const;
@@ -34,6 +38,7 @@ class CORE_EXPORT DmpProject
     std::vector<DmpMapLayer*> vectorLayers() const;
     std::vector<DmpMapLayer*> vectorLayers() const;
     DmpMapLayer* getLayer(const std::string &layerName) const;
     DmpMapLayer* getLayer(const std::string &layerName) const;
     DmpMapLayer* getLayer()const;
     DmpMapLayer* getLayer()const;
+    std::shared_ptr<DmpRectangle>  GetExtent();
   private:
   private:
     static DmpProject *project_;
     static DmpProject *project_;
     std::string projectName_;
     std::string projectName_;

@@ -215,8 +215,8 @@ void DmpVectorLayer::setDataSource(const std::string &dataSource, const std::str
 }
 }
 
 
 DmpWkbTypes::GeometryType DmpVectorLayer::GeometryType() const
 DmpWkbTypes::GeometryType DmpVectorLayer::GeometryType() const
-{
-	return DmpWkbTypes::GeometryType(wkbType_);
+{	
+	return DmpWkbTypes::geometryType(wkbType_);
 }
 }
 
 
 bool DmpVectorLayer::setDataProvider(const std::string &provider)
 bool DmpVectorLayer::setDataProvider(const std::string &provider)
@@ -293,39 +293,29 @@ bool DmpVectorLayer::setDataProvider(const std::string &provider)
 	return true;
 	return true;
 }
 }
 
 
-shared_ptr<DmpVectorThinLayer> DmpVectorLayer::GetCurrentScaleTable(double dx)
+bool sortVacuateLayers(shared_ptr<DmpVectorVacuateLayer> p1,shared_ptr<DmpVectorVacuateLayer> p2)
 {
 {
+	return p1->dis() > p2->dis();
+}
 
 
-	/*
-		int outTime = 600;
-		if(this->dataCount >500000 && this->m_pDataset->m_MapLayerThinning.size() ==0)
-		{
-            outTime = 20;
-		}	
-		
-		clsLockClass lock(_wlock);
-		time_t now = time(0);
-			//shared_ptr<WMSServer> wmsServer = this->m_mapWmsServer[servicename];
-		if(now - this->m_pDataset->m_loadMapLayerThinning >  outTime)
-		{
-			this->m_pDataset->m_loadMapLayerThinning = now;
-			shared_ptr<Workspace> pWorkspaceDef = DataSourcePools::get_instance()->GetDefaultWorkspace();
+void DmpVectorLayer::ApplendCurrentScaleTable(shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer)
+{
+	this->vacuateLayers_.push_back(pVectorVacuateLayer);
+	sort(this->vacuateLayers_.begin(), this->vacuateLayers_.end(),sortVacuateLayers);
+	return;
+}
 
 
-			this->m_pDataset->InitMapLayerThinning(pWorkspaceDef.get(),this->m_layerName, this->m_dbSource);
-		}
-		else
-		{
-			this->m_pDataset->m_loadMapLayerThinning = now;
-		}
-*/
 
 
-	for (int i = 0; i < this->thinLayers_.size(); i++)
+shared_ptr<DmpVectorVacuateLayer> DmpVectorLayer::GetCurrentScaleTable(double dx)
+{
+	dx *= 2;
+	for (int i = 0; i < this->vacuateLayers_.size(); i++)
 	{
 	{
-		shared_ptr<DmpVectorThinLayer> mapLayerThinning = this->thinLayers_[i];
+		shared_ptr<DmpVectorVacuateLayer> vacuateLayer = this->vacuateLayers_[i];
 
 
-		if (mapLayerThinning->IsCurrentLayer(dx))
+		if (vacuateLayer->IsCurrentLayer(dx))
 		{
 		{
-			return mapLayerThinning;
+			return vacuateLayer;
 		}
 		}
 	}
 	}
 	return nullptr;
 	return nullptr;

@@ -15,7 +15,7 @@
 #include "dmpmaplayer.h"
 #include "dmpmaplayer.h"
 #include "dmpwkbtypes.h"
 #include "dmpwkbtypes.h"
 #include "dmpvectordataprovider.h"
 #include "dmpvectordataprovider.h"
-#include "dmpvectorthinlayer.h"
+#include "dmpvectorvacuatelayer.h"
 #include "Renderer.h"
 #include "Renderer.h"
 #include <vector>
 #include <vector>
 
 
@@ -50,12 +50,14 @@ class CORE_EXPORT DmpVectorLayer : public DmpMapLayer
     void setRenderer(DmpFeatureRenderer *renderer);
     void setRenderer(DmpFeatureRenderer *renderer);
     void setDataSource(const std::string &dataSource, const std::string &baseName, const std::string &provider, bool loadDefaultStyleFlag);
     void setDataSource(const std::string &dataSource, const std::string &baseName, const std::string &provider, bool loadDefaultStyleFlag);
     DmpWkbTypes::GeometryType GeometryType() const;
     DmpWkbTypes::GeometryType GeometryType() const;
+    DmpWkbTypes::Type GeomWkbType() const{ return wkbType_;}
     bool setDataProvider(std::string const &provider);
     bool setDataProvider(std::string const &provider);
    
    
 
 
     shared_ptr<DmapCore_30::Renderer> GetRenderer30() { return renderer_30_; }
     shared_ptr<DmapCore_30::Renderer> GetRenderer30() { return renderer_30_; }
-    vector<shared_ptr<DmpVectorThinLayer>> thinLayers() const { return thinLayers_; }
-    shared_ptr<DmpVectorThinLayer> GetCurrentScaleTable(double dx);
+    vector<shared_ptr<DmpVectorVacuateLayer>> vacuateLayers() const { return vacuateLayers_; }
+    shared_ptr<DmpVectorVacuateLayer> GetCurrentScaleTable(double dx);
+    void ApplendCurrentScaleTable(shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer);
 
 
     std::string  schema() { return schema_;}
     std::string  schema() { return schema_;}
     std::string  geom()  { return geom_;} 
     std::string  geom()  { return geom_;} 
@@ -64,6 +66,8 @@ class CORE_EXPORT DmpVectorLayer : public DmpMapLayer
     std::string  srid(){return  srid_;}
     std::string  srid(){return  srid_;}
     size_t featurecount(){return featurecount_;}
     size_t featurecount(){return featurecount_;}
     bool IsInit(){return isinit_;}
     bool IsInit(){return isinit_;}
+
+    void  setSrid(string srid){ srid_ = srid;}
   private:
   private:
     bool readExtentFromXml_;
     bool readExtentFromXml_;
     DmpWkbTypes::Type wkbType_ = DmpWkbTypes::Unknown;
     DmpWkbTypes::Type wkbType_ = DmpWkbTypes::Unknown;
@@ -79,9 +83,9 @@ class CORE_EXPORT DmpVectorLayer : public DmpMapLayer
     std::string wherestr_;
     std::string wherestr_;
     bool isinit_ = false;
     bool isinit_ = false;
     shared_ptr<DmapCore_30::Renderer> renderer_30_ = nullptr;
     shared_ptr<DmapCore_30::Renderer> renderer_30_ = nullptr;
-    vector<shared_ptr<DmpVectorThinLayer>> thinLayers_;
+    vector<shared_ptr<DmpVectorVacuateLayer>> vacuateLayers_;
+
 
 
-    
     
     
 };
 };
 #endif //__dmpvectorlayer_h__
 #endif //__dmpvectorlayer_h__

 /**************************************************************************
 /**************************************************************************
-* file:              dmpvectorthinlayer.cpp
+* file:              dmpvectorvacuatelayer.cpp
 
 
 * Author:            qingxiongf
 * Author:            qingxiongf
 * Date:              2021-12-13 10:05:35
 * Date:              2021-12-13 10:05:35
 * Email:             qingxiongf@chinadci.com
 * Email:             qingxiongf@chinadci.com
 * copyright:         广州城市信息研究所有限公司
 * copyright:         广州城市信息研究所有限公司
 ***************************************************************************/
 ***************************************************************************/
-#include "dmpvectorthinlayer.h"
+#include "dmpvectorvacuatelayer.h"
 
 
-DmpVectorThinLayer::DmpVectorThinLayer(/* args */)
+DmpVectorVacuateLayer::DmpVectorVacuateLayer(/* args */)
 {
 {
-        
+    
 }
 }
     
     
-DmpVectorThinLayer::~DmpVectorThinLayer()
+DmpVectorVacuateLayer::~DmpVectorVacuateLayer()
 {
 {
 
 
 }
 }
 
 
- bool DmpVectorThinLayer::IsCurrentLayer(double d)
+bool DmpVectorVacuateLayer::IsCurrentLayer(double d)
 {
 {
     if(d > m_ddis)
     if(d > m_ddis)
     {
     {
@@ -27,21 +27,22 @@ DmpVectorThinLayer::~DmpVectorThinLayer()
     return false;
     return false;
 }
 }
 
 
-bool  DmpVectorThinLayer::Init(double minX, double minY, double maxX, double maxY, int dxCount, int dyCount,std::string tableName)
-{         
-    m_ddis = std::max( (maxX - minX)/ dxCount, (maxY - minY)/ dyCount);
-    m_tableName = tableName; 
-    return true;
-}
+ std::shared_ptr<DmpVectorVacuateLayer> DmpVectorVacuateLayer::clone()
+ {
+    std::shared_ptr<DmpVectorVacuateLayer> vacuateLayer(new DmpVectorVacuateLayer(*this));
+     return vacuateLayer;
+ }
+
 
 
-bool  DmpVectorThinLayer::Init(double dis,std::string tableName)
+bool  DmpVectorVacuateLayer::Init(double dis,  const std::string& tableName, const std::string& connectstr)
 {
 {
     m_ddis =dis;
     m_ddis =dis;
     m_tableName = tableName; 
     m_tableName = tableName; 
+    connectstr_ = connectstr;
     return true;
     return true;
 }
 }
 
 
-double DmpVectorThinLayer::GeDisPix()
+double DmpVectorVacuateLayer::GeDisPix()
 {
 {
    return this->m_ddis;
    return this->m_ddis;
 }
 }

 /**************************************************************************
 /**************************************************************************
-* file:              dmpvectorthinlayer.h
+* file:              dmpvectorvacuatelayer.h
 
 
 * Author:            qingxiongf
 * Author:            qingxiongf
 * Date:              2021-12-13 10:05:42
 * Date:              2021-12-13 10:05:42
@@ -7,33 +7,35 @@
 * copyright:         广州城市信息研究所有限公司
 * copyright:         广州城市信息研究所有限公司
 ***************************************************************************/
 ***************************************************************************/
 
 
-#ifndef __dmpvectorthinlayer_h__
-#define __dmpvectorthinlayer_h__
+#ifndef __dmpvectorvacuatelayer_h__
+#define __dmpvectorvacuatelayer_h__
 
 
 #include "dmap_core.h"
 #include "dmap_core.h"
 #include <string>
 #include <string>
+#include <memory>
 
 
-class CORE_EXPORT DmpVectorThinLayer 
+class CORE_EXPORT DmpVectorVacuateLayer 
 {
 {
     public:
     public:
-        DmpVectorThinLayer(/* args */);
+        DmpVectorVacuateLayer(/* args */);
 
 
-        ~DmpVectorThinLayer();
+        ~DmpVectorVacuateLayer();
 
 
         bool IsCurrentLayer(double d);
         bool IsCurrentLayer(double d);
 
 
-        bool  Init(double minX, double minY,
-                   double maxX, double maxY,
-                   int dxCount, int dyCount,
-                   std::string tableName);
 
 
-       bool  Init(double minX, 
-                   std::string tableName);
+       bool  Init(double dis,  const std::string& tableName, const std::string& connectstr);
+
+       std::shared_ptr<DmpVectorVacuateLayer> clone();
 
 
        double GeDisPix();
        double GeDisPix();
 
 
+       double dis() const { return m_ddis; }
+
        std::string tableName()const { return m_tableName;}
        std::string tableName()const { return m_tableName;}
 
 
+       std::string connectStr() const {return connectstr_;}
+
     private:
     private:
        int m_indexLevel;
        int m_indexLevel;
        int m_dataCount;
        int m_dataCount;
@@ -44,6 +46,7 @@ class CORE_EXPORT DmpVectorThinLayer
 	   double m_ddis;
 	   double m_ddis;
        std::string m_tableName;
        std::string m_tableName;
        std::string polygon_area = "geodmap_area"; 
        std::string polygon_area = "geodmap_area"; 
+       std::string connectstr_ = "";
 };
 };
 
 
-#endif // __dmpvectorthinlayer_h__
+#endif // __dmpvectorvacuatelayer_h__

@@ -33,6 +33,24 @@ void DmpRectangle::normalize()
     }
     }
 }
 }
 
 
+void DmpRectangle::merge(DmpRectangle &rectangle)
+{
+    if(xmin_ == 0 && ymin_ ==0 && xmax_ ==0 && ymax_ ==0 )
+    {
+       this->xmin_ = rectangle.xmin();
+       this->ymin_ = rectangle.ymin();
+       this->xmax_ = rectangle.xmax();
+       this->ymax_ = rectangle.ymax();
+    }
+    else
+    {
+        if(rectangle.xmin() < this->xmin_ ) this->xmin_ = rectangle.xmin();
+        if(rectangle.ymin() < this->ymin_ ) this->ymin_ = rectangle.ymin();
+        if(rectangle.xmax() > this->xmax_ ) this->xmax_ = rectangle.xmax();
+        if(rectangle.ymax() < this->ymax_ ) this->ymax_ = rectangle.ymax();
+    }
+}
+
 
 
 bool DmpRectangle::isNull() 
 bool DmpRectangle::isNull() 
 {
 {

@@ -38,6 +38,13 @@ class CORE_EXPORT DmpRectangle
     double width() const  { return xmax_ - xmin_; }
     double width() const  { return xmax_ - xmin_; }
     double height() const { return ymax_ - ymin_; }
     double height() const { return ymax_ - ymin_; }
 
 
+    void setXmax(double xmax){xmax_ = xmax; }
+    void setYmax(double ymax){ymax_ = ymax; }
+    void setXmin(double xmin){xmin_ = xmin; }
+    void setYmin(double ymin){ymin_ = ymin; }
+
+    void merge(DmpRectangle &rectangle);
+
  private:
  private:
     double xmin_ = 0.0;
     double xmin_ = 0.0;
     double ymin_ = 0.0;
     double ymin_ = 0.0;

@@ -12,7 +12,7 @@ namespace DmapCore_30
 
 
 	SimpleLineSymbol::SimpleLineSymbol()
 	SimpleLineSymbol::SimpleLineSymbol()
 	{
 	{
-		m_iAntialiasing = CAIRO_ANTIALIAS_DEFAULT;
+		m_iAntialiasing =  CAIRO_ANTIALIAS_FAST;
 		m_iColor = clsUtil::RandomColor();
 		m_iColor = clsUtil::RandomColor();
 		clsUtil::ToCairoColor(m_iColor, r, g, b, a);
 		clsUtil::ToCairoColor(m_iColor, r, g, b, a);
 		//m_pClsSurfBackup =	NULL;
 		//m_pClsSurfBackup =	NULL;

@@ -12,7 +12,7 @@ namespace DmapCore_30
 {
 {
 	SimpleMarkerSymbol::SimpleMarkerSymbol()
 	SimpleMarkerSymbol::SimpleMarkerSymbol()
 	{
 	{
-		m_iAntialiasing = CAIRO_ANTIALIAS_DEFAULT;
+		m_iAntialiasing = CAIRO_ANTIALIAS_FAST;
 		m_bBoundary = true;
 		m_bBoundary = true;
 		m_iColor = clsUtil::RandomColor();
 		m_iColor = clsUtil::RandomColor();
 		clsUtil::ToCairoColor(m_iColor, r, g, b, a);
 		clsUtil::ToCairoColor(m_iColor, r, g, b, a);

@@ -12,7 +12,7 @@ namespace DmapCore_30
 {
 {
 	SimplePolygonSymbol::SimplePolygonSymbol()
 	SimplePolygonSymbol::SimplePolygonSymbol()
 	{
 	{
-		m_iAntialiasing = CAIRO_ANTIALIAS_DEFAULT;
+		m_iAntialiasing = CAIRO_ANTIALIAS_FAST;
 		m_iBackgroundColor = clsUtil::RandomColor();
 		m_iBackgroundColor = clsUtil::RandomColor();
 		clsUtil::ToCairoColor(m_iBackgroundColor, r, g, b, a);
 		clsUtil::ToCairoColor(m_iBackgroundColor, r, g, b, a);
 		m_iLineType = 0;
 		m_iLineType = 0;

@@ -116,25 +116,24 @@ namespace DmapCore_30
 		
 		
 		clsPtree::PtreeAttrParse("glowing", ptRenderer, m_bGlowing);
 		clsPtree::PtreeAttrParse("glowing", ptRenderer, m_bGlowing);
 		if (m_bGlowing)
 		if (m_bGlowing)
-		 	clsPtree::PtreeAttrParseColor("glowingcolor", "glowingtransparency", ptRenderer, m_iBGColor);
+		 	clsPtree::PtreeAttrParseColor("glowingcolor", "glowingtransparency", ptRenderer, m_iGlowingColor);
 		
 		
 
 
-		clsPtree::PtreeAttrParse("shadow", ptRenderer, m_bGlowing);
-		if (m_bGlowing)
+		clsPtree::PtreeAttrParse("shadow", ptRenderer, m_bShadow);
+		if (m_bShadow)
 		 	clsPtree::PtreeAttrParseColor("shadowcolor", "shadowtransparency", ptRenderer, m_iShadowColor);
 		 	clsPtree::PtreeAttrParseColor("shadowcolor", "shadowtransparency", ptRenderer, m_iShadowColor);
 
 
 		pt.add_child("TEXTSYMBOL",ptRenderer);
 		pt.add_child("TEXTSYMBOL",ptRenderer);
 		return true;
 		return true;
 	}
 	}
 
 
-	void  TextSymbol::ToJson(AppendBuffer *ab)
+   void  TextSymbol::ToJson(AppendBuffer *ab)
    {
    {
 	   char buff[300] = {0};
 	   char buff[300] = {0};
 	   char resultbuff[5000] ={0};
 	   char resultbuff[5000] ={0};
 		sprintf(resultbuff, R"("TEXTSYMBOL":{"antialiasing":"antialias_default",)");
 		sprintf(resultbuff, R"("TEXTSYMBOL":{"antialiasing":"antialias_default",)");
 		clsJson::JsonAttrParse("font", resultbuff, buff, this->m_sFont);
 		clsJson::JsonAttrParse("font", resultbuff, buff, this->m_sFont);
 		clsJson::JsonAttrParse("fontsize", resultbuff, buff, this->m_iFontSize);
 		clsJson::JsonAttrParse("fontsize", resultbuff, buff, this->m_iFontSize);
-		//
 		clsJson::JsonAttrParseColor("fontcolor", "fonttransparency", resultbuff, buff, m_iFontColor);
 		clsJson::JsonAttrParseColor("fontcolor", "fonttransparency", resultbuff, buff, m_iFontColor);
 		clsJson::JsonAttrParse("x_dis", resultbuff, buff, this->m_dXdis);
 		clsJson::JsonAttrParse("x_dis", resultbuff, buff, this->m_dXdis);
 		clsJson::JsonAttrParse("y_dis", resultbuff, buff, this->m_dYdis);
 		clsJson::JsonAttrParse("y_dis", resultbuff, buff, this->m_dYdis);
@@ -147,11 +146,11 @@ namespace DmapCore_30
 		
 		
 		clsJson::JsonAttrParse("glowing", resultbuff, buff, m_bGlowing);
 		clsJson::JsonAttrParse("glowing", resultbuff, buff, m_bGlowing);
 		if (m_bGlowing)
 		if (m_bGlowing)
-		 	clsJson::JsonAttrParseColor("glowingcolor", "glowingtransparency", resultbuff, buff, m_iBGColor);
+		 	clsJson::JsonAttrParseColor("glowingcolor", "glowingtransparency", resultbuff, buff, m_iGlowingColor);
 		
 		
 
 
-		clsJson::JsonAttrParse("shadow", resultbuff, buff, m_bGlowing);
-		if (m_bGlowing)
+		clsJson::JsonAttrParse("shadow", resultbuff, buff, m_bShadow);
+		if (m_bShadow)
 		 	clsJson::JsonAttrParseColor("shadowcolor", "shadowtransparency", resultbuff, buff, m_iShadowColor);
 		 	clsJson::JsonAttrParseColor("shadowcolor", "shadowtransparency", resultbuff, buff, m_iShadowColor);
 
 
 		clsJson::JsonAttrEnd(resultbuff);
 		clsJson::JsonAttrEnd(resultbuff);
@@ -317,16 +316,21 @@ namespace DmapCore_30
 		x += m_dXdis;
 		x += m_dXdis;
 		y += m_dYdis;
 		y += m_dYdis;
 		cairo_t* cr = pClsCS->m_pCr;
 		cairo_t* cr = pClsCS->m_pCr;
-		//cairo_font_options_set_antialias(cfo, CAIRO_ANTIALIAS_GRAY);
+		//cairo_font_options_set_antialias(cr, CAIRO_ANTIALIAS_BEST);
 		cairo_text_extents(cr, sUTF8, m_pCrExtents);
 		cairo_text_extents(cr, sUTF8, m_pCrExtents);
 		int iX = (int)x;                          int iY = (int)y;
 		int iX = (int)x;                          int iY = (int)y;
 		int iTextW = (int)(m_pCrExtents->x_advance);  int iTextH = (int)(m_pCrExtents->height);
 		int iTextW = (int)(m_pCrExtents->x_advance);  int iTextH = (int)(m_pCrExtents->height);
 		//int surf_w = pClsCS->m_iW;                int surf_h = pClsCS->m_iH;
 		//int surf_w = pClsCS->m_iW;                int surf_h = pClsCS->m_iH;
+  
+        //文字被截取
+		if(iX < 0 || (iX + iTextW) > pClsCS->m_iW  || (iY - iTextH )  < 0 || iY > pClsCS->m_iH) 
+		{
+			return false;
+		}
 
 
 		/*
 		/*
 		文字避让部分
 		文字避让部分
 		*/
 		*/
-
 		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 		int xFrom = iX / gridsize;
 		int xFrom = iX / gridsize;
 		int xTo = (iX + iTextW) / gridsize;
 		int xTo = (iX + iTextW) / gridsize;
@@ -372,6 +376,10 @@ namespace DmapCore_30
 				//if (pFlag[iFlagW*i + j])	return false;
 				//if (pFlag[iFlagW*i + j])	return false;
 			}
 			}
 		}
 		}
+
+		//文字截取部分
+
+
 		//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 		//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
 
 

@@ -8,7 +8,7 @@ namespace DmapCore_30
 	{
 	{
 		m_pSurf = surface;
 		m_pSurf = surface;
 		m_pCr = cairo_create(m_pSurf);
 		m_pCr = cairo_create(m_pSurf);
-		//cairo_set_antialias(m_pCr,cairo_antialias_t::CAIRO_ANTIALIAS_BEST);
+		cairo_set_antialias(m_pCr,cairo_antialias_t::CAIRO_ANTIALIAS_BEST);
 		m_iN = 1;
 		m_iN = 1;
 		m_iW = cairo_image_surface_get_width(surface);
 		m_iW = cairo_image_surface_get_width(surface);
 		m_iH = cairo_image_surface_get_height(surface);
 		m_iH = cairo_image_surface_get_height(surface);

 #ifndef _clsMalloc_H_
 #ifndef _clsMalloc_H_
 #define _clsMalloc_H_
 #define _clsMalloc_H_
+
+#include "dmap_core.h"
+#include "stdio.h"
+#include <string>
 namespace DmapCore_30
 namespace DmapCore_30
 {
 {
-	class clsMalloc
+	class CORE_EXPORT clsMalloc
 	{
 	{
 	public:
 	public:
 		clsMalloc();
 		clsMalloc();

@@ -287,7 +287,7 @@ namespace DmapCore_30
     //CAIRO_ANTIALIAS_FAST,
     //CAIRO_ANTIALIAS_FAST,
    // CAIRO_ANTIALIAS_GOOD,
    // CAIRO_ANTIALIAS_GOOD,
   //  CAIRO_ANTIALIAS_BEST
   //  CAIRO_ANTIALIAS_BEST
-	    cairo_set_antialias(cr,CAIRO_ANTIALIAS_FAST);
+	   cairo_set_antialias(cr,CAIRO_ANTIALIAS_FAST);
 		return true;
 		return true;
 		switch (iAntialias)
 		switch (iAntialias)
 		{
 		{

@@ -30,7 +30,7 @@ namespace DmapCore_30
 
 
     bool legendParamater::next(char * title)
     bool legendParamater::next(char * title)
     {
     {
-        if(index/row_maxsize>  current_Col_Index)
+        if( row_maxsize >0  && index/row_maxsize > current_Col_Index)
         {
         {
               current_Col_Index ++;
               current_Col_Index ++;
               pixXIndex = 10 + (current_Col_Index *100);
               pixXIndex = 10 + (current_Col_Index *100);

@@ -57,7 +57,7 @@ public:
 		{
 		{
 			return;
 			return;
 		}
 		}
-        
+       // printf("%s\r\n", szRequest);
 		
 		
 		DmpSpServerRequest dmpRequest(request);
 		DmpSpServerRequest dmpRequest(request);
 		DmpSpServerResponse dmpResponse(response);
 		DmpSpServerResponse dmpResponse(response);
@@ -116,7 +116,7 @@ public:
 
 
 int main(int argc, char *argv[])
 int main(int argc, char *argv[])
 {
 {
-	int port = 8088, maxThreads = 10;
+	int port = 8820, maxThreads = 10;
 	const char *serverType = "lf";
 	const char *serverType = "lf";
 #ifndef WIN32
 #ifndef WIN32
 	extern char *optarg;
 	extern char *optarg;

 [MetaData]
 [MetaData]
 pgsqlConnect="hostaddr=localhost port=5432 dbname='dmap_dms' user='postgres' password='chinadci'"
 pgsqlConnect="hostaddr=localhost port=5432 dbname='dmap_dms' user='postgres' password='chinadci'"
-metaUrl=http://172.26.60.100:8841/
+metaUrl=http://172.26.60.101:8840/

@@ -44,19 +44,19 @@ DmpServerManager::~DmpServerManager()
             delete mapProject;
             delete mapProject;
             mapProject = nullptr;
             mapProject = nullptr;
         }
         }
-    } 
+    }
     projects_.clear();
     projects_.clear();
 }
 }
 
 
 void DmpServerManager::init(const boost::filesystem::path &modulePath)
 void DmpServerManager::init(const boost::filesystem::path &modulePath)
 {
 {
     serverRegistry_->init(modulePath);
     serverRegistry_->init(modulePath);
-    if(!loadServices())
+    if (!loadServices())
     {
     {
         std::cout << "加载服务失败!" << std::endl;
         std::cout << "加载服务失败!" << std::endl;
         LOGGER_ERROR("加载服务失败!");
         LOGGER_ERROR("加载服务失败!");
     }
     }
-    //LoadDmpServices();
+    // LoadDmpServices();
 }
 }
 
 
 std::string DmpServerManager::getCapabilities()
 std::string DmpServerManager::getCapabilities()
@@ -106,9 +106,9 @@ bool DmpServerManager::removeProject(const std::string &serviceName)
     return true;
     return true;
 }
 }
 
 
-bool DmpServerManager::publish(const std::string& serverName, const std::string& serviceName, const std::string& title, int capabilities, const std::string& projectData)
+bool DmpServerManager::publish(const std::string &serverName, const std::string &serviceName, const std::string &title, int capabilities, const std::string &projectData)
 {
 {
-    //project
+    // project
     std::string projData;
     std::string projData;
     if (!DmpServerUtils::Base64Decode(projectData, &projData))
     if (!DmpServerUtils::Base64Decode(projectData, &projData))
     {
     {
@@ -121,13 +121,16 @@ bool DmpServerManager::publish(const std::string& serverName, const std::string&
         return false;
         return false;
     }
     }
 
 
+    project->initVectorLayerVacuate([](const std::string &tableguid)
+                                    { return DmpHttp::get(DmpServerConfig::Instance()->getMetaUrl() + URL_VACUATE + tableguid); });
+
     if (!serverRegistry_->getServer(serverName)->publish(serviceName, title, capabilities, *project))
     if (!serverRegistry_->getServer(serverName)->publish(serviceName, title, capabilities, *project))
     {
     {
         delete project;
         delete project;
         return false;
         return false;
     }
     }
     projects_[serviceName] = project;
     projects_[serviceName] = project;
-    
+
     return true;
     return true;
 }
 }
 
 
@@ -154,36 +157,46 @@ bool DmpServerManager::stopService(const std::string &serverName, const std::str
 }
 }
 bool DmpServerManager::loadServices()
 bool DmpServerManager::loadServices()
 {
 {
-    boost::property_tree::ptree pt,ptList;
-    std::string conn = DmpServerConfig::Instance()->getMetaUrl();
-    const std::string url= conn + URI_RELOAD;
-    std::string strContent=DmpHttp::get(url);
-    if(strContent.length()==0)
-    {
-        return false;
-    }
-    std::stringstream ssData;
-    ssData<<strContent.c_str();
-    boost::property_tree::read_json(ssData, pt);
-    int iCount = std::atoi(pt.get<std::string>("data.count").c_str());
-    if(iCount>0)
+    std::string strContent;
+    try
     {
     {
-        ptList=pt.get_child("data.list");
-        for (auto& e : ptList) 
+        boost::property_tree::ptree pt, ptList;
+        std::string conn = DmpServerConfig::Instance()->getMetaUrl();
+        const std::string url = conn + URI_RELOAD;
+         strContent = DmpHttp::get(url);
+        if (strContent.length() == 0)
+        {
+            return false;
+        }
+        std::stringstream ssData;
+        ssData << strContent.c_str();
+        boost::property_tree::read_json(ssData, pt);
+        int iCount = std::atoi(pt.get<std::string>("data.count").c_str());
+        if (iCount > 0)
         {
         {
-            std::string name = e.second.get<std::string>("name");
-            std::string title = e.second.get<std::string>("title");
-            std::string type = e.second.get<std::string>("type");
-            int capabilities =e.second.get<int>("capabilities");
-            std::string project = e.second.get<std::string>("project");
-            this->initServices(type,name,title,capabilities,project);
+            ptList = pt.get_child("data.list");
+            for (auto &e : ptList)
+            {
+                std::string name = e.second.get<std::string>("name");
+                std::string title = e.second.get<std::string>("title");
+                std::string type = e.second.get<std::string>("type");
+                int capabilities = e.second.get<int>("capabilities");
+                std::string project = e.second.get<std::string>("project");
+                this->initServices(type, name, title, capabilities, project);
+            }
         }
         }
     }
     }
+    catch(const std::exception& e)
+    {
+        std::cerr << e.what() <<  strContent.c_str() << '\n';
+        return false;
+    }
+
     return true;
     return true;
 }
 }
-bool DmpServerManager::initServices(const std::string& serverName, const std::string& serviceName, const std::string& title, int capabilities, const std::string& projectData)
+bool DmpServerManager::initServices(const std::string &serverName, const std::string &serviceName, const std::string &title, int capabilities, const std::string &projectData)
 {
 {
-    //project
+    // project
     std::string projData;
     std::string projData;
     if (!DmpServerUtils::Base64Decode(projectData, &projData))
     if (!DmpServerUtils::Base64Decode(projectData, &projData))
     {
     {
@@ -196,12 +209,14 @@ bool DmpServerManager::initServices(const std::string& serverName, const std::st
         return false;
         return false;
     }
     }
 
 
+    project->initVectorLayerVacuate([](const std::string &tableguid)
+                                    { return DmpHttp::get(DmpServerConfig::Instance()->getMetaUrl() + URL_VACUATE + tableguid); });
+
     if (!serverRegistry_->getServer(serverName)->publish(serviceName, title, capabilities, *project))
     if (!serverRegistry_->getServer(serverName)->publish(serviceName, title, capabilities, *project))
     {
     {
         delete project;
         delete project;
         return false;
         return false;
     }
     }
-    projects_[serviceName] = project;  
+    projects_[serviceName] = project;
     return true;
     return true;
-
 }
 }

@@ -20,7 +20,8 @@
 #include "dmpserverregistry.h"
 #include "dmpserverregistry.h"
 
 
 
 
-#define URI_RELOAD    ("/API/Service/Reload")       //加载已注册服务接口     
+#define URI_RELOAD    ("/API/Service/Reload")       //加载已注册服务接口 
+#define URL_VACUATE   ("/API/Manager/TableVacuateDetail?table_guids=")  //加载矢量数据抽稀图层
 class SERVER_EXPORT DmpServerManager
 class SERVER_EXPORT DmpServerManager
 {
 {
 public:
 public:

@@ -8,6 +8,7 @@ SET (MAPSERVER_SRCS
   dmppgsql.cpp
   dmppgsql.cpp
   dmppgsqlpool.cpp
   dmppgsqlpool.cpp
   dmppgsqlsourcepools.cpp
   dmppgsqlsourcepools.cpp
+  dmpgeometry.cpp
   wfs/dmpwfs.cpp
   wfs/dmpwfs.cpp
   wfs/dmpwfsfilter.cpp
   wfs/dmpwfsfilter.cpp
   wfs/dmpgmlfilter.cpp
   wfs/dmpgmlfilter.cpp
@@ -20,9 +21,18 @@ SET (MAPSERVER_SRCS
   wms/dmpwmsparameters.cpp
   wms/dmpwmsparameters.cpp
   wms/dmpwmsgetcapabilities.cpp
   wms/dmpwmsgetcapabilities.cpp
   wms/dmpwmsgetmap.cpp
   wms/dmpwmsgetmap.cpp
+  wms/dmpwmsgetprint.cpp
   wms/dmpwmsserviceinfo.cpp
   wms/dmpwmsserviceinfo.cpp
   wms/dmpwmsgetfeatureinfo.cpp
   wms/dmpwmsgetfeatureinfo.cpp
-  wms/dmpprint.cpp
+  wms/print/dmpmapprint.cpp
+  wms/print/dmpprintlayer.cpp
+  wms/print/dmpprinttext.cpp
+  wms/print/dmpprintrect.cpp
+  wms/print/dmpprintscale.cpp
+  wms/print/dmpprintcompass.cpp
+  wms/print/dmpprintlayout.cpp
+  wms/print/dmpprintparameter.cpp
+  wms/print/dmpprintwmsservice.cpp
   mapping/dmpmapping.cpp
   mapping/dmpmapping.cpp
   mapping/dmpeditservice.cpp
   mapping/dmpeditservice.cpp
   mapping/dmpmappingparameters.cpp
   mapping/dmpmappingparameters.cpp
@@ -35,6 +45,7 @@ SET (MAPSERVER_HDRS
   dmppgsql.h
   dmppgsql.h
   dmppgsqlpool.h
   dmppgsqlpool.h
   dmppgsqlsourcepools.h
   dmppgsqlsourcepools.h
+  dmpgeometry.h
   wfs/dmpwfs.h
   wfs/dmpwfs.h
   wfs/dmpwfsfilter.h
   wfs/dmpwfsfilter.h
   wfs/dmpgmlfilter.h
   wfs/dmpgmlfilter.h
@@ -47,9 +58,18 @@ SET (MAPSERVER_HDRS
   wms/dmpwmsparameters.h
   wms/dmpwmsparameters.h
   wms/dmpwmsgetcapabilities.h
   wms/dmpwmsgetcapabilities.h
   wms/dmpwmsgetmap.h
   wms/dmpwmsgetmap.h
+  wms/dmpwmsgetprint.h
   wms/dmpwmsserviceinfo.h
   wms/dmpwmsserviceinfo.h
   wms/dmpwmsgetfeatureinfo.h
   wms/dmpwmsgetfeatureinfo.h
-  wms/dmpprint.h
+  wms/print/dmpmapprint.h
+  wms/print/dmpprintlayer.h
+  wms/print/dmpprinttext.h
+  wms/print/dmpprintrect.h
+  wms/print/dmpprintscale.h
+  wms/print/dmpprintcompass.h
+  wms/print/dmpprintlayout.h
+  wms/print/dmpprintparameter.h
+  wms/print/dmpprintwmsservice.h
   mapping/dmpmapping.h
   mapping/dmpmapping.h
   mapping/dmpeditservice.h
   mapping/dmpeditservice.h
   mapping/dmpmappingparameters.h
   mapping/dmpmappingparameters.h

+/**************************************************************************
+* file:              DmpGeometry.cpp
+
+* Author:            qingxiongf
+* Date:              2022-02-22 10:13:27
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "DmpGeometry.h"
+#include <iostream>
+#include <string.h>
+#include <sstream>
+
+namespace mapserver 
+{
+    std::string DmpGeometry::geoJsonfromWKB(const char* wkb)
+    {
+        unsigned char* pwkb = (unsigned char*)wkb;
+        unsigned char hasZorSrsid = ((unsigned char *)(pwkb + 4))[0] / 16;
+       
+        unsigned char type = ((unsigned char *)(pwkb + 1))[0];
+        this->hasZ_ = hasZorSrsid / 8;
+		this->hasSrid_ = hasZorSrsid % 8;
+
+        
+		 notbig_ = this->ReadByte(pwkb);
+		int shape = this->ReadInt(pwkb, notbig_);
+		if (hasSrid_)
+		{
+			srid_ = this->ReadInt(pwkb, notbig_);
+		}
+
+        std::stringstream sstream;
+
+        switch (type)
+        {
+        case  DmpWkbTypes::Type::Point:
+       // case  DmpWkbTypes::Type::PointZ:
+       // case  DmpWkbTypes::Type::PointM:
+       // case  DmpWkbTypes::Type::PointZM:
+        {
+            sstream << R"({"type":"Point","coordinates": [)";
+            readPointfromWKB(pwkb,sstream);
+            break;
+        }
+           
+        
+        case  DmpWkbTypes::Type::MultiPoint:
+       // case  DmpWkbTypes::Type::MultiPointZ:
+       // case  DmpWkbTypes::Type::MultiPointM:
+       // case  DmpWkbTypes::Type::MultiPointZM:
+         {
+            sstream << R"({"type":"MultiPoint","coordinates": [)";
+            int nPoint = this->ReadInt(pwkb, notbig_);
+            for (int j = 0; j < nPoint; j++)
+		    {
+			   pwkb += 5; 
+               if(j>0) sstream << ",";
+               readPointfromWKB(pwkb,sstream);
+            }
+            break;
+         }
+
+        case  DmpWkbTypes::Type::LineString:
+       // case  DmpWkbTypes::Type::LineStringZ:
+       // case  DmpWkbTypes::Type::LineStringM:
+       // case  DmpWkbTypes::Type::LineStringZM:
+        {
+            sstream << R"({"type":"LineString","coordinates": [)";
+            readLinefromWKB(pwkb,sstream);
+            break;
+        }
+          
+
+        case  DmpWkbTypes::Type::MultiLineString:
+      //  case  DmpWkbTypes::Type::MultiLineStringZ:
+      //  case  DmpWkbTypes::Type::MultiLineStringM:
+       // case  DmpWkbTypes::Type::MultiLineStringZM:
+        {
+            sstream << R"({"type":"MultiLineString","coordinates": [)";
+            int nLine = this->ReadInt(pwkb, notbig_);
+            for (int j = 0; j < nLine; j++)
+		    {
+			   pwkb += 5; 
+               if(j>0) sstream << ",";
+               readLinefromWKB(pwkb,sstream);
+            }
+            break;
+        }
+
+        case  DmpWkbTypes::Type::Polygon:
+       // case  DmpWkbTypes::Type::PolygonZ:
+      //  case  DmpWkbTypes::Type::PolygonM:
+       // case  DmpWkbTypes::Type::PolygonZM:
+        {
+            sstream << R"({"type":"Polygon","coordinates": [)";
+            readPolygonfromWKB(pwkb,sstream);
+            break;
+        }  
+
+        case  DmpWkbTypes::Type::MultiPolygon:
+      //  case  DmpWkbTypes::Type::MultiPolygonZ:
+      //  case  DmpWkbTypes::Type::MultiPolygonM:
+      //  case  DmpWkbTypes::Type::MultiPolygonZM:
+        {
+            sstream << R"({"type":"MultiPolygon","coordinates": [)";
+            int nPolygon = this->ReadInt(pwkb, notbig_);
+            for (int j = 0; j < nPolygon; j++)
+		    {
+			   pwkb += 5; 
+               if(j>0) sstream << ",";
+               readPolygonfromWKB(pwkb,sstream);
+            }
+            break;
+        }
+
+        default:
+            break;
+        }
+       
+        sstream << "]}";
+
+        return sstream.str();;
+    }
+
+    bool DmpGeometry::readPointfromWKB(unsigned char*& pwkb, stringstream& sstream )
+    {
+        double xx = this->ReadDouble(pwkb,notbig_);
+        double yy = this->ReadDouble(pwkb,notbig_);
+       
+       // sprintf(buff, "[%.6f,%.6f]" ,xx,yy);
+        sstream << "[" << ToDoubleStr(xx) << "," << ToDoubleStr(yy) << "]";
+
+        if(hasZ_)
+        {
+            pwkb += 8;
+            // double zz = this->ReadDouble(pwkb,notbig_);
+        }
+        return true;
+    }
+
+     char* DmpGeometry::ToDoubleStr(double value)
+     {
+        int len = sprintf(buff, "%.6f" ,value);
+        for ( len --; len >0; len--)
+        {
+            if(buff[len] == '0')
+            {
+                buff[len] = 0;
+            }
+            else if(buff[len] == '.')
+            {
+                buff[len] = 0;
+                break;
+            }
+            else
+            {
+                break;
+            }
+        }
+        
+         return buff;
+
+     }
+
+    bool DmpGeometry::readLinefromWKB(unsigned  char*& pwkb, stringstream& sstream)
+    {
+        int nPoint = this->ReadInt(pwkb, notbig_);
+        sstream << "[";
+        for (size_t i = 0; i < nPoint; i++)
+        {
+           if(i>0) sstream << ",";
+           readPointfromWKB(pwkb, sstream);
+        }
+        sstream <<  "]";
+        
+        return true;
+    }
+
+    bool DmpGeometry::readPolygonfromWKB(unsigned  char*& pwkb, stringstream& sstream)
+    {
+        int nline = this->ReadInt(pwkb, notbig_);
+        sstream << "[";
+        for (size_t i = 0; i < nline; i++)
+        {
+           if(i>0) sstream << ",";
+           readLinefromWKB(pwkb, sstream);
+        }
+        sstream <<  "]";
+        
+        return true;
+    }
+
+    
+
+int DmpGeometry::ReadInt(unsigned char*& here, int  not_big1)
+{
+    unsigned char * mem = (unsigned char *)malloc(4);
+	memcpy(mem, here, 4);
+	if (!not_big1)
+		this->Exchange4(mem);
+	int num = ((int*)mem)[0];
+    free(mem);
+	here += 4;
+	return num;
+}
+int DmpGeometry::ReadByte(unsigned char*& here)
+{
+	int num = ((char*)here)[0];
+	here++;
+	return num;
+}
+
+double DmpGeometry::ReadDouble(unsigned char*& here, int not_big)
+{
+	//DmapCore_30::clsMalloc clsM(8);
+    unsigned char * mem = (unsigned char *)malloc(8);
+	memcpy(mem, here, 8);
+	if (!not_big)
+		Exchange8(mem);
+	double num = ((double*)mem)[0];
+    free(mem);
+	here += 8;
+	return num;
+}
+
+bool DmpGeometry::Exchange4(unsigned char * here)
+{
+	unsigned char temp;
+	for (int i = 0; i < 2; i++)
+	{
+		temp = here[i];
+		here[i] = here[3 - i];
+		here[3 - i] = temp;
+	}
+	return true;
+}
+
+bool DmpGeometry::Exchange8(unsigned char * here)
+{
+	unsigned char temp;
+	for (int i = 0; i < 4; i++)
+	{
+		temp = here[i];
+		here[i] = here[7 - i];
+		here[7 - i] = temp;
+	}
+	return true;
+}
+
+
+}
+

+/**************************************************************************
+* file:              DmpGeometry.h
+
+* Author:            qingxiongf
+* Date:              2022-02-22 10:07:04
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __DmpGeometry_h__
+#define __DmpGeometry_h__
+#include <geometry/dmpwkbtypes.h>
+#include <string>
+using namespace std;
+namespace mapserver 
+{
+    class DmpGeometry
+    {
+          /* data */
+    public:
+       // DmpGeometry(/* args */);
+       // ~DmpGeometry();
+
+       // static DmpGeometry geometryfromWKT(const char* wkt);
+
+         std::string geoJsonfromWKB(const char* wkb);
+
+         bool readPointfromWKB(unsigned char*& pwkb, stringstream& outstream);
+         bool readLinefromWKB(unsigned char*& pwkb, stringstream& outstream);
+         bool readPolygonfromWKB(unsigned char*& pwkb, stringstream& outstream);
+
+       // static string geoJsonfromWKT(const char* wkt);
+    private:
+        int ReadInt(unsigned char*& pwkb, int  not_big1);
+        double ReadDouble(unsigned char*& pwkb, int  not_big1);
+        int ReadByte(unsigned char*& pwkb);
+        bool Exchange4(unsigned char* pwkb);
+        bool Exchange8(unsigned char* pwkb);
+
+        char* ToDoubleStr(double value);
+    private:
+        int srid_;
+        bool hasZ_;
+        bool hasSrid_;
+        int   notbig_;
+
+        DmpWkbTypes::Type type_;
+        char buff[100];
+  
+    };
+
+}
+
+#endif // __DmpGeometry_h__

@@ -12,12 +12,29 @@
 #include <ostream>
 #include <ostream>
 #include <string>
 #include <string>
 #include <boost/asio.hpp>
 #include <boost/asio.hpp>
-
+#include "dmpgeometry.h"
 using boost::asio::ip::tcp;
 using boost::asio::ip::tcp;
 
 
 namespace mapserver
 namespace mapserver
 {
 {
 
 
+	void DmpMapServerUtil::initVectorLayerSrid(shared_ptr<DmpPgsql> pPgsqlConn,DmpVectorLayer* layer)
+	{
+		if(layer->srid().empty())
+		{
+			string name = layer->name();
+			string sql = "select  t.f_geometry_column shapeField, t.type ,f_table_schema,t.srid from public.geometry_columns t where lower( t.f_table_name) = lower('"+ name +"');";
+		    if(pPgsqlConn->ExecWait(sql))
+			{
+				string geom = pPgsqlConn->getString(0);
+				string value = pPgsqlConn->getString( 1);
+				string strSchema = pPgsqlConn->getString(2);
+			    string srid = pPgsqlConn->getString(3);
+				layer->setSrid(srid);
+			}
+		}
+	}
+
 	void DmpMapServerUtil::responseGml(shared_ptr<DmpPgsql> pPgsqlConn, std::string &responseData, const string &layerName, const std::string &srid)
 	void DmpMapServerUtil::responseGml(shared_ptr<DmpPgsql> pPgsqlConn, std::string &responseData, const string &layerName, const std::string &srid)
 	{
 	{
 
 
@@ -39,17 +56,9 @@ namespace mapserver
 			int fieldsCount = pPgsqlConn->GetFieldCount();
 			int fieldsCount = pPgsqlConn->GetFieldCount();
 			for (; pPgsqlConn->next();)
 			for (; pPgsqlConn->next();)
 			{
 			{
-				//	css++;
-				//if(css!=24)continue;
-				//break;
-				//string geometry = "";
-				//string properties = "";
 				responseData.append("<gims:featureMember>");
 				responseData.append("<gims:featureMember>");
 				sprintf(buff, "<gims:%s fid=\"%s.%d\">", layerName.c_str(), layerName.c_str(), count + 1);
 				sprintf(buff, "<gims:%s fid=\"%s.%d\">", layerName.c_str(), layerName.c_str(), count + 1);
 				responseData.append(buff);
 				responseData.append(buff);
-				//responseData.append("\r\n");
-
-				//columns[md[ i ].getString(MetaData::ATTR_NAME)] = i;
 				for (int i = 0; i < fieldsCount; i++)
 				for (int i = 0; i < fieldsCount; i++)
 				{
 				{
 					const char *sfieldName = pPgsqlConn->GetFieldName(i); //pPgsqlConn->field_name[i].c_str();
 					const char *sfieldName = pPgsqlConn->GetFieldName(i); //pPgsqlConn->field_name[i].c_str();
@@ -60,7 +69,7 @@ namespace mapserver
 					if (strncmp(sfieldName, "RN_RN", 5) == 0)
 					if (strncmp(sfieldName, "RN_RN", 5) == 0)
 						continue;
 						continue;
 					std::string strFieldName = sfieldName;
 					std::string strFieldName = sfieldName;
-					//DmapDll::StringHelp::ToXMLString(strFieldName);
+					//DmapDll::StringHelp::ToXMLString(strFieldName); 
 
 
 					if (strFieldName == "geometry_as_gml")
 					if (strFieldName == "geometry_as_gml")
 					{
 					{
@@ -77,8 +86,6 @@ namespace mapserver
 						responseData.append(buff);
 						responseData.append(buff);
 					}
 					}
 				}
 				}
-				//tickAA=GetTickCount();
-
 				sprintf(buff, "</gims:%s>\r", layerName.c_str());
 				sprintf(buff, "</gims:%s>\r", layerName.c_str());
 				responseData.append(buff);
 				responseData.append(buff);
 				responseData.append("</gims:featureMember>");
 				responseData.append("</gims:featureMember>");
@@ -88,17 +95,11 @@ namespace mapserver
 
 
 				if (pointCountTemp > 2000)
 				if (pointCountTemp > 2000)
 					break;
 					break;
-				//Sleep(5000);
-				//	break;
 			}
 			}
 		}
 		}
 		catch (...)
 		catch (...)
 		{
 		{
 		}
 		}
-
-		//sprintf(buff, "numberMatched=\"%ld\" numberReturned=\"%ld\" ", count, count);
-		//responseData.append(insertBuf, sql, strlen(sql));
-
 		responseData.append("</wfs:FeatureCollection>");
 		responseData.append("</wfs:FeatureCollection>");
 
 
 		return;
 		return;
@@ -148,10 +149,17 @@ namespace mapserver
 						geometry = pPgsqlConn->getString(i);
 						geometry = pPgsqlConn->getString(i);
 						continue;
 						continue;
 					}
 					}
+					else if(strFieldName == "geometry_as_wkb")
+					{
+						DmpGeometry dmpgeometry;
+						geometry = dmpgeometry.geoJsonfromWKB(pPgsqlConn->getString(i));
+						continue;
+					}
 					else
 					else
 					{
 					{
-						const char *v = pPgsqlConn->getString(i);
-						std::sprintf(buff, R"(,"%s":"%s")", sfieldName, v);
+						string value = pPgsqlConn->getString(i);
+						DmpMapServerUtil::toJsonString(value);
+						std::sprintf(buff, R"(,"%s":"%s")", sfieldName, value.c_str());
 						properties += buff;
 						properties += buff;
 					}
 					}
 				}
 				}
@@ -518,7 +526,7 @@ namespace mapserver
 
 
 		for (i = 0; i < strlen(cd); i++)
 		for (i = 0; i < strlen(cd); i++)
 		{
 		{
-			memset(p, '/0', 2);
+			memset(p, '\0', 2);
 			if (cd[i] != '%')
 			if (cd[i] != '%')
 			{
 			{
 				decd[j++] = cd[i];
 				decd[j++] = cd[i];
@@ -532,7 +540,7 @@ namespace mapserver
 			p[1] = p[1] - 48 - ((p[1] >= 'A') ? 7 : 0) - ((p[1] >= 'a') ? 32 : 0);
 			p[1] = p[1] - 48 - ((p[1] >= 'A') ? 7 : 0) - ((p[1] >= 'a') ? 32 : 0);
 			decd[j++] = (unsigned char)(p[0] * 16 + p[1]);
 			decd[j++] = (unsigned char)(p[0] * 16 + p[1]);
 		}
 		}
-		decd[j] = '/0';
+		decd[j] = '\0';
 
 
 		return decd;
 		return decd;
 	}
 	}

@@ -13,13 +13,16 @@
 #include <string>
 #include <string>
 #include <memory>
 #include <memory>
 #include "dmppgsqlsourcepools.h"
 #include "dmppgsqlsourcepools.h"
-
+#include "dmpproject.h"
+#include "dmpvectorlayer.h"
 
 
 namespace mapserver 
 namespace mapserver 
 {
 {
     class DmpMapServerUtil
     class DmpMapServerUtil
     {
     {
     public:
     public:
+        static void initVectorLayerSrid(shared_ptr<DmpPgsql> pPgsqlConn,DmpVectorLayer* layer);
+
         static void responseGeojson(shared_ptr<DmpPgsql> pPgsqlConn, std::string &responseData,const string& layerName,const std::string &srid);
         static void responseGeojson(shared_ptr<DmpPgsql> pPgsqlConn, std::string &responseData,const string& layerName,const std::string &srid);
         static void responseGml(shared_ptr<DmpPgsql> pPgsqlConn, std::string &responseData,const string& layerName,const std::string &srid);
         static void responseGml(shared_ptr<DmpPgsql> pPgsqlConn, std::string &responseData,const string& layerName,const std::string &srid);
         static void toXmlString(std::string &s);
         static void toXmlString(std::string &s);

@@ -454,9 +454,14 @@ namespace mapserver
 
 
     bool DmpPgsqlSourcePools::AddDatabasePool(string guid)
     bool DmpPgsqlSourcePools::AddDatabasePool(string guid)
     {
     {
-        if (guid.find(" ") != string::npos && guid.size() > 50)
+        if (guid.find(" ") != string::npos || guid.size() > 100)
         {
         {
-            std::string connStr = guid;
+           std::string connStr = guid;
+            if(connStr.find(" ") == string::npos)
+            {
+                connStr  =  DmpServerDes::DesBase64Decrypt(connStr, "Chinadci");
+            }
+            
             shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool(guid,guid,guid));
             shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool(guid,guid,guid));
             newPool->Connect(connStr.c_str());
             newPool->Connect(connStr.c_str());
             //newPool->Connect("PostgreSQLConn=hostaddr=172.26.99.173 port=5433 dbname='postgres' user='postgres' password='chinadci'");
             //newPool->Connect("PostgreSQLConn=hostaddr=172.26.99.173 port=5433 dbname='postgres' user='postgres' password='chinadci'");

@@ -48,8 +48,8 @@ namespace DmpMapping
 
 
             std::string guid  = pt.get<std::string>("guid");
             std::string guid  = pt.get<std::string>("guid");
             
             
-            DmpProject* project = (DmpProject*)context.serverProject()->project();
-            std::string projectData = project->WriteXml();
+            DmpProject* projectold = (DmpProject*)context.serverProject()->project();
+            std::string projectData = projectold->WriteXml();
            // printf("%s\r\n",projectData.c_str());
            // printf("%s\r\n",projectData.c_str());
             if(!guid.empty() && !projectData.empty())
             if(!guid.empty() && !projectData.empty())
             {
             {
@@ -60,6 +60,9 @@ namespace DmpMapping
                     context.response()->writeJson("{\"status\":\"false\",\"message\":\"加载DMD符号化失败!\"}");
                     context.response()->writeJson("{\"status\":\"false\",\"message\":\"加载DMD符号化失败!\"}");
                     return false;
                     return false;
                 }
                 }
+
+                project->initVectorLayerVacuate(projectold);
+
                 vectorMappingProjects[guid] = project;
                 vectorMappingProjects[guid] = project;
 
 
             //    int i = 0;
             //    int i = 0;
@@ -137,7 +140,7 @@ namespace DmpMapping
     bool loadProjectService(const DmpServerContext &context,ProjectMap& vectorMappingProjects)
     bool loadProjectService(const DmpServerContext &context,ProjectMap& vectorMappingProjects)
     {
     {
         const char *data = (char *)(context.request()->GetData());
         const char *data = (char *)(context.request()->GetData());
-        if(data== nullptr ||  *data == '\0') 
+        if(data== nullptr ||  *data == '\0'  || context.request()->method() != DmpServerRequest::Method::POST_METHOD) 
         {
         {
              LOGGER_ERROR("post 参数错误");
              LOGGER_ERROR("post 参数错误");
              context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误!\"}");
              context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误!\"}");
@@ -166,31 +169,36 @@ namespace DmpMapping
                     context.response()->writeJson("{\"status\":\"false\",\"message\":\"DMD文档错误\"}");
                     context.response()->writeJson("{\"status\":\"false\",\"message\":\"DMD文档错误\"}");
                     return false;
                     return false;
                 }
                 }
-                vectorMappingProjects[guid] =  project;
-                
-                double minx, miny, maxx, maxy;
-                std::vector<DmpMapLayer *> vectorLayers = project->vectorLayers();
-                for (size_t i = 0; i < vectorLayers.size(); i++)
-                {
-                    DmpMapLayer *layer = vectorLayers[i];
-                    if (i == 0)
-                    {
-                        minx = layer->extent().xmin();
-                        miny = layer->extent().ymin();
-                        maxx = layer->extent().xmax();
-                        maxy = layer->extent().ymax();
-                    }
-                    else
+                project->initVectorLayerVacuate([](const std::string &tableguid)
+                 {
+                   return DmpServerConfig::Instance()->HttpGet( DmpServerConfig::Instance()->getMetaUrl() +  URL_VACUATE + tableguid);
+                 });
+
+                    vectorMappingProjects[guid] = project;
+
+                    double minx, miny, maxx, maxy;
+                    std::vector<DmpMapLayer *> vectorLayers = project->vectorLayers();
+                    for (size_t i = 0; i < vectorLayers.size(); i++)
                     {
                     {
-                        if (minx > layer->extent().xmin())
+                        DmpMapLayer *layer = vectorLayers[i];
+                        if (i == 0)
+                        {
                             minx = layer->extent().xmin();
                             minx = layer->extent().xmin();
-                        if (miny > layer->extent().ymin())
                             miny = layer->extent().ymin();
                             miny = layer->extent().ymin();
-                        if (maxx < layer->extent().xmax())
                             maxx = layer->extent().xmax();
                             maxx = layer->extent().xmax();
-                        if (maxy < layer->extent().ymax())
                             maxy = layer->extent().ymax();
                             maxy = layer->extent().ymax();
-                    }
+                        }
+                        else
+                        {
+                            if (minx > layer->extent().xmin())
+                                minx = layer->extent().xmin();
+                            if (miny > layer->extent().ymin())
+                                miny = layer->extent().ymin();
+                            if (maxx < layer->extent().xmax())
+                                maxx = layer->extent().xmax();
+                            if (maxy < layer->extent().ymax())
+                                maxy = layer->extent().ymax();
+                        }
                 }
                 }
                 
                 
                 char buff[250];
                 char buff[250];
@@ -242,7 +250,7 @@ namespace DmpMapping
     bool editService(const DmpServerContext &context,ProjectMap& vectorMappingProjects)
     bool editService(const DmpServerContext &context,ProjectMap& vectorMappingProjects)
     {
     {
         const char *data = (char *)(context.request()->GetData());
         const char *data = (char *)(context.request()->GetData());
-        if(data== nullptr ||  *data == '\0') 
+        if(data== nullptr ||  *data == '\0'  || context.request()->method() != DmpServerRequest::Method::POST_METHOD) 
         {
         {
              LOGGER_ERROR("post 参数错误");
              LOGGER_ERROR("post 参数错误");
              context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误!\"}");
              context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误!\"}");
@@ -271,6 +279,10 @@ namespace DmpMapping
                     context.response()->writeJson("{\"status\":\"false\",\"message\":\"DMD文档错误\"}");
                     context.response()->writeJson("{\"status\":\"false\",\"message\":\"DMD文档错误\"}");
                     return false;
                     return false;
                 }
                 }
+                project->initVectorLayerVacuate([](const std::string &tableguid)
+                                {
+                                        return DmpServerConfig::Instance()->HttpGet(DmpServerConfig::Instance()->getMetaUrl() + URL_VACUATE + tableguid);
+                                });
                 vectorMappingProjects[guid] =  project;
                 vectorMappingProjects[guid] =  project;
                 context.response()->writeJson("{\"status\":\"true\",\"message\":\"创建编辑服务工作空间成功!\"}");
                 context.response()->writeJson("{\"status\":\"true\",\"message\":\"创建编辑服务工作空间成功!\"}");
                 return true;
                 return true;

@@ -15,6 +15,7 @@
 #include "dmpproject.h"
 #include "dmpproject.h"
 #include "dmpservercontext.h"
 #include "dmpservercontext.h"
 #include "dmppgsqlsourcepools.h"
 #include "dmppgsqlsourcepools.h"
+#include "dmpservermanager.h"
 
 
 namespace DmpMapping
 namespace DmpMapping
 {
 {

@@ -19,7 +19,6 @@
 #include "../wms/dmpwmsgetmap.h"
 #include "../wms/dmpwmsgetmap.h"
 #include "../wms/dmpwmsparameters.h"
 #include "../wms/dmpwmsparameters.h"
 #include "dmpmapping.h"
 #include "dmpmapping.h"
-#include "dmpmappingparameters.h"
 #include "dmpimageinfo.h"
 #include "dmpimageinfo.h"
 
 
 using namespace std;
 using namespace std;
@@ -71,19 +70,38 @@ namespace DmpMapping
        getImage(context);
        getImage(context);
     }
     }
     else if(boost::iequals(request, "getmaplog")){
     else if(boost::iequals(request, "getmaplog")){
-      const std::string mapGuid = params.MapGuid();
+       getmaplog(context,params);
+    }
+    else if (boost::iequals(request, "getmap"))
+    {
+       getmap(context,params);
+    }
+    else
+    {
+      std::string responseData = "{\"result\":\"false\",\"message\":\"配图服务未实现" + request + "接口\"}";
+			context.response()->writeJson(responseData);
+    }
+   
+  }
+
+   bool DmpMappingService::getmaplog(const DmpServerContext &context,const DmpMappingParameters& params)
+    {
+        const std::string mapGuid = params.MapGuid();
       if (vectorMappingProjects_.find(mapGuid) != vectorMappingProjects_.end())
       if (vectorMappingProjects_.find(mapGuid) != vectorMappingProjects_.end())
       {
       {
         shared_ptr<DmpProject> project = vectorMappingProjects_.find(mapGuid)->second;
         shared_ptr<DmpProject> project = vectorMappingProjects_.find(mapGuid)->second;
         const DmpWms::DmpWmsParameters wmsParams(context.request()->serverParameters());
         const DmpWms::DmpWmsParameters wmsParams(context.request()->serverParameters());
         DmpWms::writeGetMapLog(context, wmsParams, project.get());
         DmpWms::writeGetMapLog(context, wmsParams, project.get());
+         return true;
       }
       }
       else
       else
       {
       {
           context.response()->writeJson("{\"status\":\"false\",\"message\":\"未找到服务\"}");
           context.response()->writeJson("{\"status\":\"false\",\"message\":\"未找到服务\"}");
+          return false;
       }
       }
     }
     }
-    else if (boost::iequals(request, "getmap"))
+
+    bool DmpMappingService::getmap(const DmpServerContext &context,const DmpMappingParameters& params)
     {
     {
       const std::string mapGuid = params.MapGuid();
       const std::string mapGuid = params.MapGuid();
       if (vectorMappingProjects_.find(mapGuid) != vectorMappingProjects_.end())
       if (vectorMappingProjects_.find(mapGuid) != vectorMappingProjects_.end())
@@ -91,6 +109,7 @@ namespace DmpMapping
         shared_ptr<DmpProject> project = vectorMappingProjects_.find(mapGuid)->second;
         shared_ptr<DmpProject> project = vectorMappingProjects_.find(mapGuid)->second;
         const DmpWms::DmpWmsParameters wmsParams(context.request()->serverParameters());
         const DmpWms::DmpWmsParameters wmsParams(context.request()->serverParameters());
         DmpWms::writeGetMap(context, wmsParams, project.get());
         DmpWms::writeGetMap(context, wmsParams, project.get());
+        return true;
       }
       }
       else
       else
       {
       {
@@ -114,27 +133,31 @@ namespace DmpMapping
             if (!DmpServerUtils::Base64Decode(mapRenderer, &projData))
             if (!DmpServerUtils::Base64Decode(mapRenderer, &projData))
             {
             {
               context.response()->writeJson("{\"status\":\"false\",\"message\":\""+ mapRenderer +"  base64转码错误\"}");
               context.response()->writeJson("{\"status\":\"false\",\"message\":\""+ mapRenderer +"  base64转码错误\"}");
-              return;
+              return false;
             }
             }
             shared_ptr<DmpProject> project(new DmpProject());
             shared_ptr<DmpProject> project(new DmpProject());
             if (!project->Read(projData))
             if (!project->Read(projData))
             {
             {
               context.response()->writeJson("{\"status\":\"false\",\"message\":\"DMD文档错误\"}");
               context.response()->writeJson("{\"status\":\"false\",\"message\":\"DMD文档错误\"}");
-              return;
+              return false;
             }
             }
+            project->initVectorLayerVacuate([](const std::string &tableguid)
+                 {
+                   return DmpServerConfig::Instance()->HttpGet( DmpServerConfig::Instance()->getMetaUrl() +  URL_VACUATE + tableguid);
+                 });
             const DmpWms::DmpWmsParameters wmsParams(context.request()->serverParameters());
             const DmpWms::DmpWmsParameters wmsParams(context.request()->serverParameters());
             DmpWms::writeGetMap(context, wmsParams, project.get());
             DmpWms::writeGetMap(context, wmsParams, project.get());
             if(!mapGuid.empty())
             if(!mapGuid.empty())
             {
             {
               vectorMappingProjects_[mapGuid] = project;
               vectorMappingProjects_[mapGuid] = project;
             }
             }
-            return;
+            return true;
           }
           }
         }
         }
       }
       }
+
+       return false;
     }
     }
-   
-  }
 
 
 
 
 
 

@@ -10,11 +10,13 @@
 #define __dmpmapping_h__
 #define __dmpmapping_h__
 #include <string>
 #include <string>
 #include <string>
 #include <string>
-#include "dmpeditservice.h"
-#include "dmpservice.h"
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread.hpp>
 #include <boost/thread.hpp>
 
 
+#include "dmpeditservice.h"
+#include "dmpservice.h"
+#include "dmpmappingparameters.h"
+
 typedef boost::shared_mutex rwmutex;
 typedef boost::shared_mutex rwmutex;
 typedef boost::shared_lock<rwmutex> readLock;
 typedef boost::shared_lock<rwmutex> readLock;
 typedef boost::unique_lock<rwmutex> writeLock;
 typedef boost::unique_lock<rwmutex> writeLock;
@@ -31,6 +33,9 @@ namespace DmpMapping
         bool allowMethod(DmpServerRequest::Method method) const override { return method == DmpServerRequest::GET_METHOD; }
         bool allowMethod(DmpServerRequest::Method method) const override { return method == DmpServerRequest::GET_METHOD; }
         void executeRequest(const DmpServerContext &context) override;
         void executeRequest(const DmpServerContext &context) override;
     private:
     private:
+        bool getmaplog(const DmpServerContext &context,const DmpMappingParameters& params);
+        bool getmap(const DmpServerContext &context, const DmpMappingParameters& params);
+    private:
        
        
     //存储工程文档实例
     //存储工程文档实例
        ProjectMap vectorMappingProjects_;
        ProjectMap vectorMappingProjects_;

@@ -56,6 +56,11 @@ namespace DmpWfs
       {
       {
          writeGetFeature(context,params, project);
          writeGetFeature(context,params, project);
       } 
       } 
+      else
+      {
+          std::string responseData = "{\"result\":\"false\",\"message\":\"WFS 未实现" + request + "接口\"}";
+			    context.response()->writeJson(responseData);
+      }
   }
   }
 }
 }
 
 

@@ -23,7 +23,31 @@ namespace DmpWfs
 						 const DmpProject *project,
 						 const DmpProject *project,
 						 bool projectSettings)
 						 bool projectSettings)
 	{
 	{
-		WfsGetFeature(context, params, project, projectSettings);
+		std::string errorinfo = WfsGetFeature(context, params, project, projectSettings);
+		if(!errorinfo.empty())
+		{
+			DmpWfsParameters::Format resultType = params.ResultType();
+			if (resultType == DmpWfsParameters::Format::GeoJson)
+			{
+				std::string responseData;
+			    responseData = "{\"result\":\"false\",\"message\":\"" + errorinfo + "\"}";
+			    context.response()->writeJson(responseData);
+			}
+			else
+			{
+				boost::property_tree::ptree ptreeDoc;
+				boost::property_tree::ptree ptreeRoot;
+				ptreeRoot.add<bool>("result", false);
+				ptreeRoot.add<std::string>("message", errorinfo);
+				ptreeDoc.add_child("WfsGetfeatureResponse",ptreeRoot);
+				std::stringstream stream; 
+   				write_xml(stream, ptreeDoc);
+   				std::string responseData = stream.str();
+			    context.response()->removeHeader("Content-Type");
+    			context.response()->setHeader("Content-Type", "text/xml;charset=utf-8");
+    			context.response()->write(responseData);
+			}
+		}
 	}
 	}
 
 
 	std::string WfsGetFeature(const DmpServerContext &context, const DmpWfsParameters &params,
 	std::string WfsGetFeature(const DmpServerContext &context, const DmpWfsParameters &params,
@@ -287,7 +311,7 @@ namespace DmpWfs
 						typeInt = PGFieldType::ShapeFieldType;
 						typeInt = PGFieldType::ShapeFieldType;
 						if (format == DmpWfsParameters::Format::GeoJson)
 						if (format == DmpWfsParameters::Format::GeoJson)
 						{
 						{
-							fields_str += " st_asgeojson(\"" + (fieldname) + "\") as geometry_as_geojson";
+							fields_str += " \"" + (fieldname) + "\" as geometry_as_wkb";
 						}
 						}
 						else
 						else
 						{
 						{

-/**************************************************************************
-* file:              dmpprint.cpp
-
-* Author:            qingxiongf
-* Date:              2022-01-20 18:50:40
-* Email:             qingxiongf@chinadci.com
-* copyright:         广州城市信息研究所有限公司
-***************************************************************************/
-#include "dmpprint.h"
-

@@ -21,6 +21,7 @@
 #include "dmpwmsgetmap.h"
 #include "dmpwmsgetmap.h"
 #include "dmpwmsserviceinfo.h"
 #include "dmpwmsserviceinfo.h"
 #include "dmpwmsgetfeatureinfo.h"
 #include "dmpwmsgetfeatureinfo.h"
+#include "dmpwmsgetprint.h"
 using namespace std;
 using namespace std;
 
 
 namespace DmpWms
 namespace DmpWms
@@ -40,6 +41,7 @@ namespace DmpWms
       const DmpWmsParameters params(context.request()->serverParameters());
       const DmpWmsParameters params(context.request()->serverParameters());
       const DmpProject* project = context.serverProject()->project();
       const DmpProject* project = context.serverProject()->project();
       const std::string request = params.Request();
       const std::string request = params.Request();
+   // printf("%s\r\n", request.c_str());
       if (request.empty())
       if (request.empty())
       {
       {
          context.response()->writeHtml("wms,Operation is null");
          context.response()->writeHtml("wms,Operation is null");
@@ -66,12 +68,21 @@ namespace DmpWms
       } 
       } 
       else if(boost::iequals(request, "getserviceinfo"))
       else if(boost::iequals(request, "getserviceinfo"))
       {
       {
-         writeGetServiceInfo(context,params, project);
+          writeGetServiceInfo(context,params, project);
       }
       }
-      else if(request == "getlegendgraphic")
+      else if(boost::iequals(request, "getlegendgraphic"))
       {
       {
           
           
       }
       }
+      else if(boost::iequals(request, "getprint"))
+      {
+          writeGetPrint(context,params, project);
+      }
+      else
+      {
+          std::string responseData = "{\"result\":\"false\",\"message\":\"WMS 未实现" + request + "接口\"}";
+			    context.response()->writeJson(responseData);
+      }
   }
   }
 } 
 } 
 
 

+/**************************************************************************
+* file:              dmpwmsgetprint.cpp
+
+* Author:            qingxiongf
+* Date:              2022-02-10 14:18:07
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpwmsgetprint.h"
+#include "print/dmpmapprint.h"
+#include "dmpwmsrenderer.h"
+#include "dmpserverresponse.h"
+#include "dmpserverrequest.h"
+#include "dmpserverproject.h"
+#include <map>
+#include <memory>
+namespace DmpWms
+{
+ void writeGetPrint(const DmpServerContext &context,const DmpWmsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings )
+    {
+        DmpWmsParameters::Format outformat = params.ResFormat();
+        DmpMapPrint mapPrint(outformat);
+
+        std::string responseData;
+       
+        std::string name = context.serverProject()->name();
+        std::string title = context.serverProject()->title();
+        std::string boxx = params.BBox();
+        std::string printTemp = params.printTemp();
+        std::string printPara =  params.printPara();
+
+        if(mapPrint.getPrintTempFile(responseData,project,printTemp.c_str(),boxx.c_str(),printPara.c_str()))
+        {
+            if(outformat == DmpWmsParameters::Format::PDF)
+            {
+                 context.response()->setHeader("Content-Type", "application/pdf");
+            }
+            else if(outformat == DmpWmsParameters::Format::SVG)
+            {
+                 context.response()->setHeader("Content-Type", "image/svg");
+            }
+            else
+            {
+                 context.response()->setHeader("Content-Type", "image/png");
+            }
+        }
+        else
+        {
+             context.response()->setHeader("Content-Type", "text/xml");
+        }
+
+        context.response()->write(responseData);
+    }
+
+    void writeGetPrintParaList(const DmpServerContext &context,const DmpWmsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings)
+     {
+
+     }
+}

+/**************************************************************************
+* file:              dmpwmsgetprint.h
+
+* Author:            qingxiongf
+* Date:              2022-02-10 14:17:58
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpwmsgetprint_h__
+#define __dmpwmsgetprint_h__
+
+
+#include <boost/property_tree/ptree.hpp> 
+#include <boost/property_tree/xml_parser.hpp> 
+#include <boost/typeof/typeof.hpp>
+#include <memory>
+#include <vector>
+#include "dmpproject.h"
+#include "dmpwmsparameters.h"
+#include "dmpservercontext.h"
+
+namespace DmpWms
+{
+    void writeGetPrint(const DmpServerContext &context,const DmpWmsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings = false );
+}
+
+#endif // __dmpwmsgetprint_h__

@@ -169,6 +169,20 @@ namespace DmpWms
         return value;
         return value;
     }
     }
 
 
+    std::string  DmpWmsParameters::printTemp() const
+    {
+        std::string value = "";
+        GetStringParameter("PRINTTEMP",value);
+        return value;
+    }
+
+    std::string  DmpWmsParameters::printPara() const
+    {
+        std::string value = "";
+        GetStringParameter("PRINTPARA",value);
+        return value;
+    }
+
     DmpWmsParameters::Format DmpWmsParameters::InfoFormat() const
     DmpWmsParameters::Format DmpWmsParameters::InfoFormat() const
     {
     {
         std::string value = "";
         std::string value = "";
@@ -241,6 +255,16 @@ namespace DmpWms
             if (frm.compare("jpg") == 0 || frm.compare("jpeg") == 0 || frm.compare("image/jpeg") == 0 ) {
             if (frm.compare("jpg") == 0 || frm.compare("jpeg") == 0 || frm.compare("image/jpeg") == 0 ) {
               f = DmpWmsParameters::Format::JPG;
               f = DmpWmsParameters::Format::JPG;
             }
             }
+            else if(frm.compare("pdf") == 0){
+               f = DmpWmsParameters::Format::PDF;
+            }else if(frm.compare("svg") == 0){
+               f = DmpWmsParameters::Format::SVG;
+            }else if(frm.compare("xml") == 0 || frm.compare("gml") == 0){
+               f = DmpWmsParameters::Format::GML;
+            }else if(frm.compare("json") == 0 || frm.compare("geojson") == 0){
+               f = DmpWmsParameters::Format::GeoJson;
+            }
+
             return f;
             return f;
         }
         }
         return DmpWmsParameters::Format::NONE;
         return DmpWmsParameters::Format::NONE;

@@ -25,7 +25,9 @@ namespace DmpWms
             XML,
             XML,
             HTML,
             HTML,
             GML,
             GML,
-            GeoJson
+            GeoJson,
+            PDF,
+            SVG
         };
         };
         DmpWmsParameters(const DmpServerParameters &parameters);
         DmpWmsParameters(const DmpServerParameters &parameters);
         DmpWmsParameters();
         DmpWmsParameters();
@@ -59,6 +61,10 @@ namespace DmpWms
         int Y() const; //地图上查询点的Y坐标，以像素为单位。0是左侧。j是WMS 1.3.0中使用的参数键。
         int Y() const; //地图上查询点的Y坐标，以像素为单位。0是左侧。j是WMS 1.3.0中使用的参数键。
         
         
         DmpWmsParameters::Format ResFormat() const; //GetMap URL为Format   GetFeatureInfo url为:info_format
         DmpWmsParameters::Format ResFormat() const; //GetMap URL为Format   GetFeatureInfo url为:info_format
+
+        std::string printTemp() const;
+
+        std::string printPara() const;
     private:
     private:
         bool GetStringParameter(const char* key, std::string &value) const;
         bool GetStringParameter(const char* key, std::string &value) const;
         bool GetIntParameter(const char* key, int& value) const;
         bool GetIntParameter(const char* key, int& value) const;

@@ -149,11 +149,11 @@ namespace DmpWms
 
 
 		string tableName = layer->name(); //layer->name();
 		string tableName = layer->name(); //layer->name();
 		string shapeName = layer->geom();
 		string shapeName = layer->geom();
-		shared_ptr<DmpVectorThinLayer> pVectorThinLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
+		shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
 
 
-		if (pVectorThinLayer != nullptr)
+		if (pVectorVacuateLayer != nullptr)
 		{
 		{
-			tableName = pVectorThinLayer->tableName();
+			tableName = pVectorVacuateLayer->tableName();
 		}
 		}
 
 
 		ss += " FROM \"%s\".\"%s\" "; // 这个 %s 是tableName
 		ss += " FROM \"%s\".\"%s\" "; // 这个 %s 是tableName
@@ -173,6 +173,25 @@ namespace DmpWms
 		//ss += " limit 40000 ";
 		//ss += " limit 40000 ";
 
 
 		double t = pRect->m_dTop, r = pRect->m_dRight, b = pRect->m_dBottom, l = pRect->m_dLeft;
 		double t = pRect->m_dTop, r = pRect->m_dRight, b = pRect->m_dBottom, l = pRect->m_dLeft;
+		//点 标注 避免被截取
+		if(layer->GeometryType() == DmpWkbTypes::GeometryType::PointGeometry)
+		{  
+			double drh =  (pRect->m_dTop -  pRect->m_dBottom)/this->m_dHeight;
+			double drw =  (pRect->m_dRight -  pRect->m_dLeft)/this->m_dWidth;
+			t = t + drh * 15;
+			b = b - drh * 15;
+			if(length > 0)
+			{
+				l = l - drw * 30;
+				r = r + drw * 20;
+			}
+			else
+			{
+				l = l - drw * 15;
+				r = r + drw * 15;
+			}
+		}
+	
 		std::string sql = format(ss.c_str(), shapeName.c_str(), layer->schema().c_str(), tableName.c_str(), shapeName.c_str(), l, b, r, t);
 		std::string sql = format(ss.c_str(), shapeName.c_str(), layer->schema().c_str(), tableName.c_str(), shapeName.c_str(), l, b, r, t);
 		//printf("%s\r\n",sql.c_str());
 		//printf("%s\r\n",sql.c_str());
 		return sql;
 		return sql;
@@ -207,11 +226,11 @@ namespace DmpWms
 
 
 				string tableName = layer->name(); //layer->name();
 				string tableName = layer->name(); //layer->name();
 				string shapeName = layer->geom();
 				string shapeName = layer->geom();
-				shared_ptr<DmpVectorThinLayer> pVectorThinLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
+				shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
 
 
-				if (pVectorThinLayer != nullptr)
+				if (pVectorVacuateLayer != nullptr)
 				{
 				{
-					tableName = pVectorThinLayer->tableName();
+					tableName = pVectorVacuateLayer->tableName();
 				}
 				}
 
 
 				ss += " FROM \"%s\".\"%s\"  "; // 这个 %s 是tableName
 				ss += " FROM \"%s\".\"%s\"  "; // 这个 %s 是tableName
@@ -294,11 +313,11 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 
 
 				string tableName = layer->name(); //layer->name();
 				string tableName = layer->name(); //layer->name();
 				string shapeName = layer->geom();
 				string shapeName = layer->geom();
-				shared_ptr<DmpVectorThinLayer> pVectorThinLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
+				shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
 
 
-				if (pVectorThinLayer != nullptr)
+				if (pVectorVacuateLayer != nullptr)
 				{
 				{
-					tableName = pVectorThinLayer->tableName();
+					tableName = pVectorVacuateLayer->tableName();
 				}
 				}
 
 
 				ss += " FROM \"%s\".\"%s\"  ";																   // 这个 %s 是tableName
 				ss += " FROM \"%s\".\"%s\"  ";																   // 这个 %s 是tableName
@@ -332,7 +351,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 		return "";
 		return "";
 	}
 	}
 
 
-	string DmpWmsRenderer::GetDrawSQLAll_Catch(DmpVectorLayer *layer, shared_ptr<DmpVectorThinLayer> pVectorThinLayer)
+	string DmpWmsRenderer::GetDrawSQLAll_Catch(DmpVectorLayer *layer, shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer)
 	{
 	{
 		if (layer == 0 || layer->geom().size() == 0)
 		if (layer == 0 || layer->geom().size() == 0)
 			return "";
 			return "";
@@ -363,9 +382,9 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 		}
 		}
 
 
 		string tableName = layer->name();
 		string tableName = layer->name();
-		if (pVectorThinLayer != nullptr)
+		if (pVectorVacuateLayer != nullptr)
 		{
 		{
-			tableName = pVectorThinLayer->tableName();
+			tableName = pVectorVacuateLayer->tableName();
 		}
 		}
 
 
 		string shapeName = layer->geom();
 		string shapeName = layer->geom();
@@ -470,9 +489,9 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 		string tableName = layer->name();
 		string tableName = layer->name();
 		string shapeName = layer->geom();
 		string shapeName = layer->geom();
 
 
-		if (layer->thinLayers().size() > 0)
+		if (layer->vacuateLayers().size() > 0)
 		{
 		{
-			tableName = layer->thinLayers()[0]->tableName();
+			tableName = layer->vacuateLayers()[0]->tableName();
 		}
 		}
 
 
 		std::string sql = format(ss.c_str(), layer->schema().c_str(), tableName.c_str());
 		std::string sql = format(ss.c_str(), layer->schema().c_str(), tableName.c_str());
@@ -518,7 +537,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 					{
 					{
 						typeString = "geometry";
 						typeString = "geometry";
 						typeInt = PGFieldType::ShapeFieldType;
 						typeInt = PGFieldType::ShapeFieldType;
-						fields_str += " st_asgeojson(\"" + (fieldname) + "\") as geometry_as_geojson";
+						fields_str += " \"" + (fieldname) + "\" as geometry_as_wkb ";
 					}
 					}
 					else if (typeString == "integer")
 					else if (typeString == "integer")
 					{
 					{
@@ -572,8 +591,14 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 		std::string sql = format(ss.c_str(), layer->schema().c_str(), tableName.c_str());
 		std::string sql = format(ss.c_str(), layer->schema().c_str(), tableName.c_str());
 
 
 		string shapeName = layer->geom();
 		string shapeName = layer->geom();
-		sql += format(" ST_DWithin(\"%s\", ST_GeometryFromText('POINT(%f %f)',%s), %f) limit %d ",
-					  shapeName.c_str(), x, y, layer->srid().c_str(), dis, feature_count);
+		// WHERE  \"%s\" && \'BOX3D(%lf %lf,%lf %lf)\'::box3d 
+		//sql += format(" ST_DWithin(\"%s\", ST_GeometryFromText('POINT(%f %f)',%s),%f) limit %d ",
+		//			  shapeName.c_str(), x, y,layer->srid().c_str(), dis, feature_count);
+
+		sql += format(" \"%s\" && \'BOX3D(%lf %lf,%lf %lf)\'::box3d limit %d ",
+					  shapeName.c_str(), x - dis, y - dis, x + dis, y + dis, feature_count);
+
+
 		//cout<<sql.c_str() <<endl;
 		//cout<<sql.c_str() <<endl;
 		return sql;
 		return sql;
 	}
 	}
@@ -596,16 +621,15 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 			double start = clock();
 			double start = clock();
 			double cost, cost2;
 			double cost, cost2;
 
 
-			string sql = this->GetFeatureInfoSQL(layer, x0, y0, dis, feature_count); //sql语句中使用 ::box
-			if (sql == "")
-				continue;
-			//printf("%s\r\n",sql.c_str());
-			string layerName = layer->name();
 			try
 			try
 			{
 			{
 				shared_ptr<DmpPgsql> pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
 				shared_ptr<DmpPgsql> pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
 				if (pPgsqlConn == nullptr)
 				if (pPgsqlConn == nullptr)
 					break;
 					break;
+				DmpMapServerUtil::initVectorLayerSrid(pPgsqlConn, layer);
+				string sql = this->GetFeatureInfoSQL(layer, x0, y0, dis, feature_count); //sql语句中使用 ::box
+		  	    if (sql == "") continue;
+			    string layerName = layer->name();
 				if (pPgsqlConn->ExecWaitBinary(sql))
 				if (pPgsqlConn->ExecWaitBinary(sql))
 				{
 				{
 					if(pPgsqlConn->GetRowCount()>0 || i==0)
 					if(pPgsqlConn->GetRowCount()>0 || i==0)
@@ -753,6 +777,11 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 		return true;
 		return true;
 	}
 	}
 
 
+	shared_ptr<Rect>  DmpWmsRenderer::GetExtent()
+	{
+		return m_pExtent;
+	}
+
 	bool DmpWmsRenderer::SetExtent(shared_ptr<Rect> rect)
 	bool DmpWmsRenderer::SetExtent(shared_ptr<Rect> rect)
 	{
 	{
 		m_pExtent = rect;
 		m_pExtent = rect;
@@ -944,7 +973,8 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 			}
 			}
 		}
 		}
 
 
-		for (int i = 0; i < (int)(m_vLayers.size()); i++)
+		//for (int i = 0; i < (int)(m_vLayers.size()); i++)
+		for (int i = (int)(m_vLayers.size()) -1; i >= 0; i--)
 		{
 		{
 			DmpVectorLayer *layer = m_vLayers[i];
 			DmpVectorLayer *layer = m_vLayers[i];
 			sprintf(buff, "<log>draw layer %s</log>", layer->name().c_str());
 			sprintf(buff, "<log>draw layer %s</log>", layer->name().c_str());
@@ -1038,7 +1068,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 			outputStream << buff;
 			outputStream << buff;
 
 
 			string sql = "";
 			string sql = "";
-			shared_ptr<DmpVectorThinLayer> pVectorThinLayer = nullptr;
+			shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer = nullptr;
 
 
 			shared_ptr<DataCollection> data(new DataCollection());
 			shared_ptr<DataCollection> data(new DataCollection());
 
 
@@ -1051,7 +1081,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 				sql = GetRegionQuerySQL(layer, pExtent.get(), format("%d", layer->crs().srid()), strRegionLayerNameDefs, strRegionColDefs, strLayerDef);
 				sql = GetRegionQuerySQL(layer, pExtent.get(), format("%d", layer->crs().srid()), strRegionLayerNameDefs, strRegionColDefs, strLayerDef);
 			}
 			}
 
 
-			pVectorThinLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
+			pVectorVacuateLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
 
 
 			string sqlLog = sql;
 			string sqlLog = sql;
 			DmpMapServerUtil::toXmlString(sqlLog);
 			DmpMapServerUtil::toXmlString(sqlLog);
@@ -1064,9 +1094,9 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 
 
 			string tableName = layer->name();
 			string tableName = layer->name();
 
 
-			if (pVectorThinLayer != nullptr)
+			if (pVectorVacuateLayer != nullptr)
 			{
 			{
-				tableName = pVectorThinLayer->tableName();
+				tableName = pVectorVacuateLayer->tableName();
 			}
 			}
 
 
 			if (tableName.length() > 32)
 			if (tableName.length() > 32)
@@ -1080,13 +1110,13 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 			{
 			{
 
 
 				shared_ptr<DmpPgsql> pPgsqlConn = nullptr;
 				shared_ptr<DmpPgsql> pPgsqlConn = nullptr;
-				if (pVectorThinLayer == nullptr)
+				if (pVectorVacuateLayer == nullptr)
 				{
 				{
 					pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
 					pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
 				}
 				}
 				else
 				else
 				{
 				{
-					pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetDefaultPgsqlConn();
+					pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(pVectorVacuateLayer->connectStr());
 				}
 				}
 
 
 				if (pPgsqlConn == nullptr)
 				if (pPgsqlConn == nullptr)
@@ -1106,7 +1136,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 					sprintf(buff,"<log>draw success</log>");
 					sprintf(buff,"<log>draw success</log>");
 					outputStream << buff;
 					outputStream << buff;
 				}
 				}
-				else if (pVectorThinLayer != nullptr)
+				else if (pVectorVacuateLayer != nullptr)
 				{
 				{
 					/*shared_ptr<DmpPgsql> pPgsqlConn1 = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
 					/*shared_ptr<DmpPgsql> pPgsqlConn1 = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
 					sprintf(buff,"<log>从抽稀图层获取数据%s</log>", pMapLayerThinning->m_tableName.c_str());
 					sprintf(buff,"<log>从抽稀图层获取数据%s</log>", pMapLayerThinning->m_tableName.c_str());
@@ -1201,7 +1231,9 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 
 
 		map<DmpVectorLayer *, shared_ptr<DataCollection>> map_DataCollection;
 		map<DmpVectorLayer *, shared_ptr<DataCollection>> map_DataCollection;
 
 
-		for (int i = 0; i < (int)(m_vLayers.size()); i++)
+
+		//for (int i = 0; i < (int)(m_vLayers.size()); i++)
+		for (int i = (int)(m_vLayers.size()) -1; i >= 0; i--)
 		{
 		{
 			DmpVectorLayer *layer = m_vLayers[i];
 			DmpVectorLayer *layer = m_vLayers[i];
 
 
@@ -1231,7 +1263,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 				double cost, cost2;
 				double cost, cost2;
 
 
 				string sql = "";
 				string sql = "";
-				shared_ptr<DmpVectorThinLayer> pVectorThinLayer = nullptr;
+				shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer = nullptr;
 
 
 				bool renderHeat = false;
 				bool renderHeat = false;
 				shared_ptr<DataCollection> data(new DataCollection());
 				shared_ptr<DataCollection> data(new DataCollection());
@@ -1245,7 +1277,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 					sql = GetRegionQuerySQL(layer, pExtent.get(), format("%d", layer->crs().srid()), strRegionLayerNameDefs, strRegionColDefs, strLayerDef);
 					sql = GetRegionQuerySQL(layer, pExtent.get(), format("%d", layer->crs().srid()), strRegionLayerNameDefs, strRegionColDefs, strLayerDef);
 				}
 				}
 
 
-				pVectorThinLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
+				pVectorVacuateLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
 
 
 				// printf( "%s\r\n", sql.c_str());
 				// printf( "%s\r\n", sql.c_str());
 				// this->GetDrawSQL(layer, pExtent.get(), strLayerDef); //sql语句中使用 ::box
 				// this->GetDrawSQL(layer, pExtent.get(), strLayerDef); //sql语句中使用 ::box
@@ -1254,9 +1286,9 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 
 
 				string tableName = layer->name();
 				string tableName = layer->name();
 
 
-				if (pVectorThinLayer != nullptr)
+				if (pVectorVacuateLayer != nullptr)
 				{
 				{
-					tableName = pVectorThinLayer->tableName();
+					tableName = pVectorVacuateLayer->tableName();
 				}
 				}
 
 
 				if (tableName.length() > 32)
 				if (tableName.length() > 32)
@@ -1270,13 +1302,13 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 				{
 				{
 
 
 					shared_ptr<DmpPgsql> pPgsqlConn = nullptr;
 					shared_ptr<DmpPgsql> pPgsqlConn = nullptr;
-					if (pVectorThinLayer == nullptr)
+					if (pVectorVacuateLayer == nullptr)
 					{
 					{
 						pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
 						pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
 					}
 					}
 					else
 					else
 					{
 					{
-						pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetDefaultPgsqlConn();
+						pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(pVectorVacuateLayer->connectStr());
 					}
 					}
 
 
 					if (pPgsqlConn == nullptr)
 					if (pPgsqlConn == nullptr)
@@ -1287,7 +1319,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 						if (PQntuples(res) == 0)
 						if (PQntuples(res) == 0)
 							continue;
 							continue;
 
 
-						int shapeType = layer->GeometryType();
+						int shapeType = layer->GeomWkbType();
 						shared_ptr<DataCollection> data(new DataCollection());
 						shared_ptr<DataCollection> data(new DataCollection());
 						data->InitDataCollection(res, shapeType, this->m_dWidth, this->m_dHeight, 0, m_dR, m_dScaleDenominator, x_dis, y_dis);
 						data->InitDataCollection(res, shapeType, this->m_dWidth, this->m_dHeight, 0, m_dR, m_dScaleDenominator, x_dis, y_dis);
 
 
@@ -1300,7 +1332,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 						this->DrawSimpleData(data.get(), layer->GetRenderer30().get(), pClsSurfThis);
 						this->DrawSimpleData(data.get(), layer->GetRenderer30().get(), pClsSurfThis);
 						
 						
 					}
 					}
-					else if (pVectorThinLayer != nullptr)
+					else if (pVectorVacuateLayer != nullptr)
 					{
 					{
 						shared_ptr<DmpPgsql> pPgsqlConn1 = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
 						shared_ptr<DmpPgsql> pPgsqlConn1 = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
 
 
@@ -1312,7 +1344,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 							if (PQntuples(res) == 0)
 							if (PQntuples(res) == 0)
 								continue;
 								continue;
 
 
-							int shapeType = layer->GeometryType();
+							int shapeType = layer->GeomWkbType();
 							shared_ptr<DataCollection> data(new DataCollection());
 							shared_ptr<DataCollection> data(new DataCollection());
 							if (!renderHeat)
 							if (!renderHeat)
 							{
 							{
@@ -1356,6 +1388,76 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 		return true;
 		return true;
 	}
 	}
 
 
+	bool DmpWmsRenderer::GetMapLegend( std::stringstream& ab, shared_ptr<legendParamater> pLegendParamater)
+	{
+		clsCrSurf *pClsSurfThis;
+
+		pClsSurfThis = m_pClsSurfBuff; //refresh画图在  buff 中
+		this->DoSetBackGround(pClsSurfThis, m_iBackColor);
+
+		for (int layerType = 0; layerType < 3; layerType++)
+		{
+			
+			for (int i = 0; i < (int)(m_vLayers.size()); i++)
+			{
+				DmpVectorLayer *layer = m_vLayers[i];
+		
+				//if ((ml->m_bVisible) == false)
+				//	continue;
+
+				//if (ml->m_pDataset == nullptr)
+				//	continue;
+
+				//double r1 = ml->m_dUpperScale; // *
+				//double r2 = ml->m_dLowerScale; // *
+				std::shared_ptr<DmapCore_30::Renderer> renderer = layer->GetRenderer30();
+				renderer->DrawLegend(pClsSurfThis, pLegendParamater, layerType, (char *)layer->name().c_str());
+			}
+		}
+
+		this->BufferCopy(m_pClsSurfBuff, m_pClsMaxSurfBuffer);
+		this->BufferCopy(m_pClsSurfBuff, m_pClsSurfDC);
+
+		pLegendParamater->next(nullptr);
+
+		cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, (int)m_dWidth, pLegendParamater->pixYIndex + 10); //cairo_win32_surface_create(hdc);
+		clsCrSurf surfDC(surface);
+		this->BufferCopy(m_pClsSurfDC, &surfDC);
+
+		cairo_surface_write_to_png_stream(surfDC.m_pSurf, cairo_write_func, &ab);
+
+		return true;
+	}
+
+	bool DmpWmsRenderer::GetMapLegend( shared_ptr<legendParamater> pLegendParamater, clsCrSurf* pClsSurf)
+	{
+		if(pClsSurf == nullptr)
+		{
+			pClsSurf = m_pClsSurfBuff;
+		}
+
+		for (int layerType = 0; layerType < 3; layerType++)
+		{
+			for (int i = 0; i < (int)(m_vLayers.size()); i++)
+			{
+				DmpVectorLayer *layer = m_vLayers[i];
+		
+				//if ((ml->m_bVisible) == false)
+				//	continue;
+
+				//if (ml->m_pDataset == nullptr)
+				//	continue;
+
+				//double r1 = ml->m_dUpperScale; // *
+				//double r2 = ml->m_dLowerScale; // *
+				std::shared_ptr<DmapCore_30::Renderer> renderer = layer->GetRenderer30();
+				renderer->DrawLegend(pClsSurf, pLegendParamater, layerType, (char *)layer->name().c_str());
+			}
+			
+		}
+		return true;
+	}
+
 	bool DmpWmsRenderer::ToStream(std::string &responseData)
 	bool DmpWmsRenderer::ToStream(std::string &responseData)
 	{
 	{
 		responseData.reserve(10240);
 		responseData.reserve(10240);

@@ -22,7 +22,7 @@
 #include "clsUtil.h"
 #include "clsUtil.h"
 #include "DataCollection.h"
 #include "DataCollection.h"
 #include "dmpvectorlayer.h"
 #include "dmpvectorlayer.h"
-#include "dmpvectorthinlayer.h"
+#include "dmpvectorvacuatelayer.h"
 #include "dmprasterbuffer.h"
 #include "dmprasterbuffer.h"
 #include "dmpproject.h"
 #include "dmpproject.h"
 #include "dmppgsqlsourcepools.h"
 #include "dmppgsqlsourcepools.h"
@@ -32,8 +32,6 @@ using namespace DmapCore_30;
 using namespace mapserver;
 using namespace mapserver;
 namespace DmpWms
 namespace DmpWms
 {
 {
-
-
     class DmpWmsRenderer
     class DmpWmsRenderer
     {
     {
     public:
     public:
@@ -49,7 +47,7 @@ namespace DmpWms
 		bool GetMapLegend( std::stringstream& ab, shared_ptr<legendParamater> pLegendParamater);
 		bool GetMapLegend( std::stringstream& ab, shared_ptr<legendParamater> pLegendParamater);
 		bool GetMapLegend( shared_ptr<legendParamater> pLegendParamater, clsCrSurf* pClsSurf);
 		bool GetMapLegend( shared_ptr<legendParamater> pLegendParamater, clsCrSurf* pClsSurf);
 		
 		
-		string GetDrawSQLAll_Catch(DmpVectorLayer* layer,shared_ptr<DmpVectorThinLayer> pMapLayerThinning);
+		string GetDrawSQLAll_Catch(DmpVectorLayer* layer,shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer);
 		string GetDrawSQL(DmpVectorLayer* layer, Rect* pRect,const char* layerdef = nullptr);
 		string GetDrawSQL(DmpVectorLayer* layer, Rect* pRect,const char* layerdef = nullptr);
 		string GetDrawSQLAll(DmpVectorLayer* layer);
 		string GetDrawSQLAll(DmpVectorLayer* layer);
 		string GetDrawSQLAllOrderby(DmpVectorLayer* layer);
 		string GetDrawSQLAllOrderby(DmpVectorLayer* layer);
@@ -71,7 +69,7 @@ namespace DmpWms
 		bool DrawSimpleData(DataCollection* data, Renderer* renderer, clsCrSurf* pClsSurf);
 		bool DrawSimpleData(DataCollection* data, Renderer* renderer, clsCrSurf* pClsSurf);
 
 
 		//shared_ptr<Rect> GetFullExtent(bool bRecalculate); //加一个bool值,如果为false , 无需计算
 		//shared_ptr<Rect> GetFullExtent(bool bRecalculate); //加一个bool值,如果为false , 无需计算
-		//shared_ptr<Rect> GetExtent();
+		shared_ptr<Rect> GetExtent();
 		bool SetExtent(shared_ptr<Rect> rect);
 		bool SetExtent(shared_ptr<Rect> rect);
 		bool GetParameters(double* pR, double* pXdis, double* pYdis);
 		bool GetParameters(double* pR, double* pXdis, double* pYdis);
 		bool SetParameters(double r = -1, double xdis = 0, double ydis = 0);
 		bool SetParameters(double r = -1, double xdis = 0, double ydis = 0);

@@ -74,7 +74,11 @@ namespace DmpWms
     ptGeographicBoundingbox.add("southBoundLatitude", miny);
     ptGeographicBoundingbox.add("southBoundLatitude", miny);
     ptGeographicBoundingbox.add("northBoundLatitude", maxy);
     ptGeographicBoundingbox.add("northBoundLatitude", maxy);
     ptProject.add_child("EX_GeographicBoundingBox",ptGeographicBoundingbox);
     ptProject.add_child("EX_GeographicBoundingBox",ptGeographicBoundingbox);
-
+    if( mapLayers.begin() != mapLayers.end())
+    {
+       ptProject.add("source",  mapLayers.begin()->second->source());
+    }
+   
     boost::property_tree::ptree ptLayers;
     boost::property_tree::ptree ptLayers;
     for (std::map<std::string, DmpMapLayer*>::iterator iter= mapLayers.begin();iter != mapLayers.end(); iter++)
     for (std::map<std::string, DmpMapLayer*>::iterator iter= mapLayers.begin();iter != mapLayers.end(); iter++)
     {
     {
@@ -90,8 +94,9 @@ namespace DmpWms
     boost::property_tree::ptree ptLayer;
     boost::property_tree::ptree ptLayer;
     ptLayer.add("Name", layer->name());
     ptLayer.add("Name", layer->name());
     ptLayer.add("Title", layer->title());
     ptLayer.add("Title", layer->title());
-    ptLayer.add("CRS", srs);
+    ptLayer.add("CRS",  layer->srid().empty()?srs:("EPSG:" + layer->srid()));
     ptLayer.add("Type", layer->GeomTypeString());
     ptLayer.add("Type", layer->GeomTypeString());
+    ptLayer.add("source", layer->source());
 
 
     boost::property_tree::ptree ptGeographicBoundingbox; 
     boost::property_tree::ptree ptGeographicBoundingbox; 
     ptGeographicBoundingbox.add("westBoundLongitude", layer->extent().xmin());
     ptGeographicBoundingbox.add("westBoundLongitude", layer->extent().xmin());

+/**************************************************************************
+* file:              dmpmapprint.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-20 18:50:40
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpmapprint.h"
+#include <unistd.h>
+#include <algorithm>
+#include <cairo/cairo-svg.h>
+
+namespace DmpWms
+{
+	static cairo_status_t cairo_write_func_print(void *pbuff, const unsigned char *data, unsigned int length)
+	{
+		// vector<unsigned char>& vecData = *((vector<unsigned char>*)closure);
+		string *pResponseData = (string *)pbuff;
+		pResponseData->append((char *)data, length);
+		return CAIRO_STATUS_SUCCESS;
+	}
+
+	DmpMapPrint::DmpMapPrint(DmpWmsParameters::Format outformat)
+	{
+		this->format = outformat;
+	}
+
+	bool DmpMapPrint::getPrint(std::string &responseData,const DmpProject *project, const string &xml, const string& servername)
+	{
+		string result_msg;
+
+		try
+		{
+			std::stringstream stream(xml);
+			boost::property_tree::ptree ptree;
+			boost::property_tree::read_xml(stream, ptree);
+
+			std::string templateStr = ptree.get<string>("template");
+			InitTemplateValue(templateStr);
+
+			m_height = 1122;
+			m_width = 793;
+
+			double xmin = ptree.get<double>("extent/xmin");
+			double ymin = ptree.get<double>("extent/ymin");
+			double xmax = ptree.get<double>("extent/xmax");
+			double ymax = ptree.get<double>("extent/ymax");
+			
+			shared_ptr<DmpPrintParameter> pDmpPrintParameter(new DmpPrintParameter());
+
+			shared_ptr<DmpPrintWMSService> dmapLayer(new DmpPrintWMSService());
+			dmapLayer->serviceName_ = servername;
+
+			dmapLayer->project_ = project;
+			//shared_ptr<DmpRectangle> dmpRectangle
+			//Rect *rect = dmapLayer->project_->GetExtent();
+			pDmpPrintParameter->InitParameter(xmin, xmax, ymax, ymin, m_width - 100, m_height - 120);
+
+		// dmapLayer->serviceName = "土地利用现状";
+		// dmapLayer->m_id = "土地利用现状";
+		// dmapLayer->boxX1 = 683497;
+		// dmapLayer->boxX2 = 695357;
+		// dmapLayer->boxY1 = 2534922;
+		// dmapLayer->boxY2 = 2543053;
+
+		//Rect *rect = dmapLayer->m_wmsServer->GetExtent();
+
+		dmapLayer->boxX1_ = xmin;
+		dmapLayer->boxX2_ = xmax;
+		dmapLayer->boxY1_ = ymin;
+		dmapLayer->boxY2_ = ymax;
+
+		shared_ptr<DmpPrintLayout> dmapLayout(new DmpPrintLayout());
+		this->vector_DmpPrintLayout.push_back(dmapLayout);
+
+		dmapLayout->data.push_back(dmapLayer);
+		dmapLayout->localtionX_ = 50;
+		dmapLayout->localtionY_ = 70;
+
+		dmapLayout->height_ = m_height - 70;
+		dmapLayout->width_ = m_width - 50;
+
+		this->m_height = m_height;
+		this->m_width = m_width;
+
+		shared_ptr<DmpPrintScale> geomLayer_scale(new DmpPrintScale());
+		geomLayer_scale->pPrintParameter_ = pDmpPrintParameter;
+		shared_ptr<DmpPrintLayout> dmapLayout_scale(new DmpPrintLayout());
+		this->vector_DmpPrintLayout.push_back(dmapLayout_scale);
+		geomLayer_scale->localtionX_ = 150;
+		geomLayer_scale->localtionY_ = m_height - 50;
+		dmapLayout_scale->data.push_back(geomLayer_scale);
+
+		shared_ptr<DmpPrintCompass> geomLayer_compass(new DmpPrintCompass());
+		geomLayer_compass->pPrintParameter_ = pDmpPrintParameter;
+		shared_ptr<DmpPrintLayout> dmapLayout_compass(new DmpPrintLayout());
+		this->vector_DmpPrintLayout.push_back(dmapLayout_compass);
+		geomLayer_compass->localtionX_ = 80;
+		geomLayer_compass->localtionY_ = m_height - 80;
+		dmapLayout_compass->data.push_back(geomLayer_compass);
+
+		ToPrint(responseData);
+		return true;
+
+		}
+		catch (...)
+		{
+
+		}
+		return false;
+	}
+
+	bool DmpMapPrint::getPrint(std::string &responseData,const DmpProject *project, const string& servername,
+							    const char *printTemp, const char *bbox)
+	{
+		string result_msg;
+
+		if (printTemp == nullptr || bbox == nullptr)
+			return false;
+
+		m_height = 1122;
+		m_width = 793;
+
+		double boxX1, boxY1, boxX2, boxY2;
+		sscanf(bbox, "%lf,%lf,%lf,%lf", &boxY1, &boxX1, &boxY2, &boxX2); // &x1,&y1,&x2,&y2);
+
+		InitTemplateValue(printTemp);
+
+		shared_ptr<DmpPrintParameter> pDmpPrintParameter(new DmpPrintParameter());
+
+		shared_ptr<DmpPrintWMSService> dmapLayer(new DmpPrintWMSService());
+		dmapLayer->serviceName_ = servername;
+
+		
+			xmin = min(boxX1, boxX2);
+			ymin = min(boxY1, boxY2);
+			xmax = max(boxX1, boxX2);
+			ymax = max(boxY1, boxY2);
+			pDmpPrintParameter->InitParameter(xmin, xmax, ymax, ymin, m_width - 100, m_height - 120);
+			// double scaleDenominator = this->RecalculateScale(rect->m_dRight,rect->m_dLeft,rect->m_dTop,rect->m_dBottom,1022,693);
+		
+
+		// dmapLayer->serviceName = "土地利用现状";
+		// dmapLayer->m_id = "土地利用现状";
+		// dmapLayer->boxX1 = 683497;
+		// dmapLayer->boxX2 = 695357;
+		// dmapLayer->boxY1 = 2534922;
+		// dmapLayer->boxY2 = 2543053;
+
+	//	Rect *rect = dmapLayer->m_wmsServer->GetExtent();
+
+		dmapLayer->boxX1_ = xmin;
+		dmapLayer->boxX2_ = xmax;
+		dmapLayer->boxY1_ = ymin;
+		dmapLayer->boxY2_ = ymax;
+
+		shared_ptr<DmpPrintLayout> dmapLayout(new DmpPrintLayout());
+		this->vector_DmpPrintLayout.push_back(dmapLayout);
+
+		dmapLayout->data.push_back(dmapLayer);
+		dmapLayout->localtionX_ = 50;
+		dmapLayout->localtionY_ = 70;
+
+		dmapLayout->height_ = m_height - 120;
+		dmapLayout->width_ = m_width - 100;
+
+		this->m_height = m_height;
+		this->m_width = m_width;
+
+		shared_ptr<DmpPrintScale> geomLayer_scale(new DmpPrintScale());
+		geomLayer_scale->pPrintParameter_ = pDmpPrintParameter;
+		shared_ptr<DmpPrintLayout> dmapLayout_scale(new DmpPrintLayout());
+		this->vector_DmpPrintLayout.push_back(dmapLayout_scale);
+		geomLayer_scale->localtionX_ = 150;
+		geomLayer_scale->localtionY_ = m_height - 110;
+		dmapLayout_scale->data.push_back(geomLayer_scale);
+
+		shared_ptr<DmpPrintCompass> geomLayer_compass(new DmpPrintCompass());
+		geomLayer_compass->pPrintParameter_ = pDmpPrintParameter;
+		shared_ptr<DmpPrintLayout> dmapLayout_compass(new DmpPrintLayout());
+		this->vector_DmpPrintLayout.push_back(dmapLayout_compass);
+		geomLayer_compass->localtionX_ = 80;
+		geomLayer_compass->localtionY_ = m_height - 140;
+		dmapLayout_compass->data.push_back(geomLayer_compass);
+
+		ToPrint(responseData);
+		return true;
+	}
+
+	bool DmpMapPrint::getPrintTempFile(string &responseData,const DmpProject *project, const char *tempName, const char *bbox,
+	const char *paras)
+	{
+		string path = "../template/";
+		path += tempName;
+		path += ".xml";
+
+		ifstream fin(path.c_str(), ios::binary);
+		if (!fin)
+		{
+			responseData = "<Error>打印模板未找到</Error>";
+			return false;
+		}
+
+		stringstream buffer;
+		buffer << fin.rdbuf();
+		string content(buffer.str());
+		fin.close();
+		return getPrintLayout(responseData, project, content.c_str(), bbox, paras);
+		// return true;
+	}
+
+	bool DmpMapPrint::getPrintLayout(string &responseData,const DmpProject *project, const char *xml, const char *bbox,const char *paras)
+	{
+		string result_msg;
+		if (xml == nullptr || bbox == nullptr)
+			return false;
+
+		m_height = 1122;
+		m_width = 793;
+
+		try
+		{
+			map<string,string> mapParas;
+			map<string,string> mapParasList;
+			if(paras)
+			{
+				std::stringstream streampara(paras);
+				boost::property_tree::ptree ptreepara;
+				boost::property_tree::read_json(streampara, ptreepara);
+
+				for (boost::property_tree::ptree::iterator pos = ptreepara.begin(); pos != ptreepara.end(); ++pos)
+             	{
+					std::string name = pos->first;
+					std::string value = pos->second.get_value<std::string>();
+					mapParas[name] = value;
+				}
+			}
+
+			std::stringstream stream(xml);
+			boost::property_tree::ptree ptree;
+			boost::property_tree::read_xml(stream, ptree);
+
+			std::string templateStr = ptree.get<string>("printlayout.template");
+			InitTemplateValue(templateStr);
+
+			double boxX1, boxY1, boxX2, boxY2;
+			sscanf(bbox, "%lf,%lf,%lf,%lf", &boxX1, &boxY1, &boxX2, &boxY2); // &x1,&y1,&x2,&y2);
+			shared_ptr<DmpPrintParameter> pDmpPrintParameter(new DmpPrintParameter());
+			// Rect *rect_service = pWmsServer->GetExtent();
+			// if (rect_service)
+			//{
+			//	rect_service->GetExtent(boxX1, boxX2, boxY1, boxY2);
+			// }
+
+			xmin = min(boxX1, boxX2);
+			ymin = min(boxY1, boxY2);
+			xmax = max(boxX1, boxX2);
+			ymax = max(boxY1, boxY2);
+			pDmpPrintParameter->pWmsService = project;
+			pDmpPrintParameter->InitParameter(xmin, xmax, ymax, ymin, m_width - 100, m_height - 120);
+
+			shared_ptr<DmpPrintLayout> printLayout(new DmpPrintLayout());
+            boost::property_tree::ptree ptreelayout = ptree.get_child("printlayout");
+			if (printLayout->ReadXML(ptreelayout, pDmpPrintParameter, result_msg,mapParas,mapParasList))
+			{
+				this->vector_DmpPrintLayout.push_back(printLayout);
+				ToPrint(responseData);
+				return true;
+			}
+		}
+		catch (const std::exception& e)
+    	{
+        	std::cerr << e.what()  << '\n';
+			result_msg = "<Error>error:Post参数是XML格式</Error>";
+		}
+
+		responseData = result_msg;
+		return false;
+	}
+
+	bool DmpMapPrint::ToPrint(string &responseData)
+	{
+		if (format ==  DmpWmsParameters::Format::SVG)
+		{
+			// string path = this->GetFilePath("mapPrint.pdf");
+			cairo_surface_t *surface = cairo_svg_surface_create_for_stream(cairo_write_func_print, &responseData,
+																		   (int)m_width,
+																		   (int)m_height);
+
+			// cairo_surface_set_fallback_resolution(surface,900,900);
+			clsCrSurf mClsSurfDC(surface, (int)m_width, (int)m_height, false);
+			cairo_set_antialias(mClsSurfDC.m_pCr, cairo_antialias_t::CAIRO_ANTIALIAS_BEST);
+			DoSetBackGround(&mClsSurfDC, 0xffffffff);
+
+			for (size_t i = 0; i < vector_DmpPrintLayout.size(); i++)
+			{
+				shared_ptr<DmpPrintLayout> layout = vector_DmpPrintLayout.at(i);
+				layout->DrawData(&mClsSurfDC,  DmpWmsParameters::Format::SVG);
+			}
+		}
+		else if (format ==  DmpWmsParameters::Format::PDF)
+		{
+			// string path = this->GetFilePath("mapPrint.pdf");
+			cairo_surface_t *surface = cairo_pdf_surface_create_for_stream(cairo_write_func_print, &responseData,
+																		   (int)m_width,
+																		   (int)m_height);
+
+			// cairo_surface_set_fallback_resolution(surface,900,900);
+			clsCrSurf mClsSurfDC(surface, (int)m_width, (int)m_height, false);
+			cairo_set_antialias(mClsSurfDC.m_pCr, cairo_antialias_t::CAIRO_ANTIALIAS_BEST);
+			DoSetBackGround(&mClsSurfDC, 0xffffffff);
+
+			for (size_t i = 0; i < vector_DmpPrintLayout.size(); i++)
+			{
+				shared_ptr<DmpPrintLayout> layout = vector_DmpPrintLayout.at(i);
+				layout->DrawData(&mClsSurfDC,  DmpWmsParameters::Format::PDF);
+			}
+		}
+		else
+		{
+			cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
+																  (int)m_width,
+																  (int)m_height);
+
+			// cairo_surface_set_fallback_resolution(surface);
+			// double dpix, dpiy;
+			// cairo_surface_get_fallback_resolution(surface,&dpix, &dpiy);
+			// printf("%f,%f",dpix,dpiy);
+
+			clsCrSurf mClsSurfDC(surface);
+			DoSetBackGround(&mClsSurfDC, 0xffffffff);
+
+			for (size_t i = 0; i < vector_DmpPrintLayout.size(); i++)
+			{
+				shared_ptr<DmpPrintLayout> layout = vector_DmpPrintLayout.at(i);
+				layout->DrawData(&mClsSurfDC, DmpWmsParameters::Format::PNG);
+			}
+
+			cairo_surface_write_to_png_stream(surface, cairo_write_func_print, &responseData);
+		}
+		return true;
+	}
+
+	bool DmpMapPrint::InitTemplateValue(string templateValue)
+	{
+
+		if (templateValue == "A4竖" || templateValue == "A4-hoch")
+		{
+			m_height = 1122;
+			m_width = 793;
+		}
+		else if (templateValue == "A4横" || templateValue == "A4-quer")
+		{
+			m_height = 793;
+			m_width = 1122;
+		}
+		else if (templateValue == "A3竖" || templateValue == "A3-hoch")
+		{
+			m_height = 1122 * 2;
+			m_width = 793 * 2;
+		}
+		else if (templateValue == "A3横" || templateValue == "A3-quer")
+		{
+			m_height = 793 * 2;
+			m_width = 1122 * 2;
+		}
+		else if (templateValue == "A5竖" || templateValue == "A5-hoch")
+		{
+			m_height = 1122 / 2;
+			m_width = 793 / 2;
+		}
+		else if (templateValue == "A5横" || templateValue == "A5-quer")
+		{
+			m_height = 793 / 2;
+			m_width = 1122 / 2;
+		}
+		return true;
+	}
+
+
+
+	double DmpMapPrint::RecalculateScale(double right, double left, double top, double bottom, double width, double height)
+	{
+		double w = right - left;
+		double h = top - bottom;
+		double oneInchInLayoutUnits = 0.0254;
+		double resolution = 96;
+		if ((w > std::pow(10, 12)) || (w < std::pow(10, -12)))
+			return false;
+		if ((h > std::pow(10, 12)) || (h < std::pow(10, -12)))
+			return false;
+
+		long double R1 = width / w;
+		long double R2 = height / h;
+		double r = R1 < R2 ? R1 : R2;
+		if ((r > std::pow(10, 12)) || (r < std::pow(10, -12)))
+			return false;
+
+		// m_dR = R1 < R2 ? R1 : R2;
+		double m_dR = r;
+		double m_dXdis = width / 2.0 - m_dR * (right + left) / 2.0;
+		double m_dYdis = height / 2.0 + m_dR * (top + bottom) / 2.0;
+
+		bool isWGS84 = left <= 180 && right < 180 &&
+					   left >= -180 && right >= -180 &&
+					   top < 90 && bottom < 90;
+
+		double scaleDenominator = 0;
+		if (isWGS84)
+		{
+			scaleDenominator = (resolution / oneInchInLayoutUnits) * (1 / r) * 111000;
+			// m_dR = r *(96 / 0.0254) *111000 ;//111000 为赤道1经度等于 111000米
+		}
+		else
+		{
+			scaleDenominator = (resolution / oneInchInLayoutUnits) * 1 / r;
+		}
+
+		return scaleDenominator;
+	}
+
+	string DmpMapPrint::GetFilePath(string path)
+	{
+		char sz[200] = {0};
+		if (GetCurrentFolderPath(sz, sizeof(sz)) > 0)
+		{
+			std::string s;
+			s = sz;
+			size_t t = s.rfind('/');
+			sz[t] = 0;
+			if (path[0] == '/')
+			{
+				return path;
+			}
+			int i = 0;
+			if (path[0] == '.')
+			{
+				if (path[1] == '.')
+				{
+					i++;
+					s = sz;
+					t = s.rfind('/');
+					sz[t] = 0;
+				}
+				i++;
+			}
+			if ((sz[t] == '/' || sz[t] == '\\') && (path[i] == '/' || path[i] == '\\'))
+			{
+				i++;
+			}
+
+			int j = t;
+			for (j = t; i < path.length(); i++, j++)
+			{
+				if (path[i] == '\\')
+				{
+					sz[j] = '/';
+				}
+				else
+				{
+					sz[j] = path[i];
+				}
+			}
+			sz[j] = 0;
+			// strcat(sz, path.c_str());
+			return sz;
+		}
+		else
+			return 0;
+	}
+
+	int DmpMapPrint::GetCurrentFolderPath(char *processdir, size_t len)
+	{
+		char *path_end;
+		if (readlink("/proc/self/exe", processdir, len) <= 0)
+			return -1;
+		path_end = strrchr(processdir, '/');
+		if (path_end == NULL)
+			return -1;
+		++path_end;
+		// strcpy(processname, path_end);
+		*path_end = '\0';
+		return (size_t)(path_end - processdir);
+	}
+
+	bool DmpMapPrint::DoSetBackGround(clsCrSurf *pClsCS, int iColor)
+	{
+		cairo_surface_t *surface = pClsCS->m_pSurf;
+		cairo_t *cr = pClsCS->m_pCr;
+		int surf_w = cairo_image_surface_get_width(surface);
+		int surf_h = cairo_image_surface_get_height(surface);
+		//画一个矩形背景
+		cairo_rectangle(cr, 0, 0, surf_w, surf_h);
+		double r, g, b, a;
+		//MyUtil::ToCairoColor(iColor, r, g, b, a);
+		cairo_set_source_rgb(cr, 255, 255, 255);
+		cairo_fill(cr);
+		return true;
+	}
+}

 /**************************************************************************
 /**************************************************************************
-* file:              dmpprint.h
+* file:              dmpmapprint.h
 
 
 * Author:            qingxiongf
 * Author:            qingxiongf
 * Date:              2022-01-20 18:50:30
 * Date:              2022-01-20 18:50:30
@@ -7,22 +7,31 @@
 * copyright:         广州城市信息研究所有限公司
 * copyright:         广州城市信息研究所有限公司
 ***************************************************************************/
 ***************************************************************************/
 
 
-#ifndef __dmpprint_h__
-#define __dmpprint_h__
+#ifndef __dmpmapprint_h__
+#define __dmpmapprint_h__
 
 
 #include <string>
 #include <string>
 #include <string.h>
 #include <string.h>
 #include <vector>
 #include <vector>
 #include <map>
 #include <map>
-
+#include <math.h>
+#include "dmpproject.h"
 #include "clsCrSurf.h"
 #include "clsCrSurf.h"
 #include "clsRect.h"
 #include "clsRect.h"
 #include "clsUtil.h"
 #include "clsUtil.h"
+#include <boost/property_tree/ptree.hpp> 
+#include <boost/property_tree/xml_parser.hpp> 
+#include <boost/property_tree/json_parser.hpp> 
+#include <boost/typeof/typeof.hpp>
+#include "dmpprintlayout.h"
+#include "dmpprintparameter.h"
+#include "../dmpwmsrenderer.h"
+#include "../dmpwmsparameters.h"
 using namespace std;
 using namespace std;
 using namespace DmapCore_30;
 using namespace DmapCore_30;
 namespace DmpWms
 namespace DmpWms
 {
 {
-    class DmpPrint
+    class DmpMapPrint
     {
     {
     private:
     private:
         std::string m_name;
         std::string m_name;
@@ -37,7 +46,7 @@ namespace DmpWms
         int m_wkid;
         int m_wkid;
         int m_dpi;
         int m_dpi;
         double m_scale;
         double m_scale;
-        int isPicture;
+        DmpWmsParameters::Format format;
 
 
     private:
     private:
         bool DoSetBackGround(clsCrSurf *pClsCS, int iColor);
         bool DoSetBackGround(clsCrSurf *pClsCS, int iColor);
@@ -46,30 +55,30 @@ namespace DmpWms
         int GetCurrentFolderPath(char *processdir, size_t len);
         int GetCurrentFolderPath(char *processdir, size_t len);
         bool InitTemplateValue(string templateValue);
         bool InitTemplateValue(string templateValue);
         bool ToPrint(std::string &responseData);
         bool ToPrint(std::string &responseData);
-
     public:
     public:
-        DmpPrint(int isPicture);
-/*
-        bool getPrint(AppendBuffer *ab, map<string, shared_ptr<WMSServer>> &mapWmsServer, const char *xml, string servername);
-        bool getPrint(AppendBuffer *ab, map<string, shared_ptr<WMSServer>> &mapWmsServer, string servername, const char *printTemp, const char *bbox);
+        DmpMapPrint(DmpWmsParameters::Format outformat);
+    
+        bool getPrint(std::string &responseData,const DmpProject* project,const string & xml, const string& servername);
+        bool getPrint(std::string &responseData,const DmpProject* project, const string& servername, const char *printTemp, const char *bbox);
 
 
-        bool getPrintLayout(AppendBuffer *ab,
-                            shared_ptr<WMSServer> pWmsServer,
+        bool getPrintLayout(std::string &responseData,
+                            const DmpProject* project,
                             const char *xml,
                             const char *xml,
-                            const char *bbox);
+                            const char *bbox,
+                            const char *paras);
 
 
-        bool getPrintTempFile(AppendBuffer *ab,
-                              shared_ptr<WMSServer> pWmsServer,
+        bool getPrintTempFile(std::string &responseData,
+                             const DmpProject* project,
                               const char *tempName,
                               const char *tempName,
-                              const char *bbox);
-
-        bool Test(AppendBuffer *ab, map<string, shared_ptr<WMSServer>> &mapWmsServer, string servername);
+                              const char *bbox,
+                              const char *paras);
 
 
-        vector<shared_ptr<DmapPrintLayout>> vector_dmapPrintLayout;
+     //   bool Test(std::string &responseData, DmpProject* project, string servername);
 
 
-        vector<shared_ptr<OperationalLayer>> vector_operationalLayer;
-        */
+        vector<shared_ptr<DmpPrintLayout>> vector_DmpPrintLayout;
+       // vector<shared_ptr<OperationalLayer>> vector_operationalLayer;
+        
     };
     };
 }
 }
 
 
-#endif // __dmpprint_h__
+#endif // __dmpmapprint_h__

+/**************************************************************************
+* file:              dmpprintcompass.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-27 16:51:01
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpprintcompass.h"
+
+namespace DmpWms
+{
+     bool DmpPrintCompass::DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format)
+    {
+         
+        return false;
+    }
+
+    bool DmpPrintCompass::ReadXML(boost::property_tree::ptree &pt,shared_ptr<DmpPrintParameter> pPrintParameter,
+     string& errorstr, map<string,string>& para, map<string,string>& paraList)
+     {
+        this->ReadXmlAttribute(pt,localtionX_,"localtion_x", para, paraList);
+        this->ReadXmlAttribute(pt,localtionY_,"localtion_y", para, paraList);
+        //this->ReadXmlAttribute(pt,type,"type");
+
+        this->ReadXmlAttribute(pt, boundSize_, "bound_size", para, paraList);
+        this->ReadXmlAttribute(pt, showbound_, "showBound", para, paraList);
+
+        this->pPrintParameter_ = pPrintParameter;
+
+        return true;
+     }
+
+
+}

+/**************************************************************************
+* file:              dmpprintcompass.h
+
+* Author:            qingxiongf
+* Date:              2022-01-27 16:50:56
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#ifndef __dmpprintcompass_h__
+#define __dmpprintcompass_h__
+
+#include "dmpprintlayer.h"
+namespace DmpWms
+{
+    class DmpPrintCompass :public DmpPrintLayer
+    {
+        public:
+            string  serviceName;
+
+            shared_ptr<DmpPrintParameter> pPrintParameter_ = nullptr;
+
+            string type = "undefine";
+           
+        public:
+            //bool DrawImage();
+            bool DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format);
+            bool ReadXML(boost::property_tree::ptree &pt,shared_ptr<DmpPrintParameter> pPrintParameter, string& errorstr,
+                map<string,string>& para, map<string,string>& paraList);
+    };
+}
+
+#endif // __dmpprintcompass_h__

+/**************************************************************************
+* file:              dmpprintlayer.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-27 15:21:31
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpprintlayer.h"
+
+namespace DmpWms
+{
+    
+    bool DmpPrintLayer::DrawBound(clsCrSurf* pClsCS,double width, double height)
+    {
+        if(this->showbound_)
+        {
+            cairo_t *cr = pClsCS->m_pCr;
+            cairo_set_source_rgb (cr, 0, 0, 0);
+            cairo_set_line_width (cr, this->boundSize_);
+
+            cairo_rectangle (cr, localtionX_, localtionY_, width, height);
+            cairo_stroke_preserve (cr);
+            return false;
+        }
+        
+        return true;
+    }
+
+    shared_ptr<clsCrSurf> DmpPrintLayer::CreateSurface(int width, int height, DmpWmsParameters::Format format)
+    {
+        cairo_surface_t *surface = nullptr;
+
+        bool isImage = true;
+
+        if (format == DmpWmsParameters::Format::PDF)
+        {
+            surface = cairo_pdf_surface_create_for_stream(nullptr, nullptr, (int)width, (int)height);
+            isImage = false;
+        }
+        else if (format == DmpWmsParameters::Format::SVG)
+        {
+            surface = cairo_svg_surface_create_for_stream(nullptr, nullptr, (int)width, (int)height);
+            isImage = false;
+        }
+        else
+        {
+            surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, (int)width, (int)height);
+            isImage = true;
+        }
+        shared_ptr<clsCrSurf> mClsSurfDC(new clsCrSurf(surface, (int)width, (int)height, isImage));
+        return mClsSurfDC;
+    }
+
+    std::string DmpPrintLayer::replace(std::string strsrc, std::string strfind, std::string strrep)
+	{
+		for (std::string::size_type pos(0); pos != std::string::npos; pos += strrep.length())
+		{
+			if ((pos = strsrc.find(strfind, pos)) != std::string::npos)
+				strsrc.replace(pos, strfind.length(), strrep);
+			else
+				break;
+		}
+		return strsrc;
+	}
+
+    bool DmpPrintLayer::ReadXmlAttribute(boost::property_tree::ptree &pt,double& v, const char* key,
+        map<string,string>& para, map<string,string>& paraList)
+    {
+        try
+        {
+            string xmlattrkey = "<xmlattr>.";
+            xmlattrkey += key;
+            string value = pt.get<std::string>(xmlattrkey,"0"); 
+            if(value.find_first_of('#') ==0 && value.find_last_of('#') == value.length()-1)
+            {
+                value = replace(value, "#", "");
+                if(para.size() ==0)
+                {
+                   paraList[value] = "double";
+                }
+                else
+                {
+                   value =  para[value] ;
+                }
+            }
+            v = atof(value.c_str());
+          
+		    return true;
+        }
+        catch(...)
+        {
+            return false;
+        }
+    }
+
+     bool DmpPrintLayer::ReadXmlAttribute(boost::property_tree::ptree &pt,int& v, const char* key,
+        map<string,string>& para, map<string,string>& paraList)
+    {
+        try
+        {
+            string xmlattrkey = "<xmlattr>.";
+            xmlattrkey += key;
+            //string value = pt.get<std::string>(xmlattrkey,"0"); 
+            // v = atoi(value.c_str());
+
+            string value = pt.get<std::string>(xmlattrkey,"0"); 
+            if(value.find_first_of('#') ==0 && value.find_last_of('#') == value.length()-1)
+            {
+                value = replace(value, "#", "");
+                if(para.size() ==0)
+                {
+                   paraList[value] = "int";
+                }
+                else
+                {
+                   value =  para[value] ;
+                }
+            }
+
+            v = atof(value.c_str());
+		    return true;
+        }
+        catch(...)
+        {
+            return false;
+        }
+    }
+
+     bool DmpPrintLayer::ReadXmlAttribute(boost::property_tree::ptree &pt,bool& v, const char* key,
+        map<string,string>& para, map<string,string>& paraList)
+    {
+        try
+        {
+            string xmlattrkey = "<xmlattr>.";
+            xmlattrkey += key;
+            string value = pt.get<std::string>(xmlattrkey,"false"); 
+
+            if(value.find_first_of('#') ==0 && value.find_last_of('#') == value.length()-1)
+            {
+                value = replace(value, "#", "");
+                if(para.size() ==0)
+                {
+                   paraList[value] = "bool";
+                }
+                else
+                {
+                   value =  para[value] ;
+                }
+            }
+           
+            if(value == "false")v = false;
+            if(value == "true") v= true;
+           
+		    return true;
+        }
+        catch(...)
+        {
+            return false;
+        }
+    }
+
+
+    bool DmpPrintLayer::ReadXmlColorAttribute(boost::property_tree::ptree &pt,int& r, int& g, int& b, const char* key, 
+     map<string,string>& para, map<string,string>& paraList)
+    {
+        string color;
+        if(this->ReadXmlAttribute(pt, color, key,para ,paraList))
+        {
+            string str_red;
+            string str_greed;
+            string str_blue;
+            int i = color.find_first_of(',');
+            if(i != string::npos)
+            {
+                str_red = color.substr(0,i);
+                color = color.substr(i+1);
+            }
+            else
+            {
+                return false;
+            }
+
+            i = color.find_first_of(',');
+            if(i != string::npos)
+            {
+                str_greed = color.substr(0,i);
+                str_blue = color.substr(i+1);
+            }
+            else
+            {
+                return false;
+            }
+
+            r = atoi(str_red.c_str());
+            g = atoi(str_greed.c_str());
+            b = atoi(str_blue.c_str());
+            return true;
+        }
+        return false;
+    }
+
+    bool DmpPrintLayer::ReadXmlAttribute(boost::property_tree::ptree &pt,std::string& v, const char* key,
+     map<string,string>& para, map<string,string>& paraList)
+    {
+         try
+        {
+            string xmlattrkey = "<xmlattr>.";
+            xmlattrkey += key;
+            v = pt.get<std::string>(xmlattrkey,""); 
+            if(v.find_first_of('#') != v.find_last_of('#'))
+            {
+                int begin = v.find_first_of('#');
+                int end = v.find_last_of('#');
+                int length = end - begin +1;
+                std::string parakey = v.substr(begin, length);
+                std::string sparakey = replace(parakey, "#", "");
+
+                if(para.size() ==0 || para.find(sparakey) == para.end())
+                {
+                   paraList[sparakey] = "string";
+                }
+                else
+                {
+                   std::string paravalue = para[sparakey];
+                   v =  replace(v, parakey, paravalue);
+                }
+            }
+            
+		    return true;
+        }
+        catch(...)
+        {
+            return false;
+        }
+    }
+
+    bool DmpPrintLayer::ReadXmlValue(boost::property_tree::ptree &pt,std::string& v, const char* key,
+     map<string,string>& para, map<string,string>& paraList)
+    {
+         try
+        {
+            string xmlattrkey = key;
+            v = pt.get<std::string>(xmlattrkey,""); 
+            if(v.find_first_of('#') ==0 && v.find_last_of('#') == v.length()-1)
+            {
+                v = replace(v, "#", "");
+                if(para.size() ==0)
+                {
+                   paraList[v] = "bool";
+                }
+                else
+                {
+                   v =  para[v] ;
+                }
+            }
+           
+		    return true;
+        }
+        catch(...)
+        {
+            return false;
+        }
+    }
+
+}

+/**************************************************************************
+* file:              dmpprintlayer.h
+
+* Author:            qingxiongf
+* Date:              2022-01-27 15:21:25
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpprintlayer_h__
+#define __dmpprintlayer_h__
+#include <string>
+#include <memory.h>
+#include <cairo/cairo-pdf.h>
+#include <cairo/cairo-svg.h>
+#include <boost/property_tree/ptree.hpp> 
+#include <boost/property_tree/xml_parser.hpp> 
+#include <boost/typeof/typeof.hpp>
+#include "clsCrSurf.h"
+#include "dmpprintparameter.h"
+#include "../dmpwmsparameters.h"
+using namespace DmapCore_30;
+using namespace std;
+namespace DmpWms
+{
+    class DmpPrintLayer
+    {
+    public:
+        std::string id_;
+
+        std::string title_;
+
+        std::string layerType_;
+
+        //背景颜色
+        int backColor_;
+
+        //边框颜色
+        int frameColor_;
+        //边框类型
+        int frameType_;
+
+        int localtionX_;
+
+        int localtionY_;
+
+        bool showbound_ = false;
+
+        double  boundSize_ = 0;
+
+    public:
+      //  virtual bool InitNodeClass();
+        virtual bool DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format) = 0;
+
+        virtual bool  ReadXML(boost::property_tree::ptree &pt, shared_ptr<DmpPrintParameter> pPrintParameter, 
+        std::string& errorstr, map<string,string>& para, map<string,string>& paraList)= 0;
+
+        bool DrawBound(clsCrSurf* pClsCS,double width, double height);
+       
+        bool ReadXmlAttribute(boost::property_tree::ptree &pt,double& v, const char* key,map<string,string>& para, map<string,string>& paraList);
+
+        bool ReadXmlAttribute(boost::property_tree::ptree &pt,int& v, const char* key,map<string,string>& para, map<string,string>& paraList);
+
+        bool ReadXmlAttribute(boost::property_tree::ptree &pt,std::string& v, const char* key,map<string,string>& para, map<string,string>& paraList);
+
+        bool ReadXmlAttribute(boost::property_tree::ptree &pt,bool& v, const char* key,map<string,string>& para, map<string,string>& paraList);
+
+        bool ReadXmlColorAttribute(boost::property_tree::ptree &pt,int& r, int& g, int& b, const char* key,map<string,string>& para, map<string,string>& paraList);
+        
+        bool ReadXmlValue(boost::property_tree::ptree &pt,std::string& v, const char* key,map<string,string>& para, map<string,string>& paraList);
+
+        shared_ptr<clsCrSurf> CreateSurface(int width, int height, DmpWmsParameters::Format format);
+
+        std::string replace(std::string strsrc, std::string strfind, std::string strrep);
+    };
+}
+
+#endif // __dmpprintlayer_h__

+/**************************************************************************
+* file:              dmpprintlayout.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-25 15:12:38
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpprintlayout.h"
+namespace DmpWms
+{
+   bool DmpPrintLayout::DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format)
+     {
+         for(size_t i =0; i< this->data.size(); i++)
+         {
+             shared_ptr<DmpPrintLayer> printlayer = this->data.at(i);
+             printlayer->DrawData(pClsCS,format);
+         }
+
+         DrawBound(pClsCS);
+         return true;
+     }
+
+     bool DmpPrintLayout::ReadXML(boost::property_tree::ptree &pt, shared_ptr<DmpPrintParameter> pPrintParameter,
+        string& errorstr, map<string,string>& para, map<string,string>& paraList)
+     {
+         
+         try
+         {
+             boost::property_tree::ptree ptlayouts = pt.get_child("layouts");
+             for (boost::property_tree::ptree::iterator pos = ptlayouts.begin(); pos != ptlayouts.end(); ++pos)
+             {
+                 string type;
+                 boost::property_tree::ptree ptlayout = pos->second;
+                 this->ReadXmlAttribute(ptlayout, type, "type",para,paraList);
+                 bool result = true;
+                 if (type == "text")
+                 {
+                     shared_ptr<DmpPrintLayer> layer(new DmpPrintText());
+                     result = layer->ReadXML(ptlayout, pPrintParameter, errorstr,para,paraList);
+                     this->data.push_back(layer);
+                 }
+                 else if (type == "dmapservice")
+                 {
+                     shared_ptr<DmpPrintLayer> layer(new DmpPrintWMSService());
+                      result = layer->ReadXML(ptlayout, pPrintParameter, errorstr,para,paraList);
+                    this->data.push_back(layer);
+                 }
+                 else if (type == "scale")
+                 {
+                     shared_ptr<DmpPrintLayer> layer(new DmpPrintScale());
+                     result = layer->ReadXML(ptlayout, pPrintParameter, errorstr,para,paraList);
+                     this->data.push_back(layer);
+                 }
+                 else if (type == "compass")
+                 {
+                     shared_ptr<DmpPrintLayer> layer(new DmpPrintCompass());
+                     result = layer->ReadXML(ptlayout, pPrintParameter, errorstr,para,paraList);
+                     this->data.push_back(layer);
+                 }
+                 else if (type == "rectangle" || type == "rect")
+                 {
+                     shared_ptr<DmpPrintLayer> layer(new DmpPrintRect());
+                     result = layer->ReadXML(ptlayout, pPrintParameter, errorstr,para,paraList);
+                     this->data.push_back(layer);
+                 }
+                 else
+                 {
+                     errorstr = "布局元素错误，layout 值为（text,dmapservice,scale,compass）";
+                     result = false;
+                 }
+             }
+         }
+         catch (const std::exception &e)
+         {
+         }
+
+         return true;
+     }
+
+     bool  DmpPrintLayout::DrawBound(clsCrSurf* pClsCS)
+     {
+        cairo_t *cr = pClsCS->m_pCr;
+        //cairo_set_antialias(pClsCS->m_pCr,cairo_antialias_t::CAIRO_ANTIALIAS_BEST);
+        cairo_set_source_rgb (cr, 0, 0, 0);
+        cairo_set_line_width (cr, 1);
+
+        cairo_rectangle (cr, localtionX_, localtionY_, width_, height_);
+        cairo_stroke_preserve (cr);
+        return true;
+     }
+}

+/**************************************************************************
+* file:              dmpprintlayout.h
+
+* Author:            qingxiongf
+* Date:              2022-01-25 15:12:34
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpprintlayout_h__
+#define __dmpprintlayout_h__
+#include "dmpprintlayer.h"
+#include "dmpprintrect.h"
+#include "dmpprintscale.h"
+#include "dmpprinttext.h"
+#include "dmpprintcompass.h"
+#include "dmpprintwmsservice.h"
+#include <vector>
+namespace DmpWms
+{
+    
+    class DmpPrintLayout :public DmpPrintLayer
+    {
+        public:
+           
+            int width_;
+            int height_;
+            bool showbound_;
+            int bound_size_ =1;
+
+
+            vector<shared_ptr<DmpPrintLayer>> data;
+
+        public:
+
+            bool DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format);
+            bool ReadXML(boost::property_tree::ptree &pt, shared_ptr<DmpPrintParameter> pPrintParameter, 
+                string& errorstr, map<string,string>& para, map<string,string>& paraList);
+        private:
+            bool  DrawBound(clsCrSurf* pClsCS);
+          
+    };
+}
+
+#endif // __dmpprintlayout_h__
+
+

+/**************************************************************************
+* file:              dmpprintparameter.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-27 16:22:44
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpprintparameter.h"
+
+namespace DmpWms
+{
+    void DmpPrintParameter::InitParameter(double l0, double r0, double t0, double b0, int w0, int h0)
+    {
+        // if(rect)
+        {
+            right = r0;
+            left = l0;
+            top = t0;
+            bottom = b0;
+            width = w0;
+            height = h0;
+
+            double w = right - left;
+            double h = top - bottom;
+
+            if ((w > pow(10, 12)) || (w < pow(10, -12)))
+                return;
+            if ((h > pow(10, 12)) || (h < pow(10, -12)))
+                return;
+
+            long double R1 = width / w;
+            long double R2 = height / h;
+            double r = R1 < R2 ? R1 : R2;
+            if ((r > pow(10, 12)) || (r < pow(10, -12)))
+                return;
+
+            // m_dR = R1 < R2 ? R1 : R2;
+            m_dR = r;
+            m_dXdis = width / 2.0 - m_dR * (right + left) / 2.0;
+            m_dYdis = height / 2.0 + m_dR * (top + bottom) / 2.0;
+
+            isWGS84 = left <= 180 && right < 180 &&
+                      left >= -180 && right >= -180 &&
+                      top < 90 && bottom < 90;
+
+            double scaleDenominator = 0;
+            if (isWGS84)
+            {
+                scaleDenominator = (resolution / oneInchInLayoutUnits) * (1 / r) * 111000;
+                // m_dR = r *(96 / 0.0254) *111000 ;//111000 为赤道1经度等于 111000米
+            }
+            else
+            {
+                scaleDenominator = (resolution / oneInchInLayoutUnits) * 1 / r;
+            }
+        }
+    }
+}

+/**************************************************************************
+* file:              dmpprintparameter.h
+
+* Author:            qingxiongf
+* Date:              2022-01-27 16:22:41
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpprintparameter_h__
+#define __dmpprintparameter_h__
+#include <math.h>
+#include "dmpproject.h"
+#include <memory>
+#include <map>
+using namespace std;
+namespace DmpWms
+{
+    class DmpPrintParameter
+    {
+     public:
+        const DmpProject* pWmsService = nullptr;
+
+        bool  isWGS84 = false;
+        double dWgs = 111000;
+        double scaleDenominator = 0; 
+        int width =0;
+        int height =0;
+
+        double left = 0;
+        double right = 0;
+        double top =0;
+        double bottom =0;
+
+        double oneInchInLayoutUnits = 0.0254;
+	    double resolution = 96;
+
+	    double m_dR = 0;
+	    double m_dXdis = 0;//width / 2.0 - m_dR * (right + left) / 2.0;
+	    double m_dYdis = 0;//height / 2.0 + m_dR * (top + bottom) / 2.0;
+
+        map<string,string> params;
+    public:
+        void InitParameter(double l0,double r0,double t0,double b0, int w0,int h0);
+
+    };
+}
+
+#endif // __dmpprintparameter_h__

+/**************************************************************************
+* file:              dmpprintrect.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-27 15:46:35
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpprintrect.h"
+
+namespace DmpWms
+{
+    bool DmpPrintRect::DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format)
+    {
+        cairo_t *cr = pClsCS->m_pCr;
+        //cairo_set_antialias(pClsCS->m_pCr,cairo_antialias_t::CAIRO_ANTIALIAS_BEST);
+        cairo_set_source_rgb (cr, 0, 0, 0);
+        cairo_set_line_width (cr, boundSize_);
+
+        cairo_rectangle (cr, localtionX_, localtionY_, width_, height_);
+        cairo_stroke_preserve (cr);
+        return true;
+    }
+
+    bool DmpPrintRect::ReadXML(boost::property_tree::ptree &pt,shared_ptr<DmpPrintParameter> pPrintParameter, 
+    string& errorstr,map<string,string>& para, map<string,string>& paraList)
+     {
+          //this->ReadXmlAttribute(bound_node, showbound, "show");
+        this->ReadXmlAttribute(pt, localtionX_, "localtion_x",para,paraList);
+        this->ReadXmlAttribute(pt, localtionY_, "localtion_y",para,paraList);
+
+        this->ReadXmlAttribute(pt, width_, "width",para,paraList);
+        this->ReadXmlAttribute(pt, height_, "height",para,paraList);
+
+        this->ReadXmlAttribute(pt, boundSize_, "bound_size",para,paraList);
+        this->pPrintParameter_ = pPrintParameter;
+
+        return true;
+     }
+
+}

+/**************************************************************************
+* file:              dmpprintrect.h
+
+* Author:            qingxiongf
+* Date:              2022-01-27 15:46:31
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpprintrect_h__
+#define __dmpprintrect_h__
+#include "dmpprintlayer.h"
+namespace DmpWms
+{
+    class DmpPrintRect :public DmpPrintLayer
+    {
+        public:
+            shared_ptr<DmpPrintParameter> pPrintParameter_ = nullptr;
+            bool DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format);
+            bool ReadXML(boost::property_tree::ptree &pt,shared_ptr<DmpPrintParameter> pPrintParameter,
+             string& errorstr,map<string,string>& para, map<string,string>& paraList);
+       
+        private:
+            int width_ =0;
+            int height_ =0;
+           
+    };
+}
+
+#endif // __dmpprintrect_h__

+/**************************************************************************
+* file:              dmpprintscale.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-27 17:24:56
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpprintscale.h"
+
+
+namespace DmpWms
+{
+    bool DmpPrintScale::DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format)
+    {
+        bool isImage = true;
+        int width = 1000;
+        int height = 30;
+        double xdis = 0;
+
+        if(this->pPrintParameter_->isWGS84)
+        {
+            xdis =  this->pPrintParameter_->dWgs/this->pPrintParameter_->m_dR ;
+        }
+        else
+        {
+            xdis = 1/this->pPrintParameter_->m_dR;
+        }
+       // double d = (resolution / oneInchInLayoutUnits)*(1/this->scaleDenominator);
+        double xdis_100 = xdis*100;
+        int ld = (int)log10(xdis_100);
+        double hd = xdis_100/pow(10,ld);
+        
+        double hh = 100;
+        if(hd>=1 && hd<2)
+        {
+            hh = 100;
+        }
+        else if(hd>=2 && hd<3.5)
+        {
+            hh = 200;
+        }
+        else if(hd>=3.5 && hd<7.5)
+        {
+            hh = 500;
+        }
+        else
+        {
+            hh = 1000;
+        }
+
+        double px_width = (hh/hd);
+
+        string dw = "M";
+        string dw2 = "M";
+        int v =hh*pow(10,ld - 2);
+
+        if(v >= 1000)
+        {
+            char buff[100] = {0};
+            v = v/1000;
+            sprintf(buff,"%d KM",v);
+            dw = buff;
+            v = v*2;
+            sprintf(buff,"%d KM",v);
+            dw2 = buff;
+        }
+        else
+        {
+            char buff[100] = {0};
+            sprintf(buff,"%d M",v);
+            dw = buff;
+
+ 
+            sprintf(buff,"%d M",v*2);
+            dw2 = buff;
+        }
+
+        shared_ptr<clsCrSurf> mClsSurfDC = this->CreateSurface((int)width, (int)height, format);
+
+        cairo_t *cr = mClsSurfDC->m_pCr; //创建画笔
+        int startPix = 10;
+        for(int i =0; i<2; i++)
+        {
+            cairo_set_source_rgb(cr, 0, 0, 0); //设置画笔颜色，也就是红，绿，蓝，这里设置成绿色。
+            cairo_move_to(cr, startPix + px_width*i, 20);         //三角形第一个顶点
+            cairo_line_to(cr, startPix + px_width*i, 25);         //三角形第二个顶点
+            cairo_line_to(cr, startPix + px_width*(i+1), 25);   //三角形第三个顶点
+            cairo_line_to(cr, startPix + px_width*(i+1), 20);   //三角形第三个顶点
+            cairo_set_line_width(cr, 1);
+            cairo_stroke(cr);
+
+           // const char *str = "N";
+            cairo_select_font_face(cr, "宋体", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+            cairo_set_font_size(cr, 10);
+            //cairo_move_to(cr, 8, 15);
+
+            cairo_move_to(cr, startPix + px_width*(i+1) - 15, 15);
+            if(i ==0)
+            {
+                  cairo_show_text(cr, dw.c_str());
+            }
+            else
+             {
+                cairo_show_text(cr, dw2.c_str());
+             }
+        }
+
+        //const char *str = "0";
+        cairo_move_to(cr, startPix -3 , 15);
+        cairo_show_text(cr, "0");
+          
+        cairo_set_source_surface(pClsCS->m_pCr, mClsSurfDC->m_pSurf, localtionX_, localtionY_);
+        cairo_paint(pClsCS->m_pCr);
+        return true;
+    }
+
+    bool DmpPrintScale::ReadXML(boost::property_tree::ptree &pt,shared_ptr<DmpPrintParameter> pPrintParameter,
+     string& errorstr, map<string,string>& para, map<string,string>& paraList)
+     {
+        this->ReadXmlAttribute(pt,localtionX_,"localtion_x",para,paraList);
+        this->ReadXmlAttribute(pt,localtionY_,"localtion_y",para,paraList);
+       // this->ReadXmlAttribute(pt,type,"type");
+
+        this->ReadXmlAttribute(pt, boundSize_, "bound_size",para,paraList);
+        this->ReadXmlAttribute(pt, showbound_, "showBound",para,paraList);
+
+        this->pPrintParameter_ = pPrintParameter;
+
+        return true;
+     }
+
+
+}

+/**************************************************************************
+* file:              dmpprintscale.h
+
+* Author:            qingxiongf
+* Date:              2022-01-27 17:24:52
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpprintscale_h__
+#define __dmpprintscale_h__
+
+#include "dmpprintlayer.h"
+namespace DmpWms
+{
+    class DmpPrintScale :public DmpPrintLayer
+    {
+        public:
+            string  serviceName;
+            shared_ptr<DmpPrintParameter> pPrintParameter_ = nullptr;
+        public:
+            //bool DrawImage();
+            bool DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format);
+            bool ReadXML(boost::property_tree::ptree &pt,shared_ptr<DmpPrintParameter> pPrintParameter, 
+            string& errorstr, map<string,string>& para, map<string,string>& paraList);
+    };
+}
+#endif // __dmpprintscale_h__

+/**************************************************************************
+* file:              dmpprinttext.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-27 16:36:43
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpprinttext.h"
+namespace DmpWms
+{
+     bool DmpPrintText::DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format)
+     {
+        cairo_set_antialias(pClsCS->m_pCr,cairo_antialias_t::CAIRO_ANTIALIAS_BEST);
+		cairo_set_source_rgb(pClsCS->m_pCr, r_, g_, b_);
+		cairo_select_font_face(pClsCS->m_pCr, font_.c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+		cairo_set_font_size(pClsCS->m_pCr,fontSize_);
+
+		cairo_move_to(pClsCS->m_pCr,localtionX_, localtionY_);
+
+		cairo_show_text(pClsCS->m_pCr, text_.c_str());
+     
+        return true;
+     }
+
+     bool DmpPrintText::ReadXML(boost::property_tree::ptree &pt, shared_ptr<DmpPrintParameter> pMapParameter,
+     string& errorstr, map<string,string>& para, map<string,string>& paraList)
+     {
+         try
+         {
+             this->ReadXmlAttribute(pt, localtionX_, "localtion_x",para,paraList);
+             this->ReadXmlAttribute(pt, localtionY_, "localtion_y",para,paraList);
+
+             this->ReadXmlAttribute(pt, boundSize_, "bound_size",para,paraList);
+             this->ReadXmlAttribute(pt, showbound_, "showBound",para,paraList);
+             boost::property_tree::ptree pttext = pt.get_child("text");
+             this->ReadXmlColorAttribute(pttext, r_, g_, b_, "fontcolor",para,paraList);
+             this->ReadXmlAttribute(pttext, text_, "title",para,paraList);
+             this->ReadXmlAttribute(pttext, fontSize_, "fontsize",para,paraList);
+             this->ReadXmlAttribute(pttext, font_, "font",para,paraList);
+             this->ReadXmlAttribute(pttext, isBold_, "bold",para,paraList);
+             return true;
+         }
+         catch(const std::exception& e)
+         {
+            return false;
+         }
+         return false;
+     }
+}

+/**************************************************************************
+* file:              dmpprinttext.h
+
+* Author:            qingxiongf
+* Date:              2022-01-27 16:36:39
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#ifndef __dmpprinttext_h__
+#define __dmpprinttext_h__
+
+#include "dmpprintlayer.h"
+namespace DmpWms
+{
+   class DmpPrintText : public DmpPrintLayer
+   {
+       private:
+
+            int r_,g_,b_;
+            std::string text_;
+            std::string font_;
+            int fontSize_;
+            bool isBold_;
+
+        public:
+           bool DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format);
+           bool ReadXML(boost::property_tree::ptree &pt,shared_ptr<DmpPrintParameter> pMapParameter, 
+           string& errorstr, map<string,string>& para, map<string,string>& paraList);
+   };
+}
+
+#endif // __dmpprinttext_h__

+/**************************************************************************
+* file:              dmpprintwmsservice.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-28 15:31:15
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpprintwmsservice.h"
+
+namespace DmpWms
+{
+    bool DmpPrintWMSService::DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format)
+    {
+        try
+		{
+			shared_ptr<DmpWmsRenderer> _WmsRenderer(new DmpWmsRenderer( height_, width_));
+            
+            shared_ptr<clsCrSurf> mClsSurfDC = this->CreateSurface((int)width_, (int)height_, format);
+
+            
+           // cairo_surface_set_fallback_resolution(  _map->GetSurfDC()->m_pSurf,900,900);
+
+           // if (this->m_mapWmsServer.find(serviceName) != this->m_mapWmsServer.end())
+            {
+                //shared_ptr<WMSServer> wmsServer = this->m_mapWmsServer[serviceName];
+                _WmsRenderer->AddWmsMapLayers(project_);
+
+                //Rect *rect_service = project_->GetExtent();
+
+                shared_ptr<Rect> rect(new Rect(boxY2_, boxX2_, boxY1_, boxX1_));
+                _WmsRenderer->SetExtent(rect);
+                _WmsRenderer->GetMap(nullptr, nullptr, mClsSurfDC.get());
+
+                if (this->showMapLegend_)
+                {
+                    DrawLegend(mClsSurfDC.get(), _WmsRenderer, format, localtionX_, localtionY_, this->width_, this->height_);
+                }
+
+                cairo_set_source_surface(pClsCS->m_pCr, mClsSurfDC->m_pSurf, localtionX_, localtionY_);
+                cairo_paint(pClsCS->m_pCr);
+                if(this->showCoord_)
+                {
+                    DrawCoord(pClsCS, _WmsRenderer, format, localtionX_, localtionY_, this->width_, this->height_);
+                }
+
+                DrawBound(pClsCS,  width_,  height_);
+            }
+
+            
+            return true;
+		}
+		catch (const std::exception &e)
+		{
+
+			std::cerr << " Refresh " << e.what() << '\n';
+			return false;
+		}
+        return false;
+    }
+
+     /*bool DmpPrintWMSService::DrawCoord(clsCrSurf* pClsCS,PrintOutputFormat format)
+     {
+         format.
+     }*/
+     bool DmpPrintWMSService::DrawCoord(clsCrSurf* pClsCS, shared_ptr<DmpWmsRenderer>  _map,DmpWmsParameters::Format format,
+     int locationX,int locationY,int width,int height)
+     {
+        if(pLegendParamater_ == nullptr)
+            return false;
+        shared_ptr<Rect> rect = _map->GetExtent();
+        if(rect == nullptr)
+            return false;
+
+        //double x0 =(x - m_dXdis)/ m_dR ;
+		//double y0 = ( y + m_dYdis)/m_dR ;
+        double x_width = rect->m_dRight -  rect->m_dLeft;
+        double dx =  100/ _map->m_dR;
+
+    
+         int ld = (int)log10(dx);
+        double hd = dx/pow(10,ld);
+        
+        double hh = 1;
+
+        if(hd>=1 && hd<2) hh = 1;
+        else if(hd>=2 && hd<3.5)  hh = 2;
+        else if(hd>=3.5 && hd<7.5) hh = 5;
+        else hh = 10;
+
+        dx = hh * pow(10,ld);
+        double xbegin = ((int) (rect->m_dLeft/dx) +1) *  dx;
+        cairo_t *cr = pClsCS->m_pCr; //创建画笔
+
+        cairo_set_source_rgb(cr, 0, 0, 0);
+        char drawText[100]= {0};
+        shared_ptr<cairo_text_extents_t> pCrExtents(new cairo_text_extents_t());
+        for(double pos_x = xbegin; pos_x <=  rect->m_dRight;  pos_x += dx )
+        {
+            double x0 =  _map->m_dR * pos_x + _map->m_dXdis + locationX;
+            sprintf(drawText, "%.4f", pos_x);
+            DoubleRemoveZero(drawText);
+		   // double y0 = -m_dR * y + m_dYdis;
+             //设置画笔颜色，也就是红，绿，蓝，这里设置成绿色。
+
+            cairo_move_to(cr, x0, locationY);         
+            cairo_line_to(cr, x0, locationY -5);        
+            cairo_set_line_width(cr, 1.5);
+            cairo_stroke(cr);
+
+            cairo_move_to(cr, x0, locationY + height);         
+            cairo_line_to(cr, x0, locationY+ height +5);        
+            cairo_set_line_width(cr, 1.5);
+            cairo_stroke(cr);
+
+         
+            cairo_select_font_face(cr, "宋体", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+            cairo_set_font_size(cr, 10);
+            //cairo_move_to(cr, 8, 15);
+
+            cairo_text_extents(cr,  drawText, pCrExtents.get());
+
+            cairo_move_to(cr, x0 - pCrExtents->width/2 ,locationY - 3 - pCrExtents->height);
+            cairo_show_text(cr, drawText);
+          
+            cairo_move_to(cr, x0 - pCrExtents->width/2 ,locationY + height + 3 + 1.5* pCrExtents->height);
+            cairo_show_text(cr, drawText);
+        }
+
+
+       /// 画Y轴
+
+       //double y_height = rect->m_dTop -  rect->m_dBottom;
+
+       double ybegin = ((int) (rect->m_dBottom/dx) +1) *  dx;
+        
+        
+        for(double pos_y = ybegin; pos_y <=  rect->m_dTop;  pos_y += dx )
+        {
+            double y0 = - _map->m_dR * pos_y + _map->m_dYdis + locationY;
+            sprintf(drawText, "%.4f", pos_y);
+            DoubleRemoveZero(drawText);
+		   // double y0 = -m_dR * y + m_dYdis;
+             //设置画笔颜色，也就是红，绿，蓝，这里设置成绿色。
+            cairo_move_to(cr,locationX -6,  y0);         
+            cairo_line_to(cr,locationX, y0);        
+            cairo_set_line_width(cr, 1.5);
+            cairo_stroke(cr);
+
+            cairo_move_to(cr,  locationX + width, y0);         
+            cairo_line_to(cr,  locationX+ width +6,y0);        
+            cairo_set_line_width(cr, 1.5);
+            cairo_stroke(cr);
+
+         
+            cairo_select_font_face(cr, "宋体", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+            cairo_set_font_size(cr, 10);
+           
+            
+            cairo_text_extents(cr,  drawText, pCrExtents.get());
+     
+            cairo_move_to(cr, locationX - pCrExtents->height -3 ,y0 + pCrExtents->width/2);
+            cairo_rotate(cr, -3.141592/2);
+            cairo_show_text(cr, drawText);
+            cairo_rotate(cr, 3.141592/2);
+          
+            cairo_move_to(cr, locationX + width + 3 + 1.5*pCrExtents->height ,y0 + pCrExtents->width/2);
+            cairo_rotate(cr, -3.141592/2);
+            cairo_show_text(cr, drawText);
+            cairo_rotate(cr, 3.141592/2);
+        }
+        return true;
+     }
+
+     void DmpPrintWMSService::DoubleRemoveZero(char* str)
+     {
+         int  len = strlen(str);
+         for(int i=0; i< len; i++)
+         {
+             if(str[i] == '.')
+               break;
+             if(i ==len -1)
+                return;
+         }
+        
+         for(int i=len -1; i>0; i--)
+         {
+             if(str[i] == '0')
+             {
+                 str[i] = 0;
+             }
+             else if(str[i] == '.')
+             {
+                 str[i] = 0;
+                 break;
+             }
+             else
+             {
+                 break;
+             }
+         }
+     }
+
+     bool DmpPrintWMSService::DrawLegend(clsCrSurf* pClsCS,  shared_ptr<DmpWmsRenderer>  _map, DmpWmsParameters::Format format,
+     int locationX,int locationY,int _width,int _height)
+     {
+
+        int height = 1000; 
+        int width = 1800;
+
+         shared_ptr<clsCrSurf> mClsSurfDC = this->CreateSurface(width_, height_, format);
+        // shared_ptr<legendParamater> pLegendParamater_(new legendParamater() );
+         pLegendParamater_->m_dScaleDenominator = _map->m_dScaleDenominator;
+
+         _map->GetMapLegend(pLegendParamater_,mClsSurfDC.get());
+
+        pLegendParamater_->next(nullptr);
+
+        shared_ptr<clsCrSurf> mClsSurfDC2 = this->CreateSurface(pLegendParamater_->max_pixXIndex+100, (int)pLegendParamater_->max_pixYIndex+15, format);
+       
+        
+        cairo_set_source_rgba (mClsSurfDC2->m_pCr, pLegendParamater_->back_r/255.0,
+         pLegendParamater_->back_g/255.0, pLegendParamater_->back_b/255.0, pLegendParamater_->back_a/255.0); 
+
+        cairo_rectangle (mClsSurfDC2->m_pCr, 3, 3, pLegendParamater_->max_pixXIndex + 100 -6, pLegendParamater_->max_pixYIndex + 10 );
+        cairo_fill_preserve(mClsSurfDC2->m_pCr);
+
+        cairo_set_source_rgb (mClsSurfDC2->m_pCr, 0, 0, 0);
+        cairo_set_line_width (mClsSurfDC2->m_pCr, 1);
+        cairo_stroke(mClsSurfDC2->m_pCr);
+
+        
+        cairo_set_source_surface(mClsSurfDC2->m_pCr, mClsSurfDC->m_pSurf,0, 0);
+		cairo_paint(mClsSurfDC2->m_pCr);
+
+        cairo_set_source_surface(pClsCS->m_pCr, mClsSurfDC2->m_pSurf,_width - pLegendParamater_->max_pixXIndex - 100- 10,
+            _height - pLegendParamater_->max_pixYIndex -20);
+		cairo_paint(pClsCS->m_pCr);
+
+        return true;
+
+     }
+
+ 
+     bool DmpPrintWMSService::ReadXML(boost::property_tree::ptree &pt,shared_ptr<DmpPrintParameter> pPrintParameter,
+      string& errorstr, map<string,string>& para, map<string,string>& paraList)
+     {
+         try
+         {
+             this->ReadXmlAttribute(pt, localtionX_, "localtion_x",para,paraList );
+             this->ReadXmlAttribute(pt, localtionY_, "localtion_y",para,paraList);
+             this->ReadXmlAttribute(pt, width_, "width",para,paraList);
+             this->ReadXmlAttribute(pt, height_, "height",para,paraList);
+             this->ReadXmlAttribute(pt, showCoord_, "showCoord",para,paraList);
+             this->ReadXmlAttribute(pt, boundSize_, "bound_size",para,paraList);
+             this->ReadXmlAttribute(pt, showbound_, "showBound",para,paraList);
+
+            // rapidxml::xml_node<char> *text_node = node->first_node("legend");
+            
+             try
+             {
+                 boost::property_tree::ptree ptlegend = pt.get_child("legend");
+                 shared_ptr<legendParamater> pLegendParamater_0(new legendParamater());
+                 pLegendParamater_ = pLegendParamater_0;
+
+                 this->ReadXmlColorAttribute(ptlegend, pLegendParamater_->r, pLegendParamater_->g, pLegendParamater_->b, "fontcolor",para,paraList);
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->title, "title",para,paraList);
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->fontSize, "fontsize",para,paraList);
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->font, "font",para,paraList);
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->isbold, "bold",para,paraList);
+                 this->ReadXmlColorAttribute(ptlegend, pLegendParamater_->back_r, pLegendParamater_->back_g, pLegendParamater_->back_b, "backgroundcolor",para,paraList);
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->back_a, "backgroundalpha",para,paraList);
+
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->showclassification, "showclassification",para,paraList);
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->rowspacing, "rowspacing",para,paraList);
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->size_x, "size_x",para,paraList);
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->size_y, "size_y",para,paraList);
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->row_maxsize, "row_maxsize",para,paraList);
+                 showMapLegend_ = true;
+             }
+             catch(...)
+             {
+                 showMapLegend_ = false;
+             }
+
+             this->boxX1_ = pPrintParameter->left;
+             this->boxX2_ = pPrintParameter->right;
+             this->boxY1_ = pPrintParameter->bottom;
+             this->boxY2_ = pPrintParameter->top;
+
+             this->project_ = pPrintParameter->pWmsService;
+
+             pPrintParameter->InitParameter(this->boxX1_, this->boxX2_, this->boxY1_, this->boxY2_, this->width_, this->height_);
+         }
+         catch(const std::exception& e)
+         {
+            showMapLegend_ = false;
+           return false;
+         }
+        return true;
+     }
+}

+/**************************************************************************
+* file:              dmpprintwmsservice.h
+
+* Author:            qingxiongf
+* Date:              2022-01-28 15:31:10
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpprintwmsservice_h__
+#define __dmpprintwmsservice_h__
+#include "dmpprintlayer.h"
+#include "dmpproject.h"
+#include "legendParamater.h"
+#include "../dmpwmsrenderer.h"
+using namespace DmapCore_30;
+
+namespace DmpWms
+{
+     class DmpPrintWMSService :public DmpPrintLayer
+    {
+        public:
+            int width_;
+            int height_;
+            string  serviceName_;
+            //不透明度
+            double  opacity_;
+
+            const DmpProject* project_;
+
+            double boxX1_, boxY1_, boxX2_, boxY2_;
+
+           // clsLock m_clsMapLock;
+
+            bool showMapLegend_ = false;
+
+            bool showCoord_ = false;
+
+            shared_ptr<legendParamater> pLegendParamater_ = nullptr;
+
+            //bool DrawImage();
+            bool DrawData(clsCrSurf* pClsCS,DmpWmsParameters::Format format);
+            
+            bool ReadXML(boost::property_tree::ptree &pt, shared_ptr<DmpPrintParameter> pPrintParameter,
+            string& errorstr, map<string,string>& para, map<string,string>& paraList);
+        private:
+
+            bool DrawLegend(clsCrSurf* pClsCS,  shared_ptr<DmpWmsRenderer>  _map, DmpWmsParameters::Format format,int locationX,int localtionY,int width,int height);
+         
+            bool DrawCoord(clsCrSurf* pClsCS, shared_ptr<DmpWmsRenderer>  _map, DmpWmsParameters::Format format,int locationX,int localtionY,int width,int height);
+
+            bool DrawCoordXText(clsCrSurf* pClsCS,shared_ptr<DmpWmsRenderer>  _map, 
+                 int locationX,int localtionY,int width,int height);
+            
+            void DoubleRemoveZero(char* str);
+    };
+}
+
+#endif // __dmpprintwmsservice_h__