print

@@ -293,32 +293,22 @@ bool DmpVectorLayer::setDataProvider(const std::string &provider)
 	return true;
 }
 
-shared_ptr<DmpVectorVacuateLayer> 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;
-		}
-*/
 
+shared_ptr<DmpVectorVacuateLayer> DmpVectorLayer::GetCurrentScaleTable(double dx)
+{
+	dx *= 2;
 	for (int i = 0; i < this->vacuateLayers_.size(); i++)
 	{
 		shared_ptr<DmpVectorVacuateLayer> vacuateLayer = this->vacuateLayers_[i];

@@ -56,7 +56,7 @@ class CORE_EXPORT DmpVectorLayer : public DmpMapLayer
     shared_ptr<DmapCore_30::Renderer> GetRenderer30() { return renderer_30_; }
     vector<shared_ptr<DmpVectorVacuateLayer>> vacuateLayers() const { return vacuateLayers_; }
     shared_ptr<DmpVectorVacuateLayer> GetCurrentScaleTable(double dx);
-    void ApplendCurrentScaleTable(shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer){vacuateLayers_.push_back(pVectorVacuateLayer);}
+    void ApplendCurrentScaleTable(shared_ptr<DmpVectorVacuateLayer> pVectorVacuateLayer);
 
     std::string  schema() { return schema_;}
     std::string  geom()  { return geom_;} 

@@ -30,6 +30,8 @@ class CORE_EXPORT DmpVectorVacuateLayer
 
        double GeDisPix();
 
+       double dis() const { return m_ddis; }
+
        std::string tableName()const { return m_tableName;}
 
        std::string connectStr() const {return connectstr_;}

@@ -22,7 +22,15 @@ SET (MAPSERVER_SRCS
   wms/dmpwmsgetmap.cpp
   wms/dmpwmsserviceinfo.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/dmpeditservice.cpp
   mapping/dmpmappingparameters.cpp
@@ -49,7 +57,15 @@ SET (MAPSERVER_HDRS
   wms/dmpwmsgetmap.h
   wms/dmpwmsserviceinfo.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/dmpeditservice.h
   mapping/dmpmappingparameters.h

-/**************************************************************************
-* file:              dmpprintlayout.cpp
-
-* Author:            qingxiongf
-* Date:              2022-01-25 15:12:38
-* Email:             qingxiongf@chinadci.com
-* copyright:         广州城市信息研究所有限公司
-***************************************************************************/
-#include "dmpprintlayout.h"
-
-namespace DmpWms
-{
-
-}
\ No newline at end of file

@@ -753,6 +753,11 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 		return true;
 	}
 
+	shared_ptr<Rect>  DmpWmsRenderer::GetExtent()
+	{
+		return m_pExtent;
+	}
+
 	bool DmpWmsRenderer::SetExtent(shared_ptr<Rect> rect)
 	{
 		m_pExtent = rect;

@@ -69,7 +69,7 @@ namespace DmpWms
 		bool DrawSimpleData(DataCollection* data, Renderer* renderer, clsCrSurf* pClsSurf);
 
 		//shared_ptr<Rect> GetFullExtent(bool bRecalculate); //加一个bool值,如果为false , 无需计算
-		//shared_ptr<Rect> GetExtent();
+		shared_ptr<Rect> GetExtent();
 		bool SetExtent(shared_ptr<Rect> rect);
 		bool GetParameters(double* pR, double* pXdis, double* pYdis);
 		bool SetParameters(double r = -1, double xdis = 0, double ydis = 0);

 /**************************************************************************
-* file:              dmpprint.cpp
+* file:              dmpmapprint.cpp
 
 * Author:            qingxiongf
 * Date:              2022-01-20 18:50:40
 * Email:             qingxiongf@chinadci.com
 * copyright:         广州城市信息研究所有限公司
 ***************************************************************************/
-#include "dmpprint.h"
+#include "dmpmapprint.h"
 #include <unistd.h>
 #include <algorithm>
 #include <cairo/cairo-svg.h>
@@ -21,11 +21,12 @@ namespace DmpWms
 		return CAIRO_STATUS_SUCCESS;
 	}
 
-	DmpPrint::DmpPrint()
+	DmpMapPrint::DmpMapPrint()
 	{
+
 	}
 /*
-	bool DmpPrint::getPrint(std::string &responseData, DmpProject *project,const char* xml,string servername)
+	bool DmpMapPrint::getPrint(std::string &responseData, DmpProject *project,const char* xml,string servername)
     {
         string  result_msg;
 
@@ -149,7 +150,7 @@ namespace DmpWms
         return true;
     }
 
-	bool DmpPrint::getPrint( std::string &responseData, DmpProject* project,
+	bool DmpMapPrint::getPrint( std::string &responseData, DmpProject* project,
 			string servername,const char* printTemp,const char *bbox)
     {
         string  result_msg;
@@ -269,7 +270,7 @@ namespace DmpWms
     }
 
 
-	bool DmpPrint::getPrintTempFile(string &responseData,,const char* tempName, const char* bbox)
+	bool DmpMapPrint::getPrintTempFile(string &responseData,,const char* tempName, const char* bbox)
 	{
 		string path = "./template/";path += tempName; path += ".xml";
 
@@ -292,7 +293,7 @@ namespace DmpWms
 	}
 
 	
-	bool DmpPrint::getPrintLayout(AppendBuffer *ab,shared_ptr<WMSServer> pWmsServer,
+	bool DmpMapPrint::getPrintLayout(AppendBuffer *ab,shared_ptr<WMSServer> pWmsServer,
 		const char* xml,const char *bbox)
     {
         string  result_msg;
@@ -358,7 +359,7 @@ namespace DmpWms
 
     }
 
-	bool DmpPrint::ToPrint(AppendBuffer *ab)
+	bool DmpMapPrint::ToPrint(AppendBuffer *ab)
 	{
 		if(isPicture ==  PrintOutputFormat::SVG)
 		{
@@ -425,7 +426,7 @@ namespace DmpWms
 	}
 
 
-	bool DmpPrint::InitTemplateValue(string templateValue)
+	bool DmpMapPrint::InitTemplateValue(string templateValue)
 	{
 		
 		if (templateValue == "A4竖" || templateValue == "A4-hoch")
@@ -462,7 +463,7 @@ namespace DmpWms
 	}
 
 
-	bool DmpPrint::Test(AppendBuffer *ab,map<string, shared_ptr<WMSServer>> &mapWmsServer,string servername)
+	bool DmpMapPrint::Test(AppendBuffer *ab,map<string, shared_ptr<WMSServer>> &mapWmsServer,string servername)
 	{
 		//double scaleDenominator = 0;
 
@@ -601,7 +602,7 @@ namespace DmpWms
 	}
 
 
-double DmpPrint::RecalculateScale(double right, double left, double top, double bottom, double width, double height )
+double DmpMapPrint::RecalculateScale(double right, double left, double top, double bottom, double width, double height )
 {
 	double w = right - left;
 	double h = top - bottom;
@@ -644,7 +645,7 @@ double DmpPrint::RecalculateScale(double right, double left, double top, double
 	return scaleDenominator;
 }
 
-	string DmpPrint::GetFilePath(string path)
+	string DmpMapPrint::GetFilePath(string path)
 	{
 		char sz[200] = {0};
         if(GetCurrentFolderPath(sz, sizeof(sz)) > 0)
@@ -695,7 +696,7 @@ double DmpPrint::RecalculateScale(double right, double left, double top, double
 
 	}
 
-	int DmpPrint::GetCurrentFolderPath(char* processdir, size_t len)
+	int DmpMapPrint::GetCurrentFolderPath(char* processdir, size_t len)
 	{
         char* path_end;
         if (readlink("/proc/self/exe", processdir, len) <= 0)
@@ -711,7 +712,7 @@ double DmpPrint::RecalculateScale(double right, double left, double top, double
 
 
 
-	bool DmpPrint::DoSetBackGround(clsCrSurf *pClsCS, int iColor)
+	bool DmpMapPrint::DoSetBackGround(clsCrSurf *pClsCS, int iColor)
 	{
 		cairo_surface_t *surface = pClsCS->m_pSurf;
 		cairo_t *cr = pClsCS->m_pCr;

 /**************************************************************************
-* file:              dmpprint.h
+* file:              dmpmapprint.h
 
 * Author:            qingxiongf
 * Date:              2022-01-20 18:50:30
@@ -16,16 +16,17 @@
 #include <map>
 #include <math.h>
 #include "dmpproject.h"
-#include "dmpwmsrenderer.h"
+#include "../dmpwmsrenderer.h"
 
 #include "clsCrSurf.h"
 #include "clsRect.h"
 #include "clsUtil.h"
 using namespace std;
 using namespace DmapCore_30;
+
 namespace DmpWms
 {
-    class DmpPrint
+    class DmpMapPrint
     {
     private:
         std::string m_name;
@@ -51,7 +52,7 @@ namespace DmpWms
         bool ToPrint(std::string &responseData);
 
     public:
-        DmpPrint();
+        DmpMapPrint();
     
         bool getPrint(std::string &responseData, DmpProject* project, const char *xml, string servername);
         bool getPrint(std::string &responseData, DmpProject* project, const char *printTemp, const char *bbox);

+/**************************************************************************
+* 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)
+     {
+        this->ReadXmlAttribute(pt,localtionX_,"localtion_x");
+        this->ReadXmlAttribute(pt,localtionY_,"localtion_y");
+        //this->ReadXmlAttribute(pt,type,"type");
+
+        this->ReadXmlAttribute(pt, boundSize_, "bound_size");
+        this->ReadXmlAttribute(pt, showbound_, "showBound");
+
+        this->pPrintParameter_ = pPrintParameter;
+
+        return true;
+     }
+
+
+}
\ No newline at end of file

+/**************************************************************************
+* 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
+    {
+        private:
+            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);
+    };
+}
+
+#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;
+    }
+
+    bool DmpPrintLayer::ReadXmlAttribute(boost::property_tree::ptree &pt,double& v, const char* key)
+    {
+        try
+        {
+            string xmlattrkey = "<xmlattr>.";
+            xmlattrkey += key;
+            string value = pt.get<std::string>(xmlattrkey,"0"); 
+             v = atof(value.c_str());
+		    return true;
+        }
+        catch(...)
+        {
+            return false;
+        }
+    }
+
+     bool DmpPrintLayer::ReadXmlAttribute(boost::property_tree::ptree &pt,int& v, const char* key)
+    {
+        try
+        {
+            string xmlattrkey = "<xmlattr>.";
+            xmlattrkey += key;
+            string value = pt.get<std::string>(xmlattrkey,"0"); 
+             v = atoi(value.c_str());
+		    return true;
+        }
+        catch(...)
+        {
+            return false;
+        }
+    }
+
+     bool DmpPrintLayer::ReadXmlAttribute(boost::property_tree::ptree &pt,bool& v, const char* key)
+    {
+        try
+        {
+            string xmlattrkey = "<xmlattr>.";
+            xmlattrkey += key;
+            string value = pt.get<std::string>(xmlattrkey,"false"); 
+            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)
+    {
+        string color;
+        if(this->ReadXmlAttribute(pt, color, key))
+        {
+            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)
+    {
+         try
+        {
+            string xmlattrkey = "<xmlattr>.";
+            xmlattrkey += key;
+            v = pt.get<std::string>(xmlattrkey,""); 
+		    return true;
+        }
+        catch(...)
+        {
+            return false;
+        }
+    }
+
+    bool DmpPrintLayer::ReadXmlValue(boost::property_tree::ptree &pt,std::string& v, const char* key)
+    {
+         try
+        {
+            string xmlattrkey = key;
+            v = pt.get<std::string>(xmlattrkey,""); 
+		    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
+    {
+    protected:
+        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)= 0;
+
+        bool DrawBound(clsCrSurf* pClsCS,double width, double height);
+       
+        bool ReadXmlAttribute(boost::property_tree::ptree &pt,double& v, const char* key);
+
+        bool ReadXmlAttribute(boost::property_tree::ptree &pt,int& v, const char* key);
+
+        bool ReadXmlAttribute(boost::property_tree::ptree &pt,std::string& v, const char* key);
+
+        bool ReadXmlAttribute(boost::property_tree::ptree &pt,bool& v, const char* key);
+
+        bool ReadXmlColorAttribute(boost::property_tree::ptree &pt,int& r, int& g, int& b, const char* key);
+        
+        bool ReadXmlValue(boost::property_tree::ptree &pt,std::string& v, const char* key);
+
+        shared_ptr<clsCrSurf> CreateSurface(int width, int height, DmpWmsParameters::Format format);
+    };
+}
+
+#endif // __dmpprintlayer_h__

+/**************************************************************************
+* file:              dmpprintlayout.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-25 15:12:38
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpprintlayout.h"
+#include "dmpprintrect.h"
+#include "dmpprintscale.h"
+#include "dmpprinttext.h"
+#include "dmpprintcompass.h"
+#include "dmpprintwmsservice.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)
+     {
+         try
+         {
+             boost::property_tree::ptree ptbound = pt.get_child("bound");
+             this->ReadXmlAttribute(ptbound, showbound_, "show");
+             this->ReadXmlAttribute(ptbound, localtionX_, "localtion_x");
+             this->ReadXmlAttribute(ptbound, localtionY_, "localtion_y");
+
+             this->ReadXmlAttribute(ptbound, width_, "width");
+             this->ReadXmlAttribute(ptbound, height_, "height");
+
+             this->ReadXmlAttribute(ptbound, boundSize_, "bound_size");
+         }
+         catch(const std::exception& e)
+         {
+            
+         }
+         
+         try
+         {
+             boost::property_tree::ptree ptlayouts = pt.get_child("layouts");
+             // for (rapidxml::xml_node<char> *layout_node = layouts_node->first_node("layout");
+             //          layout_node != nullptr;
+             //          layout_node = layout_node->next_sibling())
+             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");
+                 bool result = true;
+                 if (type == "text")
+                 {
+                     shared_ptr<DmpPrintLayer> layer(new DmpPrintText());
+                     result = layer->ReadXML(ptlayout, pPrintParameter, errorstr);
+                     this->data.push_back(layer);
+                 }
+                 else if (type == "dmapservice")
+                 {
+                     shared_ptr<DmpPrintLayer> layer(new DmpPrintWMSService());
+                      result = layer->ReadXML(ptlayout, pPrintParameter, errorstr);
+                    this->data.push_back(layer);
+                 }
+                 else if (type == "scale")
+                 {
+                     shared_ptr<DmpPrintLayer> layer(new DmpPrintScale());
+                     result = layer->ReadXML(ptlayout, pPrintParameter, errorstr);
+                     this->data.push_back(layer);
+                 }
+                 else if (type == "compass")
+                 {
+                     shared_ptr<DmpPrintLayer> layer(new DmpPrintCompass());
+                     result = layer->ReadXML(ptlayout, pPrintParameter, errorstr);
+                     this->data.push_back(layer);
+                 }
+                 else if (type == "rectangle" || type == "rect")
+                 {
+                     shared_ptr<DmpPrintLayer> layer(new DmpPrintRect());
+                     result = layer->ReadXML(ptlayout, pPrintParameter, errorstr);
+                     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;
+     }
+}
\ No newline at end of file

@@ -9,10 +9,31 @@
 
 #ifndef __dmpprintlayout_h__
 #define __dmpprintlayout_h__
-
+#include "dmpprintlayer.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);
+        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;
+            }
+        }
+    }
+}
\ No newline at end of file

+/**************************************************************************
+* 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>
+using namespace std;
+namespace DmpWms
+{
+    class DmpPrintParameter
+    {
+     public:
+        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;
+    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)
+     {
+          //this->ReadXmlAttribute(bound_node, showbound, "show");
+        this->ReadXmlAttribute(pt, localtionX_, "localtion_x");
+        this->ReadXmlAttribute(pt, localtionY_, "localtion_y");
+
+        this->ReadXmlAttribute(pt, width_, "width");
+        this->ReadXmlAttribute(pt, height_, "height");
+
+        this->ReadXmlAttribute(pt, boundSize_, "bound_size");
+        this->pPrintParameter_ = pPrintParameter;
+
+        return true;
+     }
+
+}
\ No newline at end of file

+/**************************************************************************
+* 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);
+       
+        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)
+     {
+        this->ReadXmlAttribute(pt,localtionX_,"localtion_x");
+        this->ReadXmlAttribute(pt,localtionY_,"localtion_y");
+       // this->ReadXmlAttribute(pt,type,"type");
+
+        this->ReadXmlAttribute(pt, boundSize_, "bound_size");
+        this->ReadXmlAttribute(pt, showbound_, "showBound");
+
+        this->pPrintParameter_ = pPrintParameter;
+
+        return true;
+     }
+
+
+}
\ No newline at end of file

+/**************************************************************************
+* 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
+    {
+        private:
+            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);
+    };
+}
+#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)
+     {
+         try
+         {
+             this->ReadXmlAttribute(pt, localtionX_, "localtion_x");
+             this->ReadXmlAttribute(pt, localtionY_, "localtion_y");
+
+             this->ReadXmlAttribute(pt, boundSize_, "bound_size");
+             this->ReadXmlAttribute(pt, showbound_, "showBound");
+             boost::property_tree::ptree pttext = pt.get_child("text");
+             this->ReadXmlColorAttribute(pttext, r_, g_, b_, "fontcolor");
+             this->ReadXmlAttribute(pttext, text_, "title");
+             this->ReadXmlAttribute(pttext, fontSize_, "fontsize");
+             this->ReadXmlAttribute(pttext, font_, "font");
+             this->ReadXmlAttribute(pttext, isBold_, "bold");
+             return true;
+         }
+         catch(const std::exception& e)
+         {
+            return false;
+         }
+         return false;
+     }
+}
\ No newline at end of file

+/**************************************************************************
+* 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);
+   };
+}
+
+#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)
+     {
+         try
+         {
+             this->ReadXmlAttribute(pt, localtionX_, "localtion_x");
+             this->ReadXmlAttribute(pt, localtionY_, "localtion_y");
+             this->ReadXmlAttribute(pt, width_, "width");
+             this->ReadXmlAttribute(pt, height_, "height");
+             this->ReadXmlAttribute(pt, showCoord_, "showCoord");
+             this->ReadXmlAttribute(pt, boundSize_, "bound_size");
+             this->ReadXmlAttribute(pt, showbound_, "showBound");
+
+            // 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");
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->title, "title");
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->fontSize, "fontsize");
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->font, "font");
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->isbold, "bold");
+                 this->ReadXmlColorAttribute(ptlegend, pLegendParamater_->back_r, pLegendParamater_->back_g, pLegendParamater_->back_b, "backgroundcolor");
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->back_a, "backgroundalpha");
+
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->showclassification, "showclassification");
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->rowspacing, "rowspacing");
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->size_x, "size_x");
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->size_y, "size_y");
+                 this->ReadXmlAttribute(ptlegend, pLegendParamater_->row_maxsize, "row_maxsize");
+                 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_;
+
+            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);
+        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__