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

-dmap server 4.0
\ No newline at end of file
+dmap server 4.0
+

@@ -47,11 +47,12 @@ bool DmpVectorLayer::writeXml(boost::property_tree::ptree &layerNode)
 
 void DmpVectorLayer::setRenderer(DmpFeatureRenderer *renderer)
 {
-
+   
 }
 
 void DmpVectorLayer::setDataSource(const std::string &dataSource, const std::string &baseName, const std::string &provider, bool loadDefaultStyleFlag)
 {
+ 
   DmpWkbTypes::GeometryType geomType = GeometryType();
 }
 

-[Core]
-Filter="%Severity% >= debug"
-
-[Sinks.TextFileSettings]
-Destination=TextFile
-FileName="dmap_%Y%m%d.log"
-AutoFlush=true
-Format="[%TimeStamp%] [%Uptime%] [%Scope%] <%Severity%> %Message%"
-Asynchronous=false
-Append=true
+[Core]
+Filter="%Severity% >= debug"
+
+[Sinks.TextFileSettings]
+Destination=TextFile
+FileName="dmap_%Y%m%d.log"
+AutoFlush=true
+Format="[%TimeStamp%] [%Uptime%] [%Scope%] <%Severity%> %Message%"
+Asynchronous=false
+Append=true

+
+
+#include "AppendBuffer.h"
+#include "stdlib.h"
+#include <string.h>
+//
+
+namespace DmapCore_30
+{
+
+AppendBuffer::AppendBuffer(void)
+{
+	allSize=0;
+	head=0;
+	now=0;	
+} 
+
+	AppendBuffer::AppendBuffer(const char *fileName)
+	{
+		allSize = 0;
+		head = 0;
+		now = 0;
+		if (fileName)
+		{
+			f = fopen(fileName, "wb");
+		}
+	}
+
+AppendBuffer::~AppendBuffer(void)
+{
+	Reset();
+}
+
+//分配一个新的BUFFER
+AppendBuffer::Buffer *AppendBuffer::NewABuffer(void)
+{
+	Buffer *buf=new Buffer;
+	buf->buffer=(char *)malloc(APPEND_BUFFER_SIZE);  //每个BUFFER都留这么大的空间？
+	if(buf->buffer==0)
+	{
+		delete buf;
+		return 0;
+	}
+	buf->next=0;
+	buf->bufferNowCount=0;
+
+	return buf;
+}
+char *AppendBuffer::GetString()
+	{
+		char *s = (char *)malloc(this->allSize + 1);
+		if (s == 0)return 0;
+		char *ss = s; int cc = 0;
+		for (Buffer *h = head; h;)
+		{
+			memcpy(ss, h->buffer, h->bufferNowCount);
+			ss += h->bufferNowCount;
+			//	cc += h->bufferNowCount;
+			h = h->next;
+		}
+		s[this->allSize] = 0;
+		return s;
+	}
+void AppendBuffer::AppendString(const char * str, int len)
+{	
+	
+	if(now==0)AddABuffer(); //当前的指针为0 
+
+	int remain;	
+	for(;;)
+	{
+		remain=APPEND_BUFFER_SIZE-now->bufferNowCount;
+		if(remain==0)
+		{
+			AddABuffer();
+			remain=APPEND_BUFFER_SIZE-now->bufferNowCount;
+		}
+		if(remain>=len)//放得下
+		{
+			memcpy(now->buffer+now->bufferNowCount,str,len);
+			//len-=len;
+			now->bufferNowCount+=len;
+			this->allSize+=len;			
+			break;
+		}
+		else  //放不下
+		{
+			memcpy(now->buffer+now->bufferNowCount,str,remain);
+			len-=remain;
+			now->bufferNowCount=APPEND_BUFFER_SIZE;
+			str+=remain;
+			this->allSize+=remain;			
+			AddABuffer();
+		}
+	}	
+}
+
+//int AppendBuffer::GetSize()
+//{
+//	int size = 0;
+//	for (AppendBuffer::Buffer *pb = this->head; pb; pb = pb->next)
+//	{
+//		size = size + sizeof(pb->buffer);
+//	}
+//	return size;
+//}
+
+
+void AppendBuffer::SetBuffer(AppendBuffer::Buffer *buf,const char * str, int len)
+{	
+	memcpy(buf->buffer,str,len);
+	this->allSize+=len;
+	buf->bufferNowCount=len;
+}
+
+int AppendBuffer::AppendString(const char * str)
+{
+	AppendString(str,(int)(strlen(str)));
+	return 0;
+}
+
+
+int AppendBuffer::AddABuffer(void)
+{		
+	if(head==0)
+	{
+		head=NewABuffer();
+		now=head;  //now是当前的指针
+	}
+	else
+	{
+		now->next=NewABuffer();
+		now=now->next;
+	}
+	if(now==0)return 1;//stbstb
+	return 0;
+}
+
+int AppendBuffer::AppendOtherOne(AppendBuffer * other)
+{
+	this->now->next=other->head;
+	this->now=other->now;
+	this->allSize+=other->allSize;
+	other->head=0;
+	//other->allSize=0; //stbstb
+	//other->now=0;
+	return 0;
+}
+
+void AppendBuffer::Reset(void)
+{
+	for(;head;)
+	{
+		now=head;
+		head=now->next;
+		free(now->buffer);
+		delete now;				
+	}	
+	head=0;
+	now=0;
+	allSize=0;
+}
+	
+}
\ No newline at end of file

+/**************************************************************************
+* file:              AppendBuffer.h
+
+* Author:            qingxiongf
+* Date:              2021-12-12 23:00:46
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __AppendBuffer_h__
+#define __AppendBuffer_h__
+
+#include "dmap_core.h"
+#include "stdio.h"
+#include <string>
+
+#define APPEND_BUFFER_SIZE 200000
+
+namespace DmapCore_30
+{
+
+	class CORE_EXPORT AppendBuffer
+	{
+	public:
+		struct Buffer
+		{
+			Buffer *next;
+			char *buffer;
+			int bufferNowCount;
+		};
+
+	private:
+		FILE *f;
+
+
+	public:
+		int allSize;
+		AppendBuffer(void);
+		char *GetString();
+
+		std::string content_type;
+
+	public:
+		~AppendBuffer(void);
+		AppendBuffer(const char *fileName);
+		Buffer *head;
+		Buffer *now;
+		//	char *bufferNow;
+		//	char *bufferNowCount;
+		AppendBuffer::Buffer *NewABuffer(void);
+
+	public:
+		void SetBuffer(AppendBuffer::Buffer *buf, const char *str, int len);
+		void AppendString(const char *str, int len);
+		/* int GetSize();*/
+	public:
+		int AppendString(const char *str);
+		int AddABuffer(void);
+
+		//int AppendString(const char * str);
+		//int AppendString(const char * str);
+	public:
+		int AppendOtherOne(AppendBuffer *other);
+
+	public:
+		void Reset(void);
+	};
+
+} // namespace DmapCore_30
+
+#endif // __AppendBuffer_h__
+

+#include "DataCollection.h"
+#include "clsStruct.h"
+//#include "Geometry.h"
+#include "clsUtil.h"
+#include <stdlib.h>
+
+namespace DmapCore_30
+{
+
+	DataCollection::DataCollection()
+	{
+		m_iPartCount = 0;
+		m_iStructType = 0;
+		m_pData = 0; //此指针只能够是自定义的6种结构体类型
+
+		m_dR = 1;
+		m_dScaleDenominator = 1;
+		m_dXdis = 1;
+		m_dYdis = 1;
+
+		m_subset = 0;
+
+		m_iN = 0;
+	}
+
+
+	void DataCollection::InitDataCollection(PGresult *res, int shapeType, int imageWidth, int imageHeight, 
+					int subset, double r,
+					double dScaleDenominator, double x_dis, double y_dis)
+	{
+		//InitDataCollection();
+		m_iN = 1;
+		//其他所有变量初始化
+		m_iPartCount = PQntuples(res);
+		m_dR = r;
+		m_dScaleDenominator = dScaleDenominator;
+		m_dXdis = x_dis;
+		m_dYdis = y_dis;
+		m_imageWidth = imageWidth;
+		m_imageHeight = imageHeight;
+
+		if (subset < 0)
+		{
+			m_subset = 2;
+		}
+		else
+		{
+			m_subset = subset + 2;
+		}
+	
+		this->CollectFieldName(res);
+
+		switch (shapeType)
+		{
+		case GeometryType_Point:
+			MallocForPoint(res);
+			break;
+		case GeometryType_MultiPoint:
+			break;
+		case GeometryType_LineString:
+			MallocForLineStringGeom(res);
+			break;
+		case GeometryType_MultiLineString:
+			MallocForLineStringGeom(res);
+			break;
+		case GeometryType_Polygon:
+			MallocForPolygonForGeom(res);
+			break;
+		case GeometryType_MultiPolygon:
+			MallocForPolygonForGeom(res);
+			break;
+		default:
+			
+			break;
+		}
+		//CollectAllField(res);
+	}
+
+	
+/*
+	void DataCollection::InitDataCollection(Geometry *geom, double r, double dScaleDenominator,
+	 double x_dis, double y_dis)
+	{
+		//InitDataCollection();
+		m_iN = 1;
+		m_iPartCount = 1;
+		m_dR = r;
+		m_dScaleDenominator = dScaleDenominator;
+		m_dXdis = x_dis;
+		m_dYdis = y_dis;
+
+		int geomType = geom->GeometryType();
+		switch (geomType)
+		{
+		case dmapGeometryPoint:
+		{
+			Point *p = (Point *)geom;
+			this->MallocForPoint(p);
+			break;
+		}
+		case dmapGeometryMultiPoint:
+		{
+			MultiPoint *mp = (MultiPoint *)geom;
+			this->MallocForMultiPoint(mp);
+			break;
+		}
+		case dmapGeometryPath:
+		{
+			Path *path = (Path *)geom;
+			this->MallocForPath(path);
+			break;
+		}
+		case dmapGeometryMultiLineString:
+		{
+			MultiLineString *ml = (MultiLineString *)geom;
+			this->MallocForMultiLineString(ml);
+			break;
+		}
+		case dmapGeometryRing:
+		{
+			Ring *ring = (Ring *)geom;
+			this->MallocForRing(ring);
+			break;
+		}
+		case dmapGeometryPolygon:
+		{
+			Polygon *pPolygon = (Polygon *)geom;
+			this->MallocForPolygon(pPolygon);
+			break;
+		}
+		case dmapGeometryMultiPolygon:
+		{
+			MultiPolygon *mp = (MultiPolygon *)geom;
+			this->MallocForMultiPolygon(mp);
+			break;
+		}
+		default:
+			break;
+		}
+	}*/
+
+
+	DataCollection::~DataCollection()
+	{
+		//cout<<"free begin;" <<endl;
+		if (m_pData)
+		{
+			switch (m_iStructType)
+			{
+			case clsStruct::Struct_Point:
+			{
+				this->FreeForPOINT();
+				break;
+			}
+			case clsStruct::Struct_Line:
+			{
+				this->FreeForLINE();
+				break;
+			}
+			case clsStruct::Struct_MLine:
+			{
+				this->FreeForMLINE();
+				break;
+			}
+			case clsStruct::Struct_Polygon:
+			{
+				this->FreeForPOLYGON();
+				break;
+			}
+			case clsStruct::Struct_MPolygon:
+			{
+				this->FreeForMPOLYGON();
+				break;
+			}
+			default:
+				break;
+			}
+		}
+		//cout<<"free end;" <<endl;
+	}
+
+	
+
+	/*
+	Malloc  PGresult
+	*/
+	bool DataCollection::MallocForPoint(PGresult *res)
+	{
+		m_iStructType = clsStruct::Struct_Point;
+
+		int n_fields = PQnfields(res);
+		map<int, PointClass *> map_Point;
+
+		for (size_t i = 0; i < m_iPartCount; i++)
+		{
+			unsigned char *here = (unsigned char *)PQgetvalue(res, i, 0);
+			unsigned char hasZorSrsid = ((unsigned char *)(here + 4))[0] / 16;
+			unsigned char hasZ = hasZorSrsid / 8;
+			unsigned char hasSrsid = hasZorSrsid % 8;
+
+			int not_big = here[0];
+			here++;
+			int shapetype = ((int *)here)[0];
+			here += 4;
+			if (hasSrsid)
+				here += 4;
+
+			double x = ((double *)here)[0];
+			here += 8; // clsUtil::ReadDouble(here, not_big);
+			double y = ((double *)here)[0];
+			here += 8; // clsUtil::ReadDouble(here, not_big);
+			double x0 = 0, y0 = 0;
+			this->ToScale(x, y, x0, y0);
+
+			int key = ((int)(x0 / m_subset)) * 10000 + ((int)(y0 / m_subset));
+			if (map_Point.find(key) == map_Point.end())
+			{
+				PointClass *pointClass = new PointClass();
+				pointClass->x = x0;
+				pointClass->y = y0;
+				/*clsStruct::POINT* pp0 = new clsStruct::POINT();
+				pp0->x = x0;
+				pp0->y = y0;*/
+				map_Point[key] = pointClass;
+				for (int i0 = 1; i0 < n_fields; i0++)
+				{
+					char *vc = PQgetvalue(res, i, i0);
+					pointClass->m_pdata.push_back(vc);
+				}
+			}
+		}
+
+		clsStruct::POINT *pp = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * map_Point.size());
+		if (pp == NULL)
+			return false;
+		int index = 0;
+
+		//创建预留空间
+		m_vAllField.resize(map_Point.size());
+		for (int i = 0; i < map_Point.size(); i++)
+			m_vAllField[i].resize(n_fields - 1); //这里是不包含shape 数据的
+		//开辟预留空间后, 可以直接赋值,不需要 pushback
+
+		for (map<int, PointClass *>::iterator iter = map_Point.begin(); iter != map_Point.end(); iter++)
+		{
+			PointClass *p = iter->second;
+			pp[index].x = p->x;
+			pp[index].y = p->y;
+			for (int j = 0; j < n_fields - 1; j++) //这里从第二列开始
+			{
+				m_vAllField[index][j] = p->m_pdata.at(j);
+			}
+			p->m_pdata.clear();
+			delete p;
+			iter->second = NULL;
+			index++;
+		}
+
+		this->m_iPartCount = map_Point.size();
+
+		map_Point.clear();
+
+		m_pData = pp;
+		return true;
+	}
+
+	bool DataCollection::MallocForLineStringGeom(PGresult *res)
+	{
+		m_iStructType = clsStruct::Struct_MLine;
+		//	bool isLineZ = false;
+		int n_fields = PQnfields(res);
+		clsStruct::MLINE *pp = (clsStruct::MLINE *)malloc(sizeof(clsStruct::MLINE) * m_iPartCount);
+		if (pp == NULL)
+			return false;
+		m_vAllField.resize(m_iPartCount);
+		for (int i = 0; i < m_iPartCount; i++)
+			m_vAllField[i].resize(n_fields - 1); //这里是不包含shape 数据的
+
+		for (int i = 0; i < m_iPartCount; i++)
+		{
+
+			//clsStruct::MLINE ml;
+
+			unsigned char *here = (unsigned char *)PQgetvalue(res, i, 0);
+			unsigned char geom_type = (here)[1];
+			unsigned char hasZorSrsid = ((unsigned char *)(here + 4))[0] / 16;
+			unsigned char hasZ = hasZorSrsid / 8;
+			unsigned char hasSrsid = hasZorSrsid % 8;
+			int not_big = clsUtil::ReadByte(here);
+			int shapetype = clsUtil::ReadInt(here, not_big);
+			if (hasSrsid)
+				here += 4;
+			//if (shapetype < 0) isLineZ = true;
+			if (geom_type == DCGeometryType::GeometryType_LineString)
+			{
+				int nLine = 1;//clsUtil::ReadInt(here, not_big);
+				clsStruct::LINE *pPath = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE) * nLine);
+				if (pPath == 0)
+					continue;
+				pp[i].nLine = nLine;
+				pp[i].p = pPath;
+
+				for (int j = 0; j < nLine; j++)
+				{
+					//clsStruct::LINE path;
+
+					//int not_big2 = clsUtil::ReadByte(here);
+					//here += 4; //跳过 shapetype 读取
+
+					int nPoint = clsUtil::ReadInt(here, not_big);
+					clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * nPoint);
+					if (pPoint == 0)
+						continue;
+					pPath[j].nPoint = nPoint;
+					pPath[j].p = pPoint;
+
+					for (int k = 0; k < nPoint; k++)
+					{
+						//clsStruct::POINT point;
+
+						double x = clsUtil::ReadDouble(here, not_big);
+						double y = clsUtil::ReadDouble(here, not_big);
+						if (hasZ)
+						{
+							//Z 值跳过
+							here += 8;
+						}
+						double x0 = 0, y0 = 0;
+						this->ToScale(x, y, x0, y0);
+
+						pPoint[k].x = x0;
+						pPoint[k].y = y0;
+					}
+				}
+			}
+			else if (geom_type == DCGeometryType::GeometryType_MultiLineString)
+			{
+				int nLine = clsUtil::ReadInt(here, not_big);
+				clsStruct::LINE *pPath = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE) * nLine);
+				if (pPath == 0)
+					continue;
+				pp[i].nLine = nLine;
+				pp[i].p = pPath;
+
+				for (int j = 0; j < nLine; j++)
+				{
+					//clsStruct::LINE path;
+
+					int not_big2 = clsUtil::ReadByte(here);
+					here += 4; //跳过 shapetype 读取
+
+					int nPoint = clsUtil::ReadInt(here, not_big2);
+					clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * nPoint);
+					if (pPoint == 0)
+						continue;
+					pPath[j].nPoint = nPoint;
+					pPath[j].p = pPoint;
+
+					for (int k = 0; k < nPoint; k++)
+					{
+						//clsStruct::POINT point;
+
+						double x = clsUtil::ReadDouble(here, not_big2);
+						double y = clsUtil::ReadDouble(here, not_big2);
+						if (hasZ)
+						{
+							//Z 值跳过
+							here += 8;
+						}
+						double x0 = 0, y0 = 0;
+						this->ToScale(x, y, x0, y0);
+
+						pPoint[k].x = x0;
+						pPoint[k].y = y0;
+					}
+				}
+			}
+
+			for (int j = 0; j < n_fields - 1; j++) //这里从第二列开始
+			{
+				m_vAllField[i][j] = (char *)PQgetvalue(res, i, j + 1);
+			}
+			/*ml.nLine = nLine;
+			ml.p = pPath;
+			pp[i] = ml;*/
+		}
+
+		m_pData = pp;
+		return true;
+	}
+
+	bool DataCollection::MallocForMultiLineString(PGresult *res)
+	{
+		m_iStructType = clsStruct::Struct_MLine;
+		//	bool isLineZ = false;
+		int n_fields = PQnfields(res);
+		clsStruct::MLINE *pp = (clsStruct::MLINE *)malloc(sizeof(clsStruct::MLINE) * m_iPartCount);
+		if (pp == NULL)
+			return false;
+		m_vAllField.resize(m_iPartCount);
+		for (int i = 0; i < m_iPartCount; i++)
+			m_vAllField[i].resize(n_fields - 1); //这里是不包含shape 数据的
+
+		for (int i = 0; i < m_iPartCount; i++)
+		{
+
+			//clsStruct::MLINE ml;
+
+			unsigned char *here = (unsigned char *)PQgetvalue(res, i, 0);
+			unsigned char hasZorSrsid = ((unsigned char *)(here + 4))[0] / 16;
+			unsigned char hasZ = hasZorSrsid / 8;
+			unsigned char hasSrsid = hasZorSrsid % 8;
+			int not_big = clsUtil::ReadByte(here);
+			int shapetype = clsUtil::ReadInt(here, not_big);
+			if (hasSrsid)
+				here += 4;
+			//if (shapetype < 0) isLineZ = true;
+
+			int nLine = clsUtil::ReadInt(here, not_big);
+			clsStruct::LINE *pPath = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE) * nLine);
+			if (pPath == 0)
+				continue;
+			pp[i].nLine = nLine;
+			pp[i].p = pPath;
+
+			for (int j = 0; j < nLine; j++)
+			{
+				//clsStruct::LINE path;
+
+				int not_big2 = clsUtil::ReadByte(here);
+				here += 4; //跳过 shapetype 读取
+
+				int nPoint = clsUtil::ReadInt(here, not_big2);
+				clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * nPoint);
+				if (pPoint == 0)
+					continue;
+				pPath[j].nPoint = nPoint;
+				pPath[j].p = pPoint;
+
+				for (int k = 0; k < nPoint; k++)
+				{
+					//clsStruct::POINT point;
+
+					double x = clsUtil::ReadDouble(here, not_big2);
+					double y = clsUtil::ReadDouble(here, not_big2);
+					if (hasZ)
+					{
+						//Z 值跳过
+						here += 8;
+					}
+					double x0 = 0, y0 = 0;
+					this->ToScale(x, y, x0, y0);
+
+					pPoint[k].x = x0;
+					pPoint[k].y = y0;
+				}
+
+				/*path.nPoint = nPoint;
+				path.p = pPoint;
+				pPath[j] = path;*/
+			}
+			for (int j = 0; j < n_fields - 1; j++) //这里从第二列开始
+			{
+				m_vAllField[i][j] = (char *)PQgetvalue(res, i, j + 1);
+			}
+			/*ml.nLine = nLine;
+			ml.p = pPath;
+			pp[i] = ml;*/
+		}
+
+		m_pData = pp;
+		return true;
+	}
+
+	
+	
+	bool DataCollection::PolygonIsLessThanOnePixel(unsigned char *here, int not_big1)
+	{
+		double dpix = 1 / this->m_dR;
+		here += 9;
+		int npolygonCount = clsUtil::ReadInt(here, not_big1);
+
+		double x0 = clsUtil::ReadDouble(here, not_big1);
+		double y0 = clsUtil::ReadDouble(here, not_big1);
+
+		if (npolygonCount < 6)
+		{
+			int step = (npolygonCount / 2);
+			here += step * 16;
+			double x = clsUtil::ReadDouble(here, not_big1);
+			double y = clsUtil::ReadDouble(here, not_big1);
+			if (abs(x - x0) < dpix && abs(y - y0) < dpix)
+			{
+				return true;
+			}
+		}
+		else if (npolygonCount < 35)
+		{
+			int step = (npolygonCount / 3);
+			here += step * 16;
+			double x1 = clsUtil::ReadDouble(here, not_big1);
+			double y1 = clsUtil::ReadDouble(here, not_big1);
+
+			here += step * 16;
+			double x2 = clsUtil::ReadDouble(here, not_big1);
+			double y2 = clsUtil::ReadDouble(here, not_big1);
+			if (abs(x1 - x0) < dpix && abs(y1 - y0) < dpix &&
+				abs(x2 - x0) < dpix && abs(y2 - y0) < dpix)
+			{
+				return true;
+			}
+		}
+		else
+		{
+			for (int step = 10; step < npolygonCount; step += 11)
+			{
+				here += 10 * 16;
+				double x1 = clsUtil::ReadDouble(here, not_big1);
+				double y1 = clsUtil::ReadDouble(here, not_big1);
+				if (abs(x1 - x0) > dpix || abs(y1 - y0) > dpix)
+				{
+					return false;
+				}
+			}
+
+			return true;
+		}
+		return false;
+	}
+
+	bool DataCollection::MallocForPolygonForGeom(PGresult *res)
+	{
+		bool allPolygonToPoint = false;
+
+		if (m_imageWidth > 0 && m_imageHeight > 0)
+		{
+			allPolygonToPoint = m_iPartCount > (m_imageWidth * m_imageHeight / 8);
+		}
+
+		//double maxcount = (d1* d2)/1.5;
+		//bool isPolygonZ = false;
+		m_iStructType = clsStruct::Struct_MPolygon;
+		int n_fields = PQnfields(res);
+
+		clsStruct::MPOLYGON *pp = (clsStruct::MPOLYGON *)malloc(sizeof(clsStruct::MPOLYGON) * m_iPartCount);
+		if (pp == NULL)
+			return false;
+		m_vAllField.resize(m_iPartCount);
+		for (int i = 0; i < m_iPartCount; i++)
+			m_vAllField[i].resize(n_fields - 1); //这里是不包含shape 数据的
+
+		for (int i = 0; i < m_iPartCount; i++)
+		{
+
+			int not_big1, not_big2, shapetype1, nring, npoint, srid;
+			unsigned char *here = (unsigned char *)PQgetvalue(res, i, 0);
+
+			unsigned char geom_type = (here)[1];
+			unsigned char hasZorSrsid = ((unsigned char *)(here + 4))[0] / 16;
+			unsigned char hasZ = hasZorSrsid / 8;
+			unsigned char hasSrsid = hasZorSrsid % 8;
+			// printf("%d %d \r\n",i,geom_type );
+			not_big1 = clsUtil::ReadByte(here);
+			shapetype1 = clsUtil::ReadInt(here, not_big1);
+			if (hasSrsid)
+				srid = clsUtil::ReadInt(here, not_big1); //跳过srid
+			//if (shapetype1 < 0) isPolygonZ = true;
+			if (geom_type == DCGeometryType::GeometryType_Point)
+			{
+				double x = clsUtil::ReadDouble(here, not_big1);
+				double y = clsUtil::ReadDouble(here, not_big1);
+				clsStruct::POLYGON *pPgon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON));
+				if (pPgon == NULL)
+				{
+					free(pp);
+					pp = 0;
+					break;
+				}
+
+				clsStruct::LINE *pRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE));
+				if (pRing == NULL)
+				{
+					free(pp);
+					pp = 0;
+					free(pPgon);
+					pPgon = 0;
+					break;
+				}
+
+				pPgon[0].nRing = 1;
+				pPgon[0].p = pRing;
+
+				clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT));
+
+				pRing[0].nPoint = 1;
+				pRing[0].p = pPoint;
+
+				double x0 = 0, y0 = 0;
+				this->ToScale(x, y, x0, y0);
+				pPoint[0].x = x0;
+				pPoint[0].y = y0;
+
+				pp[i].nPolygon = 1;
+				pp[i].p = pPgon;
+			}
+			else if (geom_type == DCGeometryType::GeometryType_Polygon)
+			{
+				clsStruct::POLYGON *pPgon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON) * 1);
+				//clsStruct::MPOLYGON mpgon;
+				if (pPgon == NULL)
+					continue;
+				pp[i].nPolygon = 1;
+				pp[i].p = pPgon;
+
+				//for (int j = 0; j < npolygon; j++)
+				{
+					//not_big2 = clsUtil::ReadByte(here);
+					//here += 4; //跳过 shapetype, 没意义, 必然是polygon
+
+					nring = clsUtil::ReadInt(here, not_big1);
+					clsStruct::LINE *pRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE) * nring);
+					if (pRing == NULL)
+						break;
+					pPgon[0].nRing = nring;
+					pPgon[0].p = pRing;
+
+					for (int k = 0; k < nring; k++)
+					{
+						npoint = clsUtil::ReadInt(here, not_big1);
+						clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * npoint);
+						if (pPoint == NULL)
+							break;
+						pRing[k].nPoint = npoint;
+						pRing[k].p = pPoint;
+						//clsStruct::LINE ring;
+
+						for (int m = 0; m < npoint; m++)
+						{
+							double x = clsUtil::ReadDouble(here, not_big1);
+							double y = clsUtil::ReadDouble(here, not_big1);
+							if (hasZ)
+							{
+								//Z 值跳过
+								here += 8;
+							}
+							double x0 = 0, y0 = 0;
+							this->ToScale(x, y, x0, y0);
+
+							pPoint[m].x = x0;
+							pPoint[m].y = y0;
+						}
+					}
+				}
+			}
+			else if (geom_type == DCGeometryType::GeometryType_MultiPolygon)
+			{
+				int npolygon = clsUtil::ReadInt(here, not_big1);
+
+				if (PolygonIsLessThanOnePixel(here, not_big1))
+				{
+					//here += 4;
+					//npolygon = clsUtil::ReadInt(here, not_big1)
+					not_big2 = clsUtil::ReadByte(here);
+					here += 12;
+					double x = clsUtil::ReadDouble(here, not_big2);
+					double y = clsUtil::ReadDouble(here, not_big2);
+					clsStruct::POLYGON *pPgon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON));
+					if (pPgon == NULL)
+					{
+						free(pp);
+						pp = 0;
+						break;
+					}
+
+					clsStruct::LINE *pRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE));
+					if (pRing == NULL)
+					{
+						free(pp);
+						pp = 0;
+						free(pPgon);
+						pPgon = 0;
+						break;
+					}
+
+					pPgon[0].nRing = 1;
+					pPgon[0].p = pRing;
+
+					clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT));
+
+					pRing[0].nPoint = 1;
+					pRing[0].p = pPoint;
+
+					double x0 = 0, y0 = 0;
+					this->ToScale(x, y, x0, y0);
+					pPoint[0].x = x0;
+					pPoint[0].y = y0;
+
+					pp[i].nPolygon = 1;
+					pp[i].p = pPgon;
+				}
+				else
+				{
+
+					clsStruct::POLYGON *pPgon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON) * npolygon);
+					//clsStruct::MPOLYGON mpgon;
+					if (pPgon == NULL)
+						continue;
+					pp[i].nPolygon = npolygon;
+					pp[i].p = pPgon;
+
+					for (int j = 0; j < npolygon; j++)
+					{
+						not_big2 = clsUtil::ReadByte(here);
+						here += 4; //跳过 shapetype, 没意义, 必然是polygon
+
+						nring = clsUtil::ReadInt(here, not_big2);
+						clsStruct::LINE *pRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE) * nring);
+						if (pRing == NULL)
+							break;
+						pPgon[j].nRing = nring;
+						pPgon[j].p = pRing;
+						//clsStruct::POLYGON pgon;
+
+						for (int k = 0; k < nring; k++)
+						{
+							npoint = clsUtil::ReadInt(here, not_big2);
+							clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * npoint);
+							if (pPoint == NULL)
+								break;
+							pRing[k].nPoint = npoint;
+							pRing[k].p = pPoint;
+							//clsStruct::LINE ring;
+
+							for (int m = 0; m < npoint; m++)
+							{
+								double x = clsUtil::ReadDouble(here, not_big2);
+								double y = clsUtil::ReadDouble(here, not_big2);
+								if (hasZ)
+								{
+									//Z 值跳过
+									here += 8;
+								}
+								double x0 = 0, y0 = 0;
+								this->ToScale(x, y, x0, y0);
+
+								pPoint[m].x = x0;
+								pPoint[m].y = y0;
+							}
+						}
+					}
+				}
+			}
+
+			for (int j = 0; j < n_fields - 1; j++) //这里从第二列开始
+			{
+				m_vAllField[i][j] = (char *)PQgetvalue(res, i, j + 1);
+			}
+		}
+
+		m_pData = pp;
+		return true;
+	}
+
+	bool DataCollection::MallocForPolygon(PGresult *res)
+	{
+
+		//double d1 = (queryX2 - queryX1)*m_dR;
+		//double d2 = (queryY2 - queryY1)*m_dR;
+
+		bool allPolygonToPoint = false;
+
+		if (m_imageWidth > 0 && m_imageHeight > 0)
+		{
+			allPolygonToPoint = m_iPartCount > (m_imageWidth * m_imageHeight / 8);
+		}
+
+		//double maxcount = (d1* d2)/1.5;
+		//bool isPolygonZ = false;
+		m_iStructType = clsStruct::Struct_MPolygon;
+		int n_fields = PQnfields(res);
+
+		clsStruct::MPOLYGON *pp = (clsStruct::MPOLYGON *)malloc(sizeof(clsStruct::MPOLYGON) * m_iPartCount);
+		if (pp == NULL)
+			return false;
+		m_vAllField.resize(m_iPartCount);
+		for (int i = 0; i < m_iPartCount; i++)
+			m_vAllField[i].resize(n_fields - 1); //这里是不包含shape 数据的
+
+		for (int i = 0; i < m_iPartCount; i++)
+		{
+
+			int not_big1, not_big2, shapetype1, nring, npoint;
+			//	unsigned char *here1 = (unsigned char *)PQgetvalue(res, i, 0);
+			// shared_ptr<PolygonClass>  dd = GetDataPolygon(here1);
+			//	continue;
+			unsigned char *here = (unsigned char *)PQgetvalue(res, i, 0);
+
+			unsigned char geom_type = (here)[1];
+			unsigned char hasZorSrsid = ((unsigned char *)(here + 4))[0] / 16;
+			unsigned char hasZ = hasZorSrsid / 8;
+			unsigned char hasSrsid = hasZorSrsid % 8;
+
+			not_big1 = clsUtil::ReadByte(here);
+			shapetype1 = clsUtil::ReadInt(here, not_big1);
+			if (hasSrsid)
+				shapetype1 = clsUtil::ReadInt(here, not_big1); //跳过srid
+			//if (shapetype1 < 0) isPolygonZ = true;
+			if (geom_type == DCGeometryType::GeometryType_Point)
+			{
+				double x = clsUtil::ReadDouble(here, not_big1);
+				double y = clsUtil::ReadDouble(here, not_big1);
+				clsStruct::POLYGON *pPgon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON));
+				if (pPgon == NULL)
+				{
+					free(pp);
+					pp = 0;
+					break;
+				}
+
+				clsStruct::LINE *pRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE));
+				if (pRing == NULL)
+				{
+					free(pp);
+					pp = 0;
+					free(pPgon);
+					pPgon = 0;
+					break;
+				}
+
+				pPgon[0].nRing = 1;
+				pPgon[0].p = pRing;
+
+				clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT));
+
+				pRing[0].nPoint = 1;
+				pRing[0].p = pPoint;
+
+				double x0 = 0, y0 = 0;
+				this->ToScale(x, y, x0, y0);
+				pPoint[0].x = x0;
+				pPoint[0].y = y0;
+
+				pp[i].nPolygon = 1;
+				pp[i].p = pPgon;
+			}
+			else
+			{
+				//nring = clsUtil::ReadInt(here, not_big1);
+				//npolygon = clsUtil::ReadInt(here, not_big1);
+
+				if (false)
+				{
+					//here += 4;
+					//npolygon = clsUtil::ReadInt(here, not_big1)
+					not_big2 = clsUtil::ReadByte(here);
+					here += 12;
+					double x = clsUtil::ReadDouble(here, not_big2);
+					double y = clsUtil::ReadDouble(here, not_big2);
+					clsStruct::POLYGON *pPgon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON));
+					if (pPgon == NULL)
+					{
+						free(pp);
+						pp = 0;
+						break;
+					}
+
+					clsStruct::LINE *pRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE));
+					if (pRing == NULL)
+					{
+						free(pp);
+						pp = 0;
+						free(pPgon);
+						pPgon = 0;
+						break;
+					}
+
+					pPgon[0].nRing = 1;
+					pPgon[0].p = pRing;
+
+					clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT));
+
+					pRing[0].nPoint = 1;
+					pRing[0].p = pPoint;
+
+					double x0 = 0, y0 = 0;
+					this->ToScale(x, y, x0, y0);
+					pPoint[0].x = x0;
+					pPoint[0].y = y0;
+
+					pp[i].nPolygon = 1;
+					pp[i].p = pPgon;
+				}
+				else
+				{
+
+					clsStruct::POLYGON *pPgon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON) * 1);
+					//clsStruct::MPOLYGON mpgon;
+					if (pPgon == NULL)
+						continue;
+					pp[i].nPolygon = 1;
+					pp[i].p = pPgon;
+
+					//for (int j = 0; j < npolygon; j++)
+					{
+						//not_big2 = clsUtil::ReadByte(here);
+						//here += 4; //跳过 shapetype, 没意义, 必然是polygon
+
+						nring = clsUtil::ReadInt(here, not_big2);
+						clsStruct::LINE *pRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE) * nring);
+						if (pRing == NULL)
+							break;
+						pPgon[0].nRing = nring;
+						pPgon[0].p = pRing;
+
+						for (int k = 0; k < nring; k++)
+						{
+							npoint = clsUtil::ReadInt(here, not_big2);
+							clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * npoint);
+							if (pPoint == NULL)
+								break;
+							pRing[k].nPoint = npoint;
+							pRing[k].p = pPoint;
+							//clsStruct::LINE ring;
+
+							for (int m = 0; m < npoint; m++)
+							{
+								double x = clsUtil::ReadDouble(here, not_big2);
+								double y = clsUtil::ReadDouble(here, not_big2);
+								if (hasZ)
+								{
+									//Z 值跳过
+									here += 8;
+								}
+								double x0 = 0, y0 = 0;
+								this->ToScale(x, y, x0, y0);
+
+								pPoint[m].x = x0;
+								pPoint[m].y = y0;
+							}
+						}
+					}
+				}
+			}
+
+			for (int j = 0; j < n_fields - 1; j++) //这里从第二列开始
+			{
+				m_vAllField[i][j] = (char *)PQgetvalue(res, i, j + 1);
+			}
+		}
+
+		m_pData = pp;
+		return true;
+	}
+
+	bool DataCollection::MallocForMultiPolygon(PGresult *res)
+	{
+
+		//double d1 = (queryX2 - queryX1)*m_dR;
+		//double d2 = (queryY2 - queryY1)*m_dR;
+
+		bool allPolygonToPoint = false;
+
+		if (m_imageWidth > 0 && m_imageHeight > 0)
+		{
+			allPolygonToPoint = m_iPartCount > (m_imageWidth * m_imageHeight / 8);
+		}
+
+		//double maxcount = (d1* d2)/1.5;
+		//bool isPolygonZ = false;
+		m_iStructType = clsStruct::Struct_MPolygon;
+		int n_fields = PQnfields(res);
+
+		clsStruct::MPOLYGON *pp = (clsStruct::MPOLYGON *)malloc(sizeof(clsStruct::MPOLYGON) * m_iPartCount);
+		if (pp == NULL)
+			return false;
+		m_vAllField.resize(m_iPartCount);
+		for (int i = 0; i < m_iPartCount; i++)
+			m_vAllField[i].resize(n_fields - 1); //这里是不包含shape 数据的
+
+		for (int i = 0; i < m_iPartCount; i++)
+		{
+
+			int not_big1, not_big2, shapetype1, npolygon, nring, npoint;
+			unsigned char *here = (unsigned char *)PQgetvalue(res, i, 0);
+			unsigned char geom_type = (here)[1];
+			unsigned char hasZorSrsid = ((unsigned char *)(here + 4))[0] / 16;
+			unsigned char hasZ = hasZorSrsid / 8;
+			unsigned char hasSrsid = hasZorSrsid % 8;
+			not_big1 = clsUtil::ReadByte(here);
+			shapetype1 = clsUtil::ReadInt(here, not_big1);
+			if (hasSrsid)
+				here += 4; //跳过srid
+			//if (shapetype1 < 0) isPolygonZ = true;
+			if (geom_type == DCGeometryType::GeometryType_Point)
+			{
+				double x = clsUtil::ReadDouble(here, not_big1);
+				double y = clsUtil::ReadDouble(here, not_big1);
+				clsStruct::POLYGON *pPgon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON));
+				if (pPgon == NULL)
+				{
+					free(pp);
+					pp = 0;
+					break;
+				}
+
+				clsStruct::LINE *pRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE));
+				if (pRing == NULL)
+				{
+					free(pp);
+					pp = 0;
+					free(pPgon);
+					pPgon = 0;
+					break;
+				}
+
+				pPgon[0].nRing = 1;
+				pPgon[0].p = pRing;
+
+				clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT));
+
+				pRing[0].nPoint = 1;
+				pRing[0].p = pPoint;
+
+				double x0 = 0, y0 = 0;
+				this->ToScale(x, y, x0, y0);
+				pPoint[0].x = x0;
+				pPoint[0].y = y0;
+
+				pp[i].nPolygon = 1;
+				pp[i].p = pPgon;
+			}
+			else
+			{
+				npolygon = clsUtil::ReadInt(here, not_big1);
+
+				if (PolygonIsLessThanOnePixel(here, not_big1))
+				{
+					//here += 4;
+					//npolygon = clsUtil::ReadInt(here, not_big1)
+					not_big2 = clsUtil::ReadByte(here);
+					here += 12;
+					double x = clsUtil::ReadDouble(here, not_big2);
+					double y = clsUtil::ReadDouble(here, not_big2);
+					clsStruct::POLYGON *pPgon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON));
+					if (pPgon == NULL)
+					{
+						free(pp);
+						pp = 0;
+						break;
+					}
+
+					clsStruct::LINE *pRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE));
+					if (pRing == NULL)
+					{
+						free(pp);
+						pp = 0;
+						free(pPgon);
+						pPgon = 0;
+						break;
+					}
+
+					pPgon[0].nRing = 1;
+					pPgon[0].p = pRing;
+
+					clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT));
+
+					pRing[0].nPoint = 1;
+					pRing[0].p = pPoint;
+
+					double x0 = 0, y0 = 0;
+					this->ToScale(x, y, x0, y0);
+					pPoint[0].x = x0;
+					pPoint[0].y = y0;
+
+					pp[i].nPolygon = 1;
+					pp[i].p = pPgon;
+				}
+				else
+				{
+
+					clsStruct::POLYGON *pPgon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON) * npolygon);
+					//clsStruct::MPOLYGON mpgon;
+					if (pPgon == NULL)
+						continue;
+					pp[i].nPolygon = npolygon;
+					pp[i].p = pPgon;
+
+					for (int j = 0; j < npolygon; j++)
+					{
+						not_big2 = clsUtil::ReadByte(here);
+						here += 4; //跳过 shapetype, 没意义, 必然是polygon
+
+						nring = clsUtil::ReadInt(here, not_big2);
+						clsStruct::LINE *pRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE) * nring);
+						if (pRing == NULL)
+							break;
+						pPgon[j].nRing = nring;
+						pPgon[j].p = pRing;
+						//clsStruct::POLYGON pgon;
+
+						for (int k = 0; k < nring; k++)
+						{
+							npoint = clsUtil::ReadInt(here, not_big2);
+							clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * npoint);
+							if (pPoint == NULL)
+								break;
+							pRing[k].nPoint = npoint;
+							pRing[k].p = pPoint;
+							//clsStruct::LINE ring;
+
+							for (int m = 0; m < npoint; m++)
+							{
+								double x = clsUtil::ReadDouble(here, not_big2);
+								double y = clsUtil::ReadDouble(here, not_big2);
+								if (hasZ)
+								{
+									//Z 值跳过
+									here += 8;
+								}
+								double x0 = 0, y0 = 0;
+								this->ToScale(x, y, x0, y0);
+
+								pPoint[m].x = x0;
+								pPoint[m].y = y0;
+							}
+						}
+					}
+				}
+			}
+
+			for (int j = 0; j < n_fields - 1; j++) //这里从第二列开始
+			{
+				m_vAllField[i][j] = (char *)PQgetvalue(res, i, j + 1);
+			}
+		}
+
+		m_pData = pp;
+		return true;
+	}
+
+/*
+	bool DataCollection::MallocForPoint(Point *p)
+	{
+		m_iStructType = clsStruct::Struct_Point;
+
+		clsStruct::POINT *pp = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT));
+		if (pp == NULL)
+			return false;
+		double x = p->m_dX;
+		double y = p->m_dY;
+		double x0 = 0, y0 = 0;
+		this->ToScale(x, y, x0, y0);
+
+		pp[0].x = x0;
+		pp[0].y = y0;
+
+		m_pData = pp;
+		return true;
+	}
+	bool DataCollection::MallocForMultiPoint(MultiPoint *mp)
+	{
+		m_iStructType = clsStruct::Struct_Line;
+
+		clsStruct::LINE *pp = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE));
+		if (pp == NULL)
+			return false;
+		int npoint = (int)(mp->m_vX.size());
+		clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * npoint);
+		if (pPoint == NULL)
+			return false;
+		pp->nPoint = npoint;
+		pp->p = pPoint;
+
+		for (int i = 0; i < npoint; i++)
+		{
+			double x = mp->m_vX[i];
+			double y = mp->m_vY[i];
+			double x0 = 0, y0 = 0;
+			this->ToScale(x, y, x0, y0);
+
+			pPoint[i].x = x0;
+			pPoint[i].y = y0;
+		}
+
+		m_pData = pp;
+		return true;
+	}
+	bool DataCollection::MallocForPath(Path *path)
+	{
+		m_iStructType = clsStruct::Struct_Line;
+
+		clsStruct::LINE *pp = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE));
+		if (pp == NULL)
+			return false;
+		int npoint = (int)(path->m_vX.size());
+		clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * npoint);
+		if (pPoint == NULL)
+			return false;
+		pp->nPoint = npoint;
+		pp->p = pPoint;
+
+		for (int i = 0; i < npoint; i++)
+		{
+			double x = path->m_vX[i];
+			double y = path->m_vY[i];
+			double x0 = 0, y0 = 0;
+			this->ToScale(x, y, x0, y0);
+
+			pPoint[i].x = x0;
+			pPoint[i].y = y0;
+		}
+
+		m_pData = pp;
+		return true;
+	}
+	bool DataCollection::MallocForMultiLineString(MultiLineString *ml)
+	{
+		m_iStructType = clsStruct::Struct_MLine;
+
+		clsStruct::MLINE *pp = (clsStruct::MLINE *)malloc(sizeof(clsStruct::MLINE));
+		if (pp == NULL)
+			return false;
+		int nLine = (int)(ml->m_vLineX.size());
+		clsStruct::LINE *pPath = (clsStruct::LINE *)(malloc(sizeof(clsStruct::LINE) * nLine));
+		if (pPath == NULL)
+		{
+			free(pp);
+			pp = 0;
+			return false;
+		}
+		pp->nLine = nLine;
+		pp->p = pPath;
+
+		for (int i = 0; i < nLine; i++)
+		{
+			int nPoint = (int)(ml->m_vLineX[i].size());
+			clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * nPoint);
+			if (pPoint == NULL)
+			{
+				pPath[i].nPoint = 0;
+				pPath[i].p = 0;
+				continue;
+			}
+			pPath[i].nPoint = nPoint;
+			pPath[i].p = pPoint;
+
+			for (int j = 0; j < nPoint; j++)
+			{
+				double x = ml->m_vLineX[i][j];
+				double y = ml->m_vLineY[i][j];
+				double x0 = 0, y0 = 0;
+				this->ToScale(x, y, x0, y0);
+
+				pPoint[j].x = x0;
+				pPoint[j].y = y0;
+			}
+		}
+
+		m_pData = pp;
+
+		return true;
+	}
+	bool DataCollection::MallocForRing(Ring *ring)
+	{
+		m_iStructType = clsStruct::Struct_Line;
+		m_iPartCount = 1;
+		clsStruct::LINE *pp = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE));
+		if (pp == NULL)
+			return false;
+		int npoint = (int)(ring->m_vX.size());
+		clsStruct::POINT *pPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * npoint);
+		if (pPoint == NULL)
+		{
+			free(pp);
+			pp = 0;
+			return false;
+		}
+		pp->nPoint = npoint;
+		pp->p = pPoint;
+
+		for (int i = 0; i < npoint; i++)
+		{
+			double x = ring->m_vX[i];
+			double y = ring->m_vY[i];
+			double x0 = 0, y0 = 0;
+			this->ToScale(x, y, x0, y0);
+
+			pPoint[i].x = x0;
+			pPoint[i].y = y0;
+		}
+		m_pData = pp;
+		return true;
+	}
+
+	bool DataCollection::MallocForPolygon(Polygon *pPolygon)
+	{
+		m_iStructType = clsStruct::Struct_Polygon;
+		m_iPartCount = 1;
+
+		clsStruct::POLYGON *pp = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON));
+		if (pp == NULL)
+			return false;
+		int nRing = (int)(pPolygon->m_vR.size());
+		clsStruct::LINE *pStRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE) * nRing);
+		if (pStRing == NULL)
+		{
+			free(pp);
+			pp = 0;
+			return false;
+		}
+		pp->nRing = nRing;
+		pp->p = pStRing;
+
+		for (int i = 0; i < nRing; i++)
+		{
+			Ring *ring = pPolygon->m_vR[i];
+
+			int nPoint = (int)(ring->m_vX.size());
+			clsStruct::POINT *pStPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * nPoint);
+			if (pStPoint == NULL)
+			{
+				pStRing[i].nPoint = 0;
+				pStRing[i].p = 0;
+				continue;
+			}
+
+			pStRing[i].nPoint = nPoint;
+			pStRing[i].p = pStPoint;
+			for (int j = 0; j < nPoint; j++)
+			{
+				double x = ring->m_vX[j];
+				double y = ring->m_vY[j];
+				double x0 = 0, y0 = 0;
+				this->ToScale(x, y, x0, y0);
+				pStPoint[j].x = x0;
+				pStPoint[j].y = y0;
+			}
+		}
+		m_pData = pp;
+		return true;
+	}
+
+	bool DataCollection::MallocForMultiPolygon(MultiPolygon *mp)
+	{
+		m_iPartCount = 1;
+		m_iStructType = clsStruct::Struct_MPolygon;
+		clsStruct::MPOLYGON *pp = (clsStruct::MPOLYGON *)malloc(sizeof(clsStruct::MPOLYGON));
+		if (pp == NULL)
+			return false;
+		int nPolygon = (int)(mp->m_vpPolygon.size());
+		clsStruct::POLYGON *pStPolygon = (clsStruct::POLYGON *)malloc(sizeof(clsStruct::POLYGON) * nPolygon);
+		if (pStPolygon == NULL)
+		{
+			free(pp);
+			pp = 0;
+			return false;
+		}
+		pp->nPolygon = nPolygon;
+		pp->p = pStPolygon;
+
+		for (int i = 0; i < nPolygon; i++)
+		{
+			Polygon *pPolygon = mp->m_vpPolygon[i];
+
+			int nRing = (int)(pPolygon->m_vR.size());
+			clsStruct::LINE *pStRing = (clsStruct::LINE *)malloc(sizeof(clsStruct::LINE) * nRing);
+			if (pStRing == NULL)
+			{
+				pStPolygon[i].nRing = 0;
+				pStPolygon[i].p = 0;
+				continue;
+			}
+
+			pStPolygon[i].nRing = nRing;
+			pStPolygon[i].p = pStRing;
+			for (int j = 0; j < nRing; j++)
+			{
+				Ring *pRing = pPolygon->m_vR[j];
+
+				int nPoint = (int)(pRing->m_vX.size());
+				clsStruct::POINT *pStPoint = (clsStruct::POINT *)malloc(sizeof(clsStruct::POINT) * nPoint);
+				if (pStPoint == NULL)
+				{
+					pStRing[j].nPoint = 0;
+					pStRing[j].p = 0;
+					continue;
+				}
+				pStRing[j].nPoint = nPoint;
+				pStRing[j].p = pStPoint;
+
+				for (int k = 0; k < nPoint; k++)
+				{
+					double x = pRing->m_vX[k];
+					double y = pRing->m_vY[k];
+					double x0 = 0, y0 = 0;
+					this->ToScale(x, y, x0, y0);
+					pStPoint[k].x = x0;
+					pStPoint[k].y = y0;
+				}
+			}
+		}
+		m_pData = pp;
+		return true;
+	}*/
+
+	/*
+	Free
+	*/
+	bool DataCollection::FreeForPOINT()
+	{
+		free(m_pData);
+		m_pData = NULL;
+		return true;
+	}
+
+	bool DataCollection::FreeForLINE()
+	{
+		clsStruct::LINE *pp = (clsStruct::LINE *)m_pData;
+		for (int i = 0; i < m_iPartCount; i++)
+		{
+			free(pp[i].p);
+		}
+		free(m_pData);
+		m_pData = NULL;
+		return true;
+	}
+
+	bool DataCollection::FreeForMLINE()
+	{
+		clsStruct::MLINE *pp = (clsStruct::MLINE *)m_pData;
+
+		for (int i = 0; i < m_iPartCount; i++)
+		{
+			int nLine = pp[i].nLine;
+			clsStruct::LINE *pLine = pp[i].p;
+			for (int j = 0; j < nLine; j++)
+				free(pLine[j].p);
+			free(pLine);
+		}
+		free(m_pData);
+		m_pData = NULL;
+		return true;
+	}
+
+	bool DataCollection::FreeForPOLYGON()
+	{
+		clsStruct::POLYGON *pp = (clsStruct::POLYGON *)m_pData;
+
+		for (int i = 0; i < m_iPartCount; i++)
+		{
+			int nRing = pp[i].nRing;
+			clsStruct::LINE *pRing = pp[i].p;
+			for (int j = 0; j < nRing; j++)
+				free(pRing[j].p);
+			free(pRing);
+		}
+		free(m_pData);
+		m_pData = NULL;
+		return true;
+	}
+	bool DataCollection::FreeForMPOLYGON()
+	{
+		clsStruct::MPOLYGON *pp = (clsStruct::MPOLYGON *)m_pData;
+
+		for (int i = 0; i < m_iPartCount; i++)
+		{
+			clsStruct::POLYGON *pPolygon = pp[i].p;
+			int nPolygon = pp[i].nPolygon;
+
+			for (int j = 0; j < nPolygon; j++)
+			{
+				int nRing = pPolygon[j].nRing;
+				clsStruct::LINE *pRing = pPolygon[j].p;
+
+				for (int k = 0; k < nRing; k++)
+					free(pRing[k].p);
+
+				free(pRing);
+			}
+			free(pPolygon);
+		}
+		free(m_pData);
+		m_pData = NULL;
+		return true;
+	}
+
+	void DataCollection::ToScale(double x, double y, double &x0, double &y0)
+	{
+		x0 = m_dR * x + m_dXdis;
+		y0 = -m_dR * y + m_dYdis;
+		//return true;
+	}
+
+	bool DataCollection::CollectAllField(PGresult *res)
+	{
+		//直接认为第一列是shape元素,跳过
+		int n_tuples = PQntuples(res);
+		int n_fields = PQnfields(res);
+
+		//创建预留空间
+		m_vAllField.resize(n_tuples);
+		for (int i = 0; i < n_tuples; i++)
+			m_vAllField[i].resize(n_fields - 1); //这里是不包含shape 数据的
+		//开辟预留空间后, 可以直接赋值,不需要 pushback
+		for (int i = 0; i < n_tuples; i++)
+		{
+			for (int j = 0; j < n_fields - 1; j++) //这里从第二列开始
+			{
+				const char *ss = PQgetvalue(res, i, j + 1);
+				m_vAllField[i][j] = PQgetvalue(res, i, j + 1);
+			}
+		}
+
+		m_vFieldName.resize(n_fields - 1);
+		for (int i = 0; i < n_fields - 1; i++) //从第二列开始
+		{
+			m_vFieldName[i] = PQfname(res, i + 1);
+		}
+		return true;
+	}
+
+	bool DataCollection::CollectFieldName(PGresult *res)
+	{
+		//直接认为第一列是shape元素,跳过
+		int n_fields = PQnfields(res);
+		if (n_fields < 2)
+			return false;
+
+		for (int i = 0; i < n_fields - 1; i++) //从第二列开始
+		{
+			string fieldname = PQfname(res, i + 1);
+			if (fieldname == "geodmap_area")
+			{
+				m_dmapAreaIndex = i;
+				n_fields--;
+				break;
+			}
+		}
+
+		m_vFieldName.resize(n_fields - 1);
+		for (int i = 0; i < n_fields - 1; i++) //从第二列开始
+		{
+			m_vFieldName[i] = PQfname(res, i + 1);
+		}
+		return true;
+	}
+
+	shared_ptr<PointClass> DataCollection::GetDataPoint(unsigned char *vc)
+	{
+		unsigned char hasZorSrsid = ((unsigned char *)(vc + 4))[0] / 16;
+		unsigned char hasZ = hasZorSrsid / 8;
+		unsigned char hasSrsid = hasZorSrsid % 8;
+
+		int not_big = clsUtil::ReadByte(vc);
+		int shapetype = clsUtil::ReadInt(vc, not_big);
+		if (hasSrsid)
+			vc += 4;
+
+		double x = clsUtil::ReadDouble(vc, not_big);
+		double y = clsUtil::ReadDouble(vc, not_big);
+
+		shared_ptr<PointClass> point(new PointClass());
+		point->x = x;
+		point->y = y;
+		return point;
+	}
+
+	shared_ptr<PointClass> DataCollection::GetMDataPoint(unsigned char *vc)
+	{
+		unsigned char hasZorSrsid = ((unsigned char *)(vc + 4))[0] / 16;
+		unsigned char hasZ = hasZorSrsid / 8;
+		unsigned char hasSrsid = hasZorSrsid % 8;
+
+		int not_big = clsUtil::ReadByte(vc);
+		int shapetype = clsUtil::ReadInt(vc, not_big);
+
+		if (hasSrsid)
+		{
+			int srsid = clsUtil::ReadInt(vc, not_big);
+		}
+
+		unsigned char *here = vc;
+
+		int nPointCount = clsUtil::ReadInt(vc, not_big);
+
+		for (int j = 0; j < nPointCount; j++)
+		{
+			//clsStruct::LINE path;
+
+			int not_big2 = clsUtil::ReadByte(vc);
+			vc += 4; //跳过 shapetype 读取
+			double x = clsUtil::ReadDouble(vc, not_big);
+			double y = clsUtil::ReadDouble(vc, not_big);
+
+			shared_ptr<PointClass> point(new PointClass());
+			point->x = x;
+			point->y = y;
+			return point;
+		}
+		shared_ptr<PointClass> point(new PointClass());
+	    return point;
+	}
+
+	shared_ptr<PolygonClass> DataCollection::GetDataLine(unsigned char *vc)
+	{
+		unsigned char hasZorSrsid = ((unsigned char *)(vc + 4))[0] / 16;
+		unsigned char hasZ = hasZorSrsid / 8;
+		unsigned char hasSrsid = hasZorSrsid % 8;
+
+		int not_big = clsUtil::ReadByte(vc);
+		int shapetype = clsUtil::ReadInt(vc, not_big);
+		if (hasSrsid)
+		{
+			int srsid = clsUtil::ReadInt(vc, not_big);
+		}
+
+		shared_ptr<PolygonClass> p_polygon(new PolygonClass());
+		p_polygon->polygonCount = 1;
+		double pol_minx = 1000000000;
+		double pol_miny = 1000000000;
+		double pol_maxx = -100000000;
+		double pol_maxy = -100000000;
+		//pp[i].nLine = nLine;
+		//pp[i].p = pPath;
+
+		//for (int j = 0; j < nLine; j++)
+		{
+			//clsStruct::LINE path;
+
+			//int not_big2 = clsUtil::ReadByte(vc);
+			//vc += 4; //跳过 shapetype 读取
+
+			int nPoint = clsUtil::ReadInt(vc, not_big);
+			p_polygon->vecParts.push_back(nPoint);
+			for (int k = 0; k < nPoint; k++)
+			{
+				//clsStruct::POINT point;
+
+				double x = clsUtil::ReadDouble(vc, not_big);
+				double y = clsUtil::ReadDouble(vc, not_big);
+				p_polygon->vec_X.push_back(x);
+				p_polygon->vec_Y.push_back(y);
+				if (hasZ)
+					vc += 8;
+				if (pol_minx > x)
+					pol_minx = x;
+				if (pol_miny > y)
+					pol_miny = y;
+				if (pol_maxx < x)
+					pol_maxx = x;
+				if (pol_maxy < y)
+					pol_maxy = y;
+			}
+		}
+		p_polygon->minx = pol_minx;
+		p_polygon->miny = pol_miny;
+		p_polygon->maxx = pol_maxx;
+		p_polygon->maxy = pol_maxy;
+		return p_polygon;
+	}
+
+	shared_ptr<PolygonClass> DataCollection::GetDataMLine(unsigned char *vc)
+	{
+		unsigned char hasZorSrsid = ((unsigned char *)(vc + 4))[0] / 16;
+		unsigned char hasZ = hasZorSrsid / 8;
+		unsigned char hasSrsid = hasZorSrsid % 8;
+
+		int not_big = clsUtil::ReadByte(vc);
+		int shapetype = clsUtil::ReadInt(vc, not_big);
+
+		if (hasSrsid)
+		{
+			int srsid = clsUtil::ReadInt(vc, not_big);
+		}
+
+		int nLine = clsUtil::ReadInt(vc, not_big);
+		shared_ptr<PolygonClass> p_polygon(new PolygonClass());
+		p_polygon->polygonCount = nLine;
+		double pol_minx = 1000000000;
+		double pol_miny = 1000000000;
+		double pol_maxx = -100000000;
+		double pol_maxy = -100000000;
+		//pp[i].nLine = nLine;
+		//pp[i].p = pPath;
+
+		for (int j = 0; j < nLine; j++)
+		{
+			//clsStruct::LINE path;
+
+			int not_big2 = clsUtil::ReadByte(vc);
+			vc += 4; //跳过 shapetype 读取
+
+			int nPoint = clsUtil::ReadInt(vc, not_big2);
+			p_polygon->vecParts.push_back(nPoint);
+			for (int k = 0; k < nPoint; k++)
+			{
+				//clsStruct::POINT point;
+
+				double x = clsUtil::ReadDouble(vc, not_big2);
+				double y = clsUtil::ReadDouble(vc, not_big2);
+				p_polygon->vec_X.push_back(x);
+				p_polygon->vec_Y.push_back(y);
+				if (hasZ)
+					vc += 8;
+				if (pol_minx > x)
+					pol_minx = x;
+				if (pol_miny > y)
+					pol_miny = y;
+				if (pol_maxx < x)
+					pol_maxx = x;
+				if (pol_maxy < y)
+					pol_maxy = y;
+			}
+		}
+		p_polygon->minx = pol_minx;
+		p_polygon->miny = pol_miny;
+		p_polygon->maxx = pol_maxx;
+		p_polygon->maxy = pol_maxy;
+		return p_polygon;
+	}
+
+	shared_ptr<PolygonClass> DataCollection::GetDataPolygon(unsigned char *here)
+	{
+		shared_ptr<PolygonClass> p_polygon(new PolygonClass());
+		try
+		{
+			unsigned char hasZorSrsid = ((unsigned char *)(here + 4))[0] / 16;
+			unsigned char hasZ = hasZorSrsid / 8;
+			unsigned char hasSrsid = hasZorSrsid % 8;
+			//bool hasZ = false;
+			int not_big1, not_big2, shapetype1, nring, npoint;
+			not_big1 = clsUtil::ReadByte(here);
+			shapetype1 = clsUtil::ReadInt(here, not_big1);
+			if (hasSrsid)
+			{
+				int srsid = clsUtil::ReadInt(here, not_big1);
+			}
+
+			double pol_minx = 1000000000;
+			double pol_miny = 1000000000;
+			double pol_maxx = -100000000;
+			double pol_maxy = -100000000;
+
+			p_polygon->polygonCount = 1;
+
+			//for (int j = 0; j < 1; j++)
+			//{
+			//not_big2 = clsUtil::ReadByte(here);
+			//here += 4; //跳过 shapetype, 没意义, 必然是polygon
+
+			nring = clsUtil::ReadInt(here, not_big1);
+			p_polygon->vecParts.push_back(nring);
+
+			for (int k = 0; k < nring; k++)
+			{
+				npoint = clsUtil::ReadInt(here, not_big1);
+				p_polygon->vecParts.push_back(npoint);
+
+				for (int m = 0; m < npoint; m++)
+				{
+					double x = clsUtil::ReadDouble(here, not_big1);
+					double y = clsUtil::ReadDouble(here, not_big1);
+					if (hasZ)
+						here += 8;
+					p_polygon->vec_X.push_back(x);
+					p_polygon->vec_Y.push_back(y);
+
+					if (pol_minx > x)
+						pol_minx = x;
+					if (pol_miny > y)
+						pol_miny = y;
+					if (pol_maxx < x)
+						pol_maxx = x;
+					if (pol_maxy < y)
+						pol_maxy = y;
+				}
+			}
+			//}
+
+			p_polygon->minx = pol_minx;
+			p_polygon->miny = pol_miny;
+			p_polygon->maxx = pol_maxx;
+			p_polygon->maxy = pol_maxy;
+
+			if (p_polygon->vec_X.size() == 0)
+			{
+				//delete p_polygon;
+				return NULL;
+			}
+		}
+		catch (const std::exception &e)
+		{
+			//std::cerr << e.what() << '\n';
+			//delete p_polygon;
+			return NULL;
+		}
+
+		return p_polygon;
+	}
+
+	shared_ptr<PolygonClass> DataCollection::GetDataMPolygon(unsigned char *here)
+	{
+		shared_ptr<PolygonClass> p_polygon(new PolygonClass());
+		try
+		{
+			unsigned char hasZorSrsid = ((unsigned char *)(here + 4))[0] / 16;
+			unsigned char hasZ = hasZorSrsid / 8;
+			unsigned char hasSrsid = hasZorSrsid % 8;
+
+			unsigned char geom_type = (here)[1];
+
+			if (geom_type == DCGeometryType::GeometryType_Point)
+			{
+				int not_big1 = clsUtil::ReadByte(here);
+				int shapetype1 = clsUtil::ReadInt(here, not_big1);
+				if (hasSrsid)
+					here += 4;
+				p_polygon->polygonCount = 1;
+				double x = clsUtil::ReadDouble(here, not_big1);
+				double y = clsUtil::ReadDouble(here, not_big1);
+
+				p_polygon->minx = x;
+				p_polygon->miny = y;
+				p_polygon->maxx = x;
+				p_polygon->maxy = y;
+
+				p_polygon->vec_X.push_back(x);
+				p_polygon->vec_Y.push_back(y);
+			}
+			else
+			{
+				int not_big1, not_big2, shapetype1, npolygon, nring, npoint;
+				not_big1 = clsUtil::ReadByte(here);
+				shapetype1 = clsUtil::ReadInt(here, not_big1);
+				if (hasSrsid)
+					here += 4; //跳过srid
+				npolygon = clsUtil::ReadInt(here, not_big1);
+				/*clsStruct::POLYGON* pPgon = (clsStruct::POLYGON*)malloc(sizeof(clsStruct::POLYGON)* npolygon);*/
+				//clsStruct::MPOLYGON mpgon;
+				if (npolygon == 0)
+				{
+					return NULL;
+				}
+				double pol_minx = 1000000000;
+				double pol_miny = 1000000000;
+				double pol_maxx = -100000000;
+				double pol_maxy = -100000000;
+
+				p_polygon->polygonCount = npolygon;
+
+				for (int j = 0; j < npolygon; j++)
+				{
+					not_big2 = clsUtil::ReadByte(here);
+					here += 4; //跳过 shapetype, 没意义, 必然是polygon
+
+					nring = clsUtil::ReadInt(here, not_big2);
+					p_polygon->vecParts.push_back(nring);
+
+					for (int k = 0; k < nring; k++)
+					{
+						npoint = clsUtil::ReadInt(here, not_big2);
+						p_polygon->vecParts.push_back(npoint);
+
+						for (int m = 0; m < npoint; m++)
+						{
+							double x = clsUtil::ReadDouble(here, not_big2);
+							double y = clsUtil::ReadDouble(here, not_big2);
+							if (hasZ)
+								here += 8;
+							p_polygon->vec_X.push_back(x);
+							p_polygon->vec_Y.push_back(y);
+
+							if (pol_minx > x)
+								pol_minx = x;
+							if (pol_miny > y)
+								pol_miny = y;
+							if (pol_maxx < x)
+								pol_maxx = x;
+							if (pol_maxy < y)
+								pol_maxy = y;
+						}
+					}
+				}
+
+				p_polygon->minx = pol_minx;
+				p_polygon->miny = pol_miny;
+				p_polygon->maxx = pol_maxx;
+				p_polygon->maxy = pol_maxy;
+
+				if (p_polygon->vec_X.size() == 0)
+				{
+					//delete p_polygon;
+					return NULL;
+				}
+			}
+		}
+		catch (const std::exception &e)
+		{
+			//std::cerr << e.what() << '\n';
+			//delete p_polygon;
+			return NULL;
+		}
+
+		return p_polygon;
+	}
+
+}

+#pragma once
+#ifndef _DataCollection_H_
+#define _DataCollection_H_
+
+#include<vector>
+#include<string>
+#include "dmap_core.h"
+#include<libpq-fe.h>
+#include <map>
+#include "memory"
+using namespace std;
+
+namespace DmapCore_30
+{
+	
+	
+ enum DMapFieldType
+{
+	dmapShort = 0,
+	dmapInt = 1,
+	dmapLong = 2,
+	dmapDouble = 3,
+	dmapBoolean = 4,
+	dmapChar = 5,
+	dmapString = 6,
+	dmapGeography = 7,
+	dmapData = 8,
+	dmapGeometry = 9,
+	shapePoint = 10,
+	shapeLineString = 11,
+	shapePolygon = 12,
+	shapeMultiPoint = 13,
+	shapeMultiLineString = 14,
+	shapeMultiPolygon = 15
+};
+
+
+/*static enum ZoomFlag
+{
+dmapZoomReset = 0,
+dmapZoomIn = 1,
+dmapZoomOut = 2,
+dmapZoomNoChange = 3
+};*/
+
+ enum PointType
+{
+	dmapPointTypeCircle = 0,     //圆
+	dmapPointTypeTriangle = 1,    //三角形
+	dmapPointTypeSquare = 2,      //正方形
+	dmapPointTypeCross = 3,        //十字架
+	dmapPointTypeStar = 4,         //五角星
+};
+ enum LineType
+{
+	dmapLineTypeSolid = 0,
+	dmapLineTypeDash = 1,
+	dmapLineTypeDot = 2,
+	dmapLineTypeDashDot = 3,
+	dmapLineTypeDashDotDot = 4,
+};
+
+enum DCGeometryType
+	{
+		GeometryType_Point = 1,
+        GeometryType_LineString = 2,
+        GeometryType_Polygon = 3,
+        GeometryType_MultiPoint = 4,
+        GeometryType_MultiLineString = 5,
+      	GeometryType_MultiPolygon = 6,
+	};
+
+ enum GeometryType
+{
+	dmapGeometryPoint = 0,
+	dmapGeometryMultiPoint = 1,
+	dmapGeometryPath = 2,
+	dmapGeometryMultiLineString = 3,
+	dmapGeometryRing = 4,
+	dmapGeometryPolygon = 5,
+	dmapGeometryMultiPolygon = 6
+};
+ 
+ enum ImageType
+{
+	dmapImageTypePNG = 0,
+	dmapImageTypeJPG = 1
+};
+ enum StorageType
+{
+	dmapStorageTypeExploded = 0,
+	dmapStorageTypeCompact = 1
+};
+
+/*
+range的[lower,upper]区间两个端点是否使用
+all表示两边使用
+upper表示使用大端点,不使用小端点
+*/
+ enum EqulityType
+{
+	dmapEqualityAll = 0,
+	dmapEqualityUpper = 1,
+	dmapEqualityLower = 2,
+	dmapEqualityNone = 3
+};
+
+
+ enum dmapAntialias
+{
+	dmapAntialiasingDefault=0,
+	dmapAntialiasingNone = 1,
+	dmapAntialiasingGray = 2,
+	dmapAntialiasingSubpixel = 3,
+	dmapAntialiasingFast = 4,
+	dmapAntialiasingGood = 5,
+	dmapAntialiasingBest = 6,
+	dmapAntialiasingTrue = 7,
+	dmapAntialiasingFalse = 8
+};
+
+
+ enum dmapLineLabelPositionDirection
+{
+	dmapLineLabelPositionLevel = 0,
+	dmapLineLabelPositionParallel = 1,
+	dmapLineLabelPositionCurved = 2,
+	dmapLineLabelPositionVertical = 3,
+};
+
+ enum dmapLineLabelPositionPlace  //在线上方或下方 或左边或右边 或者线上
+{
+	dmapLineLabelPositionLeft = 0,
+	dmapLineLabelPositionRight = 1,
+	dmapLineLabelPositionOnTop = 2,
+	dmapLineLabelPositionAbove = 3,
+	dmapLineLabelPositionBelow = 4,
+};
+
+ enum dmapLineLabelPositionStartOrEnd
+{
+	dmapLineLabelPositionStart = 0,
+	dmapLineLabelPositionEnd = 1,
+	dmapLineLabelPositionCenter = 2,
+};
+
+ enum dmapPolygonLabelPositionDirection
+{
+	dmapPolygonLabelPositionParallel = 0,
+	dmapPolygonLabelPositionStraight = 1,
+	dmapPolygonLabelPositionParallelAndStraight = 2,
+};
+
+
+ enum dmapRotateMethod
+{
+	dmapRotate_geographic = 0,
+	dmapRotate_Arithmetic = 1,
+	dmapRotate_Mod_arithmetic = 2
+};
+
+	class PGeomClass
+	{
+	public:
+		vector<char *> m_pdata;
+	    ~PGeomClass()
+   		 {
+        for (size_t i = 0; i < m_pdata.size(); i++)
+        {
+            char *data = m_pdata.at(i);
+            if (data != 0)
+            {
+                free(data);
+                m_pdata[i] = 0;
+            }
+        }
+        m_pdata.clear();
+    }
+	};
+
+
+	class PointClass :public PGeomClass
+	{
+	public:
+		float x;
+		float y;
+	};
+
+
+
+	class PolygonClass :public PGeomClass
+	{
+	public:
+		unsigned  int polygonCount;
+		vector<int> vecParts;
+		vector<float> vec_X;
+		vector<float> vec_Y;
+
+		float minx;
+		float miny;
+		float maxx;
+		float maxy;
+	};
+
+	//class Point;
+	//class MultiPoint;
+//	class Path;
+//	class MultiLineString;
+	//class Ring;
+	//class Polygon;
+//	class MultiPolygon;
+	//class Geometry;
+	class CORE_EXPORT DataCollection
+	{
+	public:
+
+		void InitDataCollection(PGresult* res, int shapeType,int imageWidth, int imageHeight, int subset, double r = 1, double dScaleDenominator=1,double x_dis = 0, double y_dis = 0);
+		//DataCollection(Recordsets* recss, int shapeType, double r = 1, double x_dis = 0, double y_dis = 0);
+		//void InitDataCollection(Geometry* geom, double r = 1, double dScaleDenominator=1, double x_dis = 0, double y_dis = 0);
+
+
+		void InitHeatCollection(PGresult* res,int shapeType,int imageWidth, int imageHeight, double layer_minx, double layer_maxx, double layer_miny, double layer_maxy,
+			int subset, double r = 1, double dScaleDenominator=1,double x_dis = 0, double y_dis = 0);
+
+	
+		
+	
+		~DataCollection();
+
+		DataCollection();
+
+	//	void InitDataCollection();
+		int m_iPartCount;
+		int m_iStructType;
+		void * m_pData;  //此指针只能够是自定义的6种结构体类型
+
+		vector<vector<string> > m_vAllField;  //这是结果集的所有除 shape 外的field, 数组中每个元素表示一行数据
+		vector<string> m_vFieldName; // 这是所有字段的名字
+		double m_dR;
+		double m_dXdis;
+		double m_dYdis;
+		double m_dScaleDenominator;
+
+		int m_imageWidth =0;
+		int m_imageHeight =0;
+
+		int m_subset;
+
+		bool m_dmapAreaIndex = -1;
+
+		//shared_ptr<DataHeatCollection> pHeatData;
+
+	private:
+		int m_iN;
+
+
+		bool MallocForPoint(PGresult* res);
+		bool MallocForMultiLineString(PGresult* res);
+		bool MallocForPolygon(PGresult *res);
+		bool MallocForMultiPolygon(PGresult* res);
+
+		bool MallocForPolygonForGeom(PGresult *res);
+        bool MallocForLineStringGeom(PGresult *res);
+
+		//bool MallocForHeatCollectionGeom(PGresult *res,int dcigridColIndex);
+
+		//bool MallocForPoint(Point* p);
+		//bool MallocForMultiPoint(MultiPoint* mp);
+		//bool MallocForPath(Path* path);
+		//bool MallocForMultiLineString(MultiLineString* ml);
+		//bool MallocForRing(Ring* ring);
+		//bool MallocForPolygon(Polygon* pPolygon);
+		//bool MallocForMultiPolygon(MultiPolygon* mp);
+
+		bool PolygonIsLessThanOnePixel(unsigned char* here,int not_big1);
+
+		/*
+		Struct_Point = 0,
+		Struct_Line = 1,
+		Struct_MLine = 2,
+		Struct_Polygon = 3,
+		Struct_MPolygon = 4
+		*/
+		bool FreeForPOINT();
+		bool FreeForLINE();
+		bool FreeForMLINE();
+		bool FreeForPOLYGON();
+		bool FreeForMPOLYGON();
+
+		inline void ToScale(double x, double y, double&x0, double&y0);
+		bool CollectAllField(PGresult* res);
+		bool CollectFieldName(PGresult* res);
+
+
+		shared_ptr<PointClass> GetDataPoint(unsigned char *vc);
+		shared_ptr<PointClass> GetMDataPoint(unsigned char *vc);
+		shared_ptr<PolygonClass> GetDataLine(unsigned char *vc);
+		shared_ptr<PolygonClass> GetDataMLine(unsigned char *vc);
+		shared_ptr<PolygonClass> GetDataPolygon(unsigned char *vc);
+		shared_ptr<PolygonClass> GetDataMPolygon(unsigned char *vc);
+	};
+
+
+	
+
+}
+#endif
\ No newline at end of file

+
+#ifndef _GroupRenderer_H_
+#define _GroupRenderer_H_
+
+#include "GroupRenderer.h"
+#include"SimpleMarkerSymbol.h"
+#include"SimpleLabelRenderer.h"
+#include"SimpleLineSymbol.h"
+#include"SimplePolygonSymbol.h"
+#include"ValueMapRenderer.h"
+//#include"RangeMapRenderer.h"
+#include"SimpleRenderer.h"
+#include"TrueTypeMarkerSymbol.h"
+#include "clsUtil.h"
+#include "clsXML.h"
+
+namespace DmapCore_30
+{
+	GroupRenderer::GroupRenderer()
+	{
+		m_vSymbols = {};
+		m_sTag = "";
+		m_sXML = "";
+		m_simpleRenderer = true;
+	}
+	GroupRenderer::~GroupRenderer()
+	{
+		this->Clear();
+	}
+	bool GroupRenderer::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
+	{
+		
+		//遍历所有节点
+			for (auto ptchild =pt.begin(); ptchild != pt.end(); ++ptchild)
+			{
+				//所有子节点都是样式
+				Renderer* renderer = NULL;
+				if (clsXML::XMLParse(ptchild->first, ptchild->second,  &renderer))
+				{
+					if (renderer)m_vSymbols.push_back(renderer);
+				}
+			}
+			return true;
+		
+
+	}
+
+	void  GroupRenderer::ToJson(AppendBuffer *ab)
+	{
+
+		//strcat(resultbuff,R"("GROUPRENDERER":[)");
+		ab->AppendString(R"("GROUPRENDERER":[)");
+		int length = (int)m_vSymbols.size();
+		for (int i = 0; i < length; i++)
+		{
+			if(i>0){
+				ab->AppendString(",");
+			} 
+			//	strcat(resultbuff,",");
+			Renderer* renderer = m_vSymbols[i];
+			renderer->ToJson(ab);
+		}
+		ab->AppendString("]");
+		//strcat(resultbuff,"]");
+		
+
+	}
+
+
+
+	GroupRenderer* GroupRenderer::CreateNew()
+	{
+		GroupRenderer* dest = new GroupRenderer();
+		return dest;
+	}
+	int GroupRenderer::RendererType()
+	{
+		return dmapGroupRenderer;
+	}
+
+	const char* GroupRenderer::GetTag()
+	{
+		return m_sTag.c_str();
+	}
+	bool  GroupRenderer::SetTag(const char* sTag)
+	{
+		if (!sTag)
+			return false;
+		m_sTag = sTag;
+		return true;
+	}
+	bool  GroupRenderer::AddSymbol(int index, Renderer* pRenderer)
+	{
+		int length__ = m_vSymbols.size();
+		if (index > length__)return false;
+		pRenderer->AddRef();
+		if (index < 0 || index == length__)
+			m_vSymbols.push_back(pRenderer);
+		else
+			m_vSymbols.insert(m_vSymbols.begin() + index, pRenderer);
+		return true;
+	}
+	bool  GroupRenderer::Remove(int index)
+	{
+		RemoveIndexP(index, m_vSymbols);
+	}
+	Renderer* GroupRenderer::GetItem(int index)
+	{
+		GetIndexP(index, m_vSymbols);
+	}
+	bool  GroupRenderer::SetItem(int index, Renderer* pRenderer)
+	{
+		SetIndexP(index, pRenderer, m_vSymbols);
+	}
+	int   GroupRenderer::GetSymbolCount()
+	{
+		int length = (int)m_vSymbols.size();
+		return length;
+
+	}
+	bool  GroupRenderer::Clear()
+	{
+		ClearP(m_vSymbols);
+	}
+
+	//bool GroupRenderer::DrawSimpleData(clsCrSurf* pClsCS, DataCollection* data, char* pFlag)
+	//{
+	//	int length = (int)(m_vSymbols.size());
+
+	//	for (int i = 0; i < length; i++)
+	//	{
+	//		Renderer* renderer = m_vSymbols[i];
+	//		if (renderer->m_simpleRenderer)
+	//		{
+	//			int renType = renderer->RendererType();
+	//			renderer->DrawData(pClsCS, data, pFlag);
+	//		}
+	//	}
+	//	return true;
+	//}
+
+
+	bool GroupRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
+	{
+		int length = (int)(m_vSymbols.size());
+
+		for (int i = 0; i < length; i++)
+		{
+			Renderer* renderer = m_vSymbols[i];
+			//if (renderer->m_simpleRenderer == drawSimpleData)
+			{
+				int renType = renderer->RendererType();
+				renderer->DrawData(pClsCS, data,true, pFlag);
+			}
+		}
+		return true;
+	}
+	bool GroupRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag)
+	{
+		int length = (int)(m_vSymbols.size());
+		for (int i = 0; i < length; i++)
+		{
+			Renderer* renderer = m_vSymbols[i];
+			int renType = renderer->RendererType();
+			renderer->DrawData(pClsCS, data, dataIndex, pFlag);
+		}
+		return true;
+	}
+
+	 bool GroupRenderer::DrawLegend(clsCrSurf* pClsCS,  shared_ptr<legendParamater> pLegendParamater,  int layerType,char* pFlag = NULL) 
+	 {
+		 int length = (int)(m_vSymbols.size());
+		for (int i = 0; i < length; i++)
+		{
+			Renderer* renderer = m_vSymbols[i];
+			int renType = renderer->RendererType();
+			renderer->DrawLegend(pClsCS, pLegendParamater,layerType, pFlag);
+		}
+		 return true;
+	 }
+
+
+	void GroupRenderer::TryAddField(vector<string>&pvField)
+	{
+		int length = (int)(m_vSymbols.size());
+		for (int i = 0; i < length; i++)
+		{
+			if (m_vSymbols[i] == 0)continue;
+			m_vSymbols[i]->TryAddField(pvField);
+		}
+	}
+
+	bool GroupRenderer::TryFindHeatRenderer()
+	{
+		 int length = (int)(m_vSymbols.size());
+		for (int i = 0; i < length; i++)
+		{
+			Renderer* renderer = m_vSymbols[i];
+			if(renderer->TryFindHeatRenderer())
+			{
+				return true;
+			}
+		}
+		 return false;
+	}
+}
+
+#endif
\ No newline at end of file

+#pragma once
+#include<vector>
+using namespace std;
+#include"Renderer.h"
+
+namespace DmapCore_30
+{
+	class clsCrSurf;
+	class DataCollection;
+	class GroupRenderer :public Renderer
+	{
+	public:
+		GroupRenderer();
+		~GroupRenderer();
+		static GroupRenderer* CreateNew();
+		virtual int RendererType();
+		virtual bool Parse(boost::property_tree::ptree &pt, AppendBuffer *f);
+		virtual void ToJson(AppendBuffer *ab);
+	//	virtual bool DrawSimpleData(clsCrSurf* pClsCS, DataCollection* data, char* pFlag);
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag);
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag);
+		virtual bool DrawLegend(clsCrSurf* pClsCS,  shared_ptr<legendParamater> pLegendParamater, int layerType, char* pFlag);
+		vector<Renderer*> m_vSymbols;
+		const char* GetTag();
+		bool  SetTag(const char* sTag);
+		bool  AddSymbol(int index, Renderer*);
+		bool  Remove(int index);
+		Renderer* GetItem(int index);
+		bool  SetItem(int index, Renderer* pRenderer);
+		int   GetSymbolCount();
+		bool  Clear();
+
+		void TryAddField(vector<string>&pvField);
+		bool TryFindHeatRenderer();
+	private:
+
+		string m_sTag;
+	};
+
+}
\ No newline at end of file

+
+
+#include "Renderer.h"
+#include"SimpleMarkerSymbol.h"
+#include"SimplePolygonSymbol.h"
+#include"ValueMapRenderer.h"
+//#include"RangeMapRenderer.h"
+#include"GroupRenderer.h"
+#include"SimpleLineSymbol.h"
+
+#include"clsUtil.h"
+#include"clsMalloc.h"
+#include <unistd.h>
+#include <algorithm>
+namespace DmapCore_30
+{
+	Renderer::Renderer()
+	{
+		m_iN = 1;
+	}
+
+
+	Renderer::~Renderer()
+	{
+	}
+
+	bool Renderer::AddRef()
+	{
+		m_iN++;
+		return true;
+	}
+	bool Renderer::Release()
+	{
+		m_iN--;
+		if (m_iN < 0)
+			return false;
+		if (!m_iN)
+		{
+			switch (this->RendererType())
+			{
+			case dmapSimpleMarkerSymbol:delete (SimpleMarkerSymbol*)this; break;
+			case dmapSimpleLineSymbol:
+				delete ((SimpleLineSymbol*)this);
+				break;
+			case dmapSimplePolygonSymbol: delete (SimplePolygonSymbol*)this; break;
+			case dmapValueMapRenderer: delete (ValueMapRenderer*)this; break;
+			//case dmapRangeMapRenderer: delete (RangeMapRenderer*)this; break;
+			case dmapGroupRenderer: delete (GroupRenderer*)this; break;
+			default:
+				delete this;
+				break;
+			}
+		}
+		return true;
+	}
+
+	int Renderer::GetN()
+	{
+		return m_iN;
+	}
+/*
+	bool Renderer::RendererXmlParse(Renderer**ppRen, const char* fileName)
+	{
+		if (!(*ppRen))
+		{
+			rapidxml::xml_document<char> doc;
+			rapidxml::file<> fdoc(fileName);
+			try
+			{
+				doc.parse<0>(fdoc.data());
+			}
+			catch (...)
+			{
+				return false;
+			}
+
+			rapidxml::xml_node<char>* root = doc.first_node();
+			bool flag = clsXML::XMLParse(root, NULL, ppRen);
+			return flag;
+		}
+		AppendBuffer ab(fileName);
+		clsXML::XMLHead(&ab);
+		clsXML::XMLParse(NULL, &ab, ppRen);
+	
+		return true;
+	}
+*/
+	void Renderer::TryAddField2(vector<string>&pvField, std::string field)
+	{
+		if (field.size() == 0)return;
+		vector<string>::iterator it = find(pvField.begin(), pvField.end(), field);
+		if (it == pvField.end())
+			pvField.push_back(field);
+	};
+
+	string Renderer::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 Renderer::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);
+	}
+
+
+	void Renderer::TryAddField(vector<string>&pvField)
+	{
+		
+	};
+/*
+	bool Renderer::RenStr(Renderer** ppRen, const char** psXML)
+	{
+		using namespace rapidxml;
+		if (*ppRen == NULL)
+		{
+			if (psXML == 0 || *psXML == 0 || (*psXML)[0] == 0)return false;
+			char *xml = _strdup(*psXML); clsMalloc mcx(xml);
+			if (xml == 0 || xml[0] == 0)return false;
+			try{
+				xml_document<> doc;    // character type defaults to char
+				doc.parse<0>(xml);
+				xml_node<char> *n = doc.first_node();
+				if (n == 0){ return false; }
+				bool flag = clsXML::XMLParse(n, NULL, ppRen);
+				return flag;
+			}
+			catch (parse_error e)
+			{
+				
+				return false;
+			}
+			catch (...)
+			{
+				return false;
+			}
+		}
+		AppendBuffer ab(0);
+		clsXML::XMLParse(NULL, &ab, ppRen);
+		clsMalloc clsM1(ab.GetString());
+		(*ppRen)->m_sXML = clsM1.mem;
+	
+		*psXML = (*ppRen)->m_sXML.c_str();
+		return true;
+	
+	}*/
+}
+

+
+#ifndef _Renderer_H_
+#define _Renderer_H_
+#pragma once
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/foreach.hpp>
+#include <string>
+#include "AppendBuffer.h"
+#include "legendParamater.h"
+#include <memory>
+#include <cairo/cairo.h>
+#include"clsXML.h"
+#include "dmap_core.h"
+using namespace std;
+namespace DmapCore_30
+{
+
+	 enum RendererType
+{
+	dmapSimpleMarkerSymbol = 1,
+	dmapSimpleLineSymbol = 2,
+	dmapSimplePolygonSymbol = 3,
+	dmapValueMapRenderer = 4,
+	dmapRangeMapRenderer = 5,
+	dmapGroupRenderer = 6,
+	dmapScaleDependentRenderer = 7,
+	dmapSimpleLabelRenderer = 8,
+	dmapTrueTypeMarkerSymbol = 9,
+	dmapSimpleRenderer = 10,
+	dmapTextSymbol = 11,
+	dmapHeatMapRenderer = 12
+};
+
+	class clsCrSurf;
+	class DataCollection;
+	class CORE_EXPORT  Renderer
+	{
+	public:
+		Renderer();
+		~Renderer();
+		bool AddRef();
+		bool Release();
+		virtual int RendererType() = 0;
+		virtual void ToJson(AppendBuffer *ab)=0;
+
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag = NULL) = 0;
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag = NULL) =0;
+		virtual bool Parse( boost::property_tree::ptree &pt, AppendBuffer *f) = 0;
+		//static bool RendererXmlParse(Renderer**pRen, const char* fileName);
+		//static bool RenStr(Renderer** ppRen, const char** psXML);    //纯粹作弊,什么都没干,直接调用现有接口
+
+		virtual bool DrawLegend(clsCrSurf* pClsCS,  shared_ptr<legendParamater> pLegendParamater, int layerType, char* pFlag = NULL) = 0;
+
+		virtual void TryAddField(vector<string>&pvField);
+		virtual bool TryFindHeatRenderer()=0;
+		void TryAddField2(vector<string>&pvField, std::string field);
+
+
+		string GetFilePath(string path);
+		int GetCurrentFolderPath(char* processdir, size_t len);
+		int GetN();//仅作调试使用
+		string m_sXML;
+
+		bool m_simpleRenderer;
+	private:
+		int m_iN;
+
+		
+	};
+
+}
+
+#endif
\ No newline at end of file

+
+#include "ScaleDependentRenderer.h"
+#include"clsXML.h"
+#include"DataCollection.h"
+#include"SimpleMarkerSymbol.h"
+#include"SimpleLabelRenderer.h"
+#include"SimpleLineSymbol.h"
+#include"SimplePolygonSymbol.h"
+#include"ValueMapRenderer.h"
+#include"RangeMapRenderer.h"
+#include"GroupRenderer.h"
+namespace DmapCore_30
+{
+	ScaleDependentRenderer::ScaleDependentRenderer()
+	{
+		m_dLower = 0.0;
+		m_dUpper = 1e308;
+		m_pRenderer = NULL;
+		m_simpleRenderer = false;
+	}
+
+
+	ScaleDependentRenderer::~ScaleDependentRenderer()
+	{
+		if (m_pRenderer)
+		{
+			m_pRenderer->Release();
+			m_pRenderer = NULL; //注意手工重置为 NULL
+		}
+	}
+	BOOL ScaleDependentRenderer::Parse(rapidxml::xml_node<char>* node, AppendBuffer *f)
+	{
+		if (!node&& !f)return false;
+		clsXML clsX(f, "SCALEDEPENDENTRENDERER");
+		clsXML::XMLAttrParse(node, f, &m_dLower, "lower");
+		clsXML::XMLAttrParse(node, f, &m_dUpper, "upper");
+		clsX.closeProperties();
+		if (node)
+		{
+			clsXML::XMLParse(node->first_node(), NULL, &m_pRenderer);
+		}
+		else
+		{
+			clsXML::XMLParse(NULL, f, &m_pRenderer);
+		}
+		return true;
+	}
+
+    void  ScaleDependentRenderer::ToJson(AppendBuffer *ab)
+	{
+
+	}
+
+	//BOOL ScaleDependentRenderer::RendererString(Renderer** ppRen, const char** psXML)
+	//{
+	//	return true;
+	//}
+
+	int ScaleDependentRenderer::RendererType()
+	{
+		return dmapScaleDependentRenderer;
+	}
+	ScaleDependentRenderer* ScaleDependentRenderer::CreateNew()
+	{
+		ScaleDependentRenderer* sdr = new ScaleDependentRenderer();
+		return sdr;
+	}
+
+	double ScaleDependentRenderer::GetLower()
+	{
+		return m_dLower;
+	}
+	BOOL ScaleDependentRenderer::SetLower(double lower)
+	{
+		if (lower < 0)
+			return false;
+		m_dLower = lower;
+		return true;
+	}
+	double ScaleDependentRenderer::GetUpper()
+	{
+		return m_dUpper;
+	}
+	BOOL ScaleDependentRenderer::SetUpper(double upper)
+	{
+		if (upper < 0)
+			return false;
+		m_dUpper = upper;
+		return true;
+	}
+
+	Renderer* ScaleDependentRenderer::GetRenderer()
+	{
+		if (m_pRenderer)
+			m_pRenderer->AddRef();
+		return m_pRenderer;
+	}
+	BOOL ScaleDependentRenderer::SetRenderer(Renderer* renderer)
+	{
+		if (!renderer)
+			return false;
+		renderer->AddRef();
+		if (m_pRenderer)
+			m_pRenderer->Release();
+		m_pRenderer = renderer;
+		return true;
+	}
+
+	BOOL ScaleDependentRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, 
+	bool drawSimpleData, char* pFlag)
+	{
+		//DrawData是否要使用重载??现在弄进去有麻烦啊
+		double r__ = data->m_dR;
+		double r = r__ / (96/0.0254);
+		if (r <m_dLower || r > m_dUpper)
+			return false;
+		int renType = m_pRenderer->RendererType();
+		m_pRenderer->DrawData(pClsCS, data, pFlag);
+		/*switch (renType)
+		{
+		case dmapSimpleMarkerSymbol:((SimpleMarkerSymbol*)m_pRenderer)->DrawData(pClsCS, data); break;
+		case dmapSimpleLineSymbol:((SimpleLineSymbol*)m_pRenderer)->DrawData(pClsCS, data); break;
+		case dmapSimplePolygonSymbol:((SimplePolygonSymbol*)m_pRenderer)->DrawData(pClsCS, data); break;
+		case dmapValueMapRenderer:((ValueMapRenderer*)m_pRenderer)->DrawData(pClsCS, data); break;
+		case dmapRangeMapRenderer:((RangeMapRenderer*)m_pRenderer)->DrawData(pClsCS, data); break;
+		case dmapGroupRenderer:((GroupRenderer*)m_pRenderer)->DrawData(pClsCS, data, pFlag); break;
+		case dmapSimpleLabelRenderer:((SimpleLabelRenderer*)m_pRenderer)->DrawData(pClsCS, data, pFlag); break;
+		default:
+		break;
+		}*/
+		return true;
+	}
+
+	BOOL  ScaleDependentRenderer::DrawData(clsCrSurf* pClsCS, 
+	DataCollection* data, int dataIndex, char* pFlag)
+	{
+		//DrawData是否要使用重载??现在弄进去有麻烦啊
+		double r__ = data->m_dR;
+		double r = r__ / (96/0.0254);
+		if (r <m_dLower || r > m_dUpper)
+			return false;
+		int renType = m_pRenderer->RendererType();
+	//	data->m_pData
+		m_pRenderer->DrawData(pClsCS, data, dataIndex, pFlag);
+		/*switch (renType)
+		{
+		case dmapSimpleMarkerSymbol:((SimpleMarkerSymbol*)m_pRenderer)->DrawData(pClsCS, data); break;
+		case dmapSimpleLineSymbol:((SimpleLineSymbol*)m_pRenderer)->DrawData(pClsCS, data); break;
+		case dmapSimplePolygonSymbol:((SimplePolygonSymbol*)m_pRenderer)->DrawData(pClsCS, data); break;
+		case dmapValueMapRenderer:((ValueMapRenderer*)m_pRenderer)->DrawData(pClsCS, data); break;
+		case dmapRangeMapRenderer:((RangeMapRenderer*)m_pRenderer)->DrawData(pClsCS, data); break;
+		case dmapGroupRenderer:((GroupRenderer*)m_pRenderer)->DrawData(pClsCS, data, pFlag); break;
+		case dmapSimpleLabelRenderer:((SimpleLabelRenderer*)m_pRenderer)->DrawData(pClsCS, data, pFlag); break;
+		default:
+		break;
+		}*/
+		return true;
+	}
+
+	BOOL ScaleDependentRenderer::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag)
+	{
+	
+		return true;
+	}
+	
+
+	void ScaleDependentRenderer::TryAddField(vector<string>&pvField)
+	{
+		if (m_pRenderer)m_pRenderer->TryAddField(pvField);
+	}
+}
\ No newline at end of file

+#ifndef _ScaleDependentRenderer_H_
+#define _ScaleDependentRenderer_H_
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/foreach.hpp>
+#include"Renderer.h"
+#include<vector>
+#include "dmap_core.h"
+using namespace std;
+namespace DmapCore_30
+{
+	class clsCrSurf;
+	class DataCollection;
+	class CORE_EXPORT ScaleDependentRenderer :public Renderer
+	{
+	public:
+		//scale中只有一个样式,通常为group
+		ScaleDependentRenderer();
+		~ScaleDependentRenderer();
+		virtual BOOL Parse(rapidxml::xml_node<char>* node, AppendBuffer *f);
+		virtual void ToJson(AppendBuffer *ab);
+		//virtual BOOL RendererString(Renderer** ppRen, const char** psXML);
+		virtual BOOL DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag);
+		virtual BOOL DrawData(clsCrSurf* pClsCS, DataCollection* data, int drawSimpleData, char* pFlag);
+        virtual BOOL DrawLegend(clsCrSurf* pClsCS,  shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag);
+		virtual int RendererType();
+		static ScaleDependentRenderer* CreateNew();
+
+
+		double GetLower();
+		BOOL SetLower(double lower);
+		double GetUpper();
+		BOOL SetUpper(double upper);
+		Renderer* GetRenderer();
+		BOOL SetRenderer(Renderer* renderer);
+
+		virtual void TryAddField(vector<string>&pvField);
+		virtual bool TryFindHeatRenderer(){ return false; }
+
+		double m_dLower;
+		double m_dUpper;
+		Renderer* m_pRenderer;
+	};
+
+}
+#endif
\ No newline at end of file

+
+
+#include "SimpleLabelRenderer.h"
+#include"clsXML.h"
+#include"DataCollection.h"
+#include"clsCrSurf.h"
+#define _USE_MATH_DEFINES
+#include<math.h>
+#include"clsMalloc.h"
+#include"clsUtil.h"
+//#include"StringHelp.h"
+//#include"algorithm.h"
+#include<iterator>
+#include <stdlib.h>
+#include <iostream> 
+#include "clsJson.h"
+#include <string.h>
+//#include <string.h>
+#define dotX 5
+#define dotY 5
+#define WordIntervalLine 8.0  //文字与线条隔开两个像素
+#define WordIntervalPoint 5.0  //文字与点隔开两个像素
+namespace DmapCore_30
+{
+
+SimpleLabelRenderer::SimpleLabelRenderer()
+{
+	m_pTextSymbol = new TextSymbol();
+	m_sField = "";
+	m_sLabelPriorities = "0,0,0,0,0,0,0,0";
+	m_pTextSymbol = NULL;
+	/*m_iFeatureWeight = 0;
+	m_iLabelWeight = 0;
+	m_iHowmanyLabels = 0;
+	m_dLabelBufferRatio = 0;*/
+	m_sRotationAngles = "0";
+	//m_iRotateMethod = 0;
+	m_vdAngles.push_back(0);
+	m_sRotationAngleField = "";
+	m_bIsVerticalToAngle = false;
+	this->DoSetPointLabelPositionType();
+	m_iLineLabelPositionDirection = 0;
+	m_iLineLabelPositionStartOrEnd = 0;
+	m_sLineLabelPositionPlaces = "9,9,9";
+	this->DoSetLineLabelPositionPlaces();
+	
+	m_iPolygonLabelPositionDirection = 0;
+	m_bLabelInPolygon = false;
+	m_simpleRenderer = false;
+}
+
+
+SimpleLabelRenderer::~SimpleLabelRenderer()
+{
+	if (m_pTextSymbol)
+		m_pTextSymbol->Release();
+}
+
+int SimpleLabelRenderer::RendererType()
+{
+	return dmapSimpleLabelRenderer;
+}
+bool  SimpleLabelRenderer::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
+{
+
+	clsXML clsX(f, "SIMPLELABELRENDERER");
+	clsXML::XMLAttrParse(pt, f, &m_sField, "field");
+
+
+	clsXML::XMLAttrParse(pt, f, &m_sLabelPriorities, "labelpriorities");
+	clsXML::XMLAttrParse(pt, f, &m_sRotationAngles, "rotationangles");
+	//clsXML::ParseEnum("rotatemethod", pt, f, &m_iRotateMethod,"geograghic","arithmetic","mod_arithmetic");
+	clsXML::XMLAttrParse(pt, f, &m_sRotationAngleField, "rotationanglefield");
+	clsXML::XMLAttrParse(pt, f,&m_bIsVerticalToAngle,"isverticaltoangle" );
+	//if (pt)
+		this->DoSetPointLabelPositionType();
+
+	clsXML::ParseEnum("linelabelpositiondirection", pt, f, &m_iLineLabelPositionDirection, "level", "parallel", "curved","vertical");
+	clsXML::ParseEnum("linelabelpositionstartorend",pt,f,&m_iLineLabelPositionStartOrEnd,"start","end","center");
+	clsXML::XMLAttrParse(pt, f, &m_sLineLabelPositionPlaces, "linelabelpositionplace"); 
+	if (m_sLineLabelPositionPlaces == "error")
+	{
+		m_sLineLabelPositionPlaces = "9,9,9";
+	}
+	//if (pt)
+		this->DoSetLineLabelPositionPlaces();
+
+
+	clsXML::ParseEnum("polygonlabelpositiondirection",pt,f,&m_iPolygonLabelPositionDirection,"parallel","straight","parallelandstraight");
+	clsXML::XMLAttrParse(pt, f, &m_bLabelInPolygon, "labelinpolygon");
+	clsX.closeProperties();
+	//if (pt)
+	//{
+		Renderer* ts = NULL;
+		boost::property_tree::ptree pt_textsymbol = pt.get_child("TEXTSYMBOL");
+		clsXML::XMLParse("TEXTSYMBOL",pt_textsymbol, &ts);
+		m_pTextSymbol = (TextSymbol*)ts;		
+	//}
+	//else
+	//{
+	//	Renderer* ren = (Renderer*)m_pTextSymbol;
+	//	clsXML::XMLParse(NULL, f, &ren);
+	//}
+
+	return true;
+}
+
+ void  SimpleLabelRenderer::ToJson(AppendBuffer *ab)
+ {
+	 	char buff[300] = {0};
+		char resultbuff[5000] = {0};
+		strcat(resultbuff, R"("SIMPLELABELRENDERER":{)");
+		clsJson::JsonAttrParse("field", resultbuff, buff, this->m_sField);
+		clsJson::JsonAttrParse("labelpriorities", resultbuff, buff, this->m_sLabelPriorities);
+		clsJson::JsonAttrParse("rotationangles", resultbuff, buff, this->m_sRotationAngles);
+		clsJson::JsonAttrParse("rotationanglefield", resultbuff, buff, this->m_sRotationAngleField);
+		clsJson::JsonAttrParse("isverticaltoangle", resultbuff, buff, this->m_bIsVerticalToAngle);
+
+		clsJson::ParseEnum("linelabelpositiondirection", resultbuff, buff, m_iLineLabelPositionDirection, "level", "parallel", "curved","vertical");
+		clsJson::ParseEnum("linelabelpositionstartorend", resultbuff, buff, m_iLineLabelPositionStartOrEnd, "start","end","center");
+		clsJson::JsonAttrParse("linelabelpositionplace", resultbuff, buff, m_sLineLabelPositionPlaces);
+		clsJson::ParseEnum("polygonlabelpositiondirection", resultbuff, buff, m_iPolygonLabelPositionDirection, "parallel","straight","parallelandstraight");
+
+		clsJson::JsonAttrParse("labelinpolygon", resultbuff, buff, this->m_bLabelInPolygon);
+		ab->AppendString(resultbuff);
+		if(m_pTextSymbol)
+		{
+			m_pTextSymbol->ToJson(ab);
+			ab->AppendString("}");
+		}
+		else
+		{
+			ab->AppendString(R"("JsonEnd":"" })");
+		}
+		
+		//clsJson::JsonAttrEnd(resultbuff);
+ }
+//bool SimpleLabelRenderer::RendererString(Renderer** ppRen, const char** psXML)
+//{
+//	return true;
+//}
+
+bool SimpleLabelRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
+{
+	int iPartCount = data->m_iPartCount;
+	if (m_pTextSymbol == 0)
+	{
+		return true;
+	}
+
+	//m_lpt = this->DoSetLabelPositionType();
+	m_pTextSymbol->SetCairo(pClsCS);
+
+	for (int i = 0; i < iPartCount; i++)
+		this->DrawStruct(pClsCS, data, i);
+	return true;
+}
+
+
+bool SimpleLabelRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag)
+{
+	int iPartCount = data->m_iPartCount;
+	if (m_pTextSymbol == 0)
+	{
+		return true;
+	}
+	//m_lpt = this->DoSetLabelPositionType();
+	m_pTextSymbol->SetCairo(pClsCS);
+
+	//for (int i = 0; i < iPartCount; i++)
+	this->DrawStruct(pClsCS, data, dataIndex);
+	return true;
+}
+
+SimpleLabelRenderer* SimpleLabelRenderer::CreateNew()
+{
+	SimpleLabelRenderer* dest = new SimpleLabelRenderer();
+	return dest;
+}
+const char*  SimpleLabelRenderer::GetField()
+{
+	return m_sField.c_str();
+}
+bool    SimpleLabelRenderer::SetField(const char* sField)
+{
+	m_sField = sField;
+	return true;
+}
+const char*  SimpleLabelRenderer::GetLabelPriorities()
+{
+	return m_sLabelPriorities.c_str();
+}
+bool    SimpleLabelRenderer::SetLabelPriorities(const char* sLabelPriorities)
+{
+	bool flag = this->TrackPriorityString(sLabelPriorities);
+	if (!flag)
+		return false;
+	m_sLabelPriorities = sLabelPriorities;
+
+	this->DoSetPointLabelPositionType();
+	return true;
+}
+TextSymbol* SimpleLabelRenderer::GetTextSymbol()
+{
+	if (m_pTextSymbol)
+		m_pTextSymbol->AddRef();
+	return m_pTextSymbol;
+}
+bool    SimpleLabelRenderer::SetTextSymbol(TextSymbol* ts)
+{
+	if (!ts)
+		return false;
+	ts->AddRef();
+	if (m_pTextSymbol)
+		m_pTextSymbol->Release();
+	m_pTextSymbol = ts;
+	return true;
+}
+const char*SimpleLabelRenderer::GetRotationAngleField()
+{
+	return m_sRotationAngleField.c_str();
+}
+bool    SimpleLabelRenderer::SetRotationAngleField(const char* sAngleField)
+{
+	m_sRotationAngleField = sAngleField;
+	if (m_sRotationAngleField != "")
+	{
+		this->DoSetPointLabelPositionType();
+	}
+	return true;
+}
+const char* SimpleLabelRenderer::GetRotationAngles()
+{
+	return m_sRotationAngles.c_str();
+}
+bool    SimpleLabelRenderer::SetRotationAngles(const char* sRotationalAngles)
+{
+	m_sRotationAngles = sRotationalAngles;
+	bool bIsNumber = this->TrackRotationAngles(sRotationalAngles);
+	if (bIsNumber)
+	{
+		this->CalculateAngles();
+		this->DoSetPointLabelPositionType();
+	}
+		
+	return true;
+}
+//int          SimpleLabelRenderer::GetRotateMethod()
+//{
+//	return m_iRotateMethod;
+//}
+//bool         SimpleLabelRenderer::SetRotateMethod(int iRotateMethod)
+//{
+//	m_iRotateMethod = iRotateMethod;
+//	return true;
+//}
+int SimpleLabelRenderer::GetLineLabelPositionDirection()
+{
+	return m_iLineLabelPositionDirection;
+}
+bool SimpleLabelRenderer::SetLineLabelPositionDirection(int iLineLabelPositionDirection)
+{
+	m_iLineLabelPositionDirection = iLineLabelPositionDirection;
+	return true;
+}
+const char*SimpleLabelRenderer::GetLineLabelPositionPlace()
+{
+	return m_sLineLabelPositionPlaces.c_str();
+}
+bool SimpleLabelRenderer::SetLineLabelPositionPlace(const char*sLineLabelPositionPlace)
+{
+	m_sLineLabelPositionPlaces = sLineLabelPositionPlace;
+	this->DoSetLineLabelPositionPlaces();
+	return true;
+}
+int SimpleLabelRenderer::GetLineLabelPositionStartOrEnd()
+{
+	return m_iLineLabelPositionStartOrEnd;
+}
+bool SimpleLabelRenderer::SetLineLabelPositionStartOrEnd(int iLineLabelPositionStartOrEnd)
+{
+	m_iLineLabelPositionStartOrEnd = iLineLabelPositionStartOrEnd;
+	return true;
+}
+
+int     SimpleLabelRenderer::GetPolygonLabelPositionDirection()
+{
+	return m_iPolygonLabelPositionDirection;
+}
+bool    SimpleLabelRenderer::SetPolygonLabelPositionDirection(int iPolygonLabelPositionDirection)
+{
+	m_iPolygonLabelPositionDirection = iPolygonLabelPositionDirection;
+	return true;
+}
+bool    SimpleLabelRenderer::GetLabelInPolygon()
+{
+	return m_bLabelInPolygon;
+}
+bool    SimpleLabelRenderer::SetLabelInPolygon(bool bLabelInPolygon)
+{
+	m_bLabelInPolygon = bLabelInPolygon;
+	return true;
+}
+bool    SimpleLabelRenderer::GetIsVerticalToAngle()
+{
+	return m_bIsVerticalToAngle;
+}
+bool    SimpleLabelRenderer::SetIsVerticalToAngle(bool bIsVerticalToAngle)
+{
+	m_bIsVerticalToAngle = bIsVerticalToAngle;
+	return true;
+}
+
+
+
+bool SimpleLabelRenderer::DoSetLineLabelPositionPlaces()
+{
+	if (m_sLineLabelPositionPlaces == "")
+		return true;
+	const char* sLLPP = m_sLineLabelPositionPlaces.c_str();
+
+	char str[1000];
+	strcpy(str, sLLPP);
+	int len = strlen(str);
+	char * p = str;
+	int k = 0;
+	for (int i = 0; i < len + 1; i++)
+	{
+		char c = str[i];
+		if (c == 0)
+		{
+			m_LineLabelPositionPlaces[k] = stoi(p, NULL);
+			break;
+		}
+		if (c == ',')
+		{
+			str[i] = 0;
+			m_LineLabelPositionPlaces[k++] = stoi(p, NULL);
+			p = str + i+1;
+		}
+	}
+	return true;
+}
+
+
+void SimpleLabelRenderer::TryAddField(vector<string>&pvField)
+{
+	TryAddField2(pvField, m_sField);
+	if (m_plpt == SimpleLabelRenderer::dmapPointLabelPositionAngleField)
+	{
+		TryAddField2(pvField, m_sRotationAngleField);
+	}
+
+	
+	/*
+	vector<string>::iterator it = find(pvField->begin(), pvField->end(), m_sField);
+	if (it == pvField->end())
+		pvField->push_back(m_sField);
+
+	if (m_plpt == SimpleLabelRenderer::dmapPointLabelPositionAngleField)
+	{
+		vector<string>::iterator it = find(pvField->begin(), pvField->end(), m_sRotationAngles);
+		if (it == pvField->end())
+			pvField->push_back(m_sRotationAngleField);
+	}*/
+}
+
+
+
+SimpleLabelRenderer::PointLabelPositionType SimpleLabelRenderer::DoSetPointLabelPositionType()
+{
+	if (m_sLabelPriorities != "0,0,0,0,0,0,0,0")
+	{
+		if (m_sLabelPriorities == "DMap_PlaceOnTopHorizontal")
+			m_plpt = SimpleLabelRenderer::dmapPointLabelPositionOnTopHorizontal;
+		else
+		{
+			//判断是否是8个数字
+			const char* sLabelPriorities = m_sLabelPriorities.c_str();
+			bool isNumbers = this->TrackPriorityString(sLabelPriorities);
+			if (!isNumbers)
+				m_plpt = SimpleLabelRenderer::dmapPointLabelPositionError;
+			else
+			{
+				m_plpt = SimpleLabelRenderer::dmapPointLabelPositionPeriphery;
+				this->CalculatePrioritiesNumber();
+			}
+				
+		}
+	}
+	else
+	{
+		if (m_sRotationAngleField != "")
+			m_plpt = SimpleLabelRenderer::dmapPointLabelPositionAngleField;
+		else
+			m_plpt = SimpleLabelRenderer::dmapPointLabelPositionAngleNumber;
+	}
+
+	return m_plpt;
+}
+
+bool SimpleLabelRenderer::TrackPriorityString(const char* sPriority)
+{
+	//判断 m_sLabelPriorities 是否是8个数字,是返回true
+	return true;
+}
+
+bool SimpleLabelRenderer::TrackRotationAngles(const char* sRotationalAngles)
+{
+	/*
+	这里偷个懒,认为只有正负号,小数点,逗号,数字的字符串就是合法的
+	*/
+	int len = strlen(sRotationalAngles);
+	bool bIsNumber = true;
+
+	for (int i = 0; i < len; i++)
+	{
+		char c = sRotationalAngles[i];
+		switch (c)
+		{
+		case '+':
+		case '-':
+		case '.':
+		case ',':
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			break;
+		default:
+			bIsNumber = false;
+			break;
+		}
+	}
+
+	return bIsNumber;
+
+}
+
+bool SimpleLabelRenderer::CalculatePrioritiesNumber()
+{
+	const char* ss = m_sLabelPriorities.c_str();
+
+	int num[8]; // 这是从字符串接收来的8个数字
+
+	for (int i = 0; i < 8; i++)
+	{
+		num[i] = ss[2 * i] - '0';
+		if (num[i] == 0)
+		{
+			num[i] = 9;  //将0 暂时作为9处理
+			m_i8[i] = 0;
+		}
+		else
+			m_i8[i] = i + 1;
+	}
+
+	int temp;
+	for (int i = 0; i < 7; i++)
+	{
+		for (int j = 0; j < 7 - i; j++)
+		{
+			if (num[j] > num[j + 1])
+			{
+				temp = num[j]; num[j] = num[j + 1]; num[j + 1] = temp;
+				temp = m_i8[j]; m_i8[j] = m_i8[j + 1]; m_i8[j + 1] = temp;
+			}
+		}
+	}
+	return true;
+}
+bool SimpleLabelRenderer::CalculateAngles()
+{
+	m_vdAngles.clear();
+	const char* sAngles = m_sRotationAngles.c_str();
+	int len = strlen(sAngles);
+	clsMalloc m(100);
+	char * sAngles_ = m.mem;
+	memcpy(sAngles_, sAngles, len);
+	char * p = sAngles_;
+	for (int i = 0; i <= len; i++)
+	{
+		char c = sAngles_[i];
+		if (!c)
+		{
+			double dAngle = stod(p, NULL);
+			dAngle = dAngle / 180 * M_PI;
+			m_vdAngles.push_back(dAngle);
+			break;
+		}
+			
+		if (c == ',')
+		{
+			sAngles_[i] = 0;
+			double dAngle = stod(p, NULL);
+			dAngle = dAngle / 180 * M_PI;
+			m_vdAngles.push_back(dAngle);
+			p = sAngles_ + i + 1;
+		}
+	}
+	return true;
+}
+
+
+bool SimpleLabelRenderer::DrawStruct(clsCrSurf* pClsCS, DataCollection* data, int index)
+{
+	int iStructType = data->m_iStructType;
+
+	/*
+	获取到SimpleLabelRenderer的field
+	*/
+	int iFieldCount = (int)(data->m_vFieldName.size());
+	int iFieldIndex = -1;
+	for (int i = 0; i < iFieldCount; i++)
+	{
+		if (strcmp(m_sField.c_str() , data->m_vFieldName[i].c_str()) ==0)
+		{
+			iFieldIndex = i;
+			break;
+		}
+	}
+	
+	if (iFieldIndex < 0)return false;
+	const char* sFieldValue_GBK = (data->m_vAllField[index][iFieldIndex]).c_str();	
+	if (sFieldValue_GBK == NULL || sFieldValue_GBK[0] == 0 || (sFieldValue_GBK[1] == 0 && sFieldValue_GBK[0] == ' '))
+	{
+		return false;
+	}
+
+	//if (index >= 2)
+	//{
+	//	return false;
+	//}
+
+//	printf(sFieldValue_GBK); printf(" %d \r\n", index);
+
+	/*printf(" %d \r\n",index);
+	if ( index == 72)
+	{
+		printf(" %d \r\n", index);
+	}*/
+
+	//clsMalloc clsM;
+	//bool flag = clsUtil::ConvertEncGB18030_UTF8(sFieldValue_GBK, clsM);
+	//if (!flag)
+		//return false;
+	//char* sUTF8 = (char *)sFieldValue_GBK;//clsM.mem;
+
+
+	switch (iStructType)
+	{
+	case clsStruct::Struct_Point:
+	{
+									/*clsStruct::POINT* pPoint = ((clsStruct::POINT*)(data->m_pData)) + index;
+									this->DrawPoint(pClsCS, pPoint, sUTF8);*/
+									this->DrawPoint(pClsCS, data, index, (char *)sFieldValue_GBK);
+									break;
+	}
+	case clsStruct::Struct_MLine:
+	{
+									clsStruct::MLINE* pMLine = ((clsStruct::MLINE*)(data->m_pData)) + index;
+									this->DrawMLine(pClsCS, pMLine, (char *)sFieldValue_GBK);
+									break;
+	}
+	case	clsStruct::Struct_MPolygon:
+	{
+										  clsStruct::MPOLYGON* pMPolygon = ((clsStruct::MPOLYGON*)(data->m_pData)) + index;
+										  this->DrawMPolygon(pClsCS, pMPolygon, (char *)sFieldValue_GBK);
+										  break;
+	}
+	default:
+		break;
+	}
+
+	return true;
+}
+
+
+
+bool SimpleLabelRenderer::DrawPoint(clsCrSurf* pClsCS, DataCollection* data, int index, char* sUTF8)
+{
+	clsStruct::POINT* pStructPoint = ((clsStruct::POINT*)(data->m_pData)) + index;
+	double x = pStructPoint->x, y = pStructPoint->y;
+
+	switch (m_plpt)
+	{
+	case SimpleLabelRenderer::dmapPointLabelPositionOnTopHorizontal:
+	{
+												  cairo_text_extents_t extents;
+												  cairo_text_extents(pClsCS->m_pCr, sUTF8, &extents);
+												  x = x - extents.width / 2;
+												  y = y + extents.height / 2;
+												  m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8);
+												  break;
+	}
+	case SimpleLabelRenderer::dmapPointLabelPositionAngleNumber:
+	{
+											  int iAnglesCount = m_vdAngles.size();
+											  for (int i = 0; i < iAnglesCount; i++)
+											  {
+												  double dAngle = m_vdAngles[i];
+						
+												  dAngle = clsUtil::StandardizationAngle(dAngle);
+												  double x_show, y_show;
+												  cairo_text_extents_t extents;
+												  cairo_text_extents(pClsCS->m_pCr, sUTF8, &extents);
+												  double dTextW = extents.x_advance;
+												  double dTextH = extents.height;
+												  if (dAngle >= 0 && dAngle < M_PI / 2)
+												  {
+													  if (m_bIsVerticalToAngle)
+													  {
+														  dAngle = dAngle - M_PI / 2;
+														  double dAngle__ = -dAngle;
+														  double x_ = x - cos(dAngle__)*dTextW / 2;
+														  double y_ = y + sin(dAngle__)*dTextW / 2;
+														  x_show = x_ + sin(dAngle__)*(dTextH + WordIntervalPoint);
+														  y_show = y_ + cos(dAngle__)*(dTextH + WordIntervalPoint);
+													  }
+													  else
+													  {
+														  double x_ = x - sin(dAngle)*dTextH / 2;
+														  double y_ = y + cos(dAngle)*dTextH / 2;
+														  x_show = x_ + cos(dAngle)*WordIntervalPoint;
+														  y_show = y_ + sin(dAngle)*WordIntervalPoint;
+													  }
+												  }
+												  else if ((dAngle > M_PI / 2) && (dAngle < M_PI))
+												  {
+													  if (m_bIsVerticalToAngle)
+													  {
+														  dAngle -= M_PI / 2;
+														  double x_ = x - cos(dAngle)*dTextW / 2;
+														  double y_ = y - sin(dAngle)*dTextW / 2;
+														  x_show = x_ - sin(dAngle)*(dTextH + WordIntervalPoint);
+														  y_show = y_ + cos(dAngle)*(dTextH + WordIntervalPoint);
+													  }
+													  else
+													  {
+														  double dAngle_ = dAngle - M_PI / 2;
+														  double x_ = x - cos(dAngle_)*(dTextW + WordIntervalPoint);
+														  double y_ = y + sin(dAngle_)*(dTextW + WordIntervalPoint);
+														  x_show = x_ + sin(dAngle_)*dTextH / 2;
+														  y_show = y_ + cos(dAngle_)*dTextH / 2;
+														  dAngle = -dAngle_;
+													  }
+												  }
+												  else if ((dAngle >= M_PI) && (dAngle <= 3 * M_PI / 2))
+												  {
+													  if (m_bIsVerticalToAngle)
+													  {
+														  double dAngle_ = dAngle - M_PI;
+														  double x_ = x - sin(dAngle_)*dTextW / 2;
+														  double y_ = y + cos(dAngle_)*dTextW / 2;
+														  x_show = x_ - cos(dAngle_)*WordIntervalPoint;
+														  y_show = y_ - sin(dAngle_)*WordIntervalPoint;
+
+														  dAngle = dAngle_ - M_PI / 2;
+													  }
+													  else
+													  {
+														  dAngle -= M_PI;
+														  double x_ = x - sin(dAngle)*dTextH / 2;
+														  double y_ = y + cos(dAngle)*dTextH / 2;
+														  x_show = x_ - cos(dAngle)*(dTextW + WordIntervalPoint);
+														  y_show = y_ - sin(dAngle)*(dTextW + WordIntervalPoint);
+													  }
+												  }
+												  else
+												  {
+													  if (m_bIsVerticalToAngle)
+													  {
+														  dAngle -= 3 * M_PI / 2;
+														  double x_ = x - cos(dAngle)* dTextW / 2;
+														  double y_ = y - sin(dAngle)* dTextW / 2;
+														  x_show = x_ + sin(dAngle)*WordIntervalPoint;
+														  y_show = y_ - cos(dAngle)* WordIntervalPoint;
+													  }
+													  else
+													  {
+														  double dAngle_ = 2 * M_PI - dAngle;
+														  double x_ = x + sin(dAngle_)*dTextH / 2;
+														  double y_ = y + cos(dAngle_)*dTextH / 2;
+														  x_show = x_ + cos(dAngle_)*WordIntervalPoint;
+														  y_show = y_ - sin(dAngle_)*WordIntervalPoint;
+														  dAngle = -dAngle_;
+
+													  }
+												  }
+
+												  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+												  if (m_pTextSymbol->DrawAText(pClsCS, x_show, y_show, sUTF8, dAngle))
+													  break;
+											  }
+											  break;
+	}
+	case SimpleLabelRenderer::dmapPointLabelPositionAngleField:
+	{
+											 /*
+											 获取 弧度
+											 */
+											 int iFieldCount = (int)(data->m_vFieldName.size());
+											 int iFieldIndex = -1;
+											 for (int i = 0; i < iFieldCount; i++)
+											 {
+												 if (m_sRotationAngleField == data->m_vFieldName[i])
+												 {
+													 iFieldIndex = i;
+													 break;
+												 }
+											 }
+											 if (iFieldIndex == -1)
+												 break;
+											 const char* sAngle = (data->m_vAllField[index][iFieldIndex]).c_str();
+											 double dAngle = stod(sAngle, NULL);
+											 dAngle = dAngle / 180 * M_PI;
+
+											
+
+											 dAngle = clsUtil::StandardizationAngle(dAngle);
+											 double x_show, y_show;
+											 cairo_text_extents_t extents;
+											 cairo_text_extents(pClsCS->m_pCr, sUTF8, &extents);
+											 double dTextW = extents.x_advance;
+											 double dTextH = extents.height;
+											 if (dAngle >= 0 && dAngle < M_PI / 2)
+											 {
+												 if (m_bIsVerticalToAngle)
+												 {
+													 dAngle = dAngle - M_PI / 2;
+													 double dAngle__ = -dAngle;
+													 double x_ = x - cos(dAngle__)*dTextW / 2;
+													 double y_ = y + sin(dAngle__)*dTextW / 2;
+													 x_show = x_ + sin(dAngle__)*(dTextH + WordIntervalPoint);
+													 y_show = y_ + cos(dAngle__)*(dTextH + WordIntervalPoint);
+												 }
+												 else
+												 {
+													 double x_ = x - sin(dAngle)*dTextH / 2;
+													 double y_ = y + cos(dAngle)*dTextH / 2;
+													 x_show = x_ + cos(dAngle)*WordIntervalPoint;
+													 y_show = y_ + sin(dAngle)*WordIntervalPoint;
+												 }
+											 }
+											 else if ((dAngle > M_PI / 2) && (dAngle < M_PI))
+											 {
+												 if (m_bIsVerticalToAngle)
+												 {
+													 dAngle -= M_PI / 2;
+													 double x_ = x - cos(dAngle)*dTextW / 2;
+													 double y_ = y - sin(dAngle)*dTextW / 2;
+													 x_show = x_ - sin(dAngle)*(dTextH + WordIntervalPoint);
+													 y_show = y_ + cos(dAngle)*(dTextH + WordIntervalPoint);
+												 }
+												 else
+												 {
+													 double dAngle_ = dAngle - M_PI / 2;
+													 double x_ = x - cos(dAngle_)*(dTextW + WordIntervalPoint);
+													 double y_ = y + sin(dAngle_)*(dTextW + WordIntervalPoint);
+													 x_show = x_ + sin(dAngle_)*dTextH / 2;
+													 y_show = y_ + cos(dAngle_)*dTextH / 2;
+													 dAngle = -dAngle_;
+												 }
+											 }
+											 else if ((dAngle >= M_PI) && (dAngle <= 3 * M_PI / 2))
+											 {
+												 if (m_bIsVerticalToAngle)
+												 {
+													 double dAngle_ = dAngle - M_PI;
+													 double x_ = x - sin(dAngle_)*dTextW / 2;
+													 double y_ = y + cos(dAngle_)*dTextW / 2;
+													 x_show = x_ - cos(dAngle_)*WordIntervalPoint;
+													 y_show = y_ - sin(dAngle_)*WordIntervalPoint;
+
+													 dAngle = dAngle_ - M_PI / 2;
+												 }
+												 else
+												 {
+													 dAngle -= M_PI;
+													 double x_ = x - sin(dAngle)*dTextH / 2;
+													 double y_ = y + cos(dAngle)*dTextH / 2;
+													 x_show = x_ - cos(dAngle)*(dTextW + WordIntervalPoint);
+													 y_show = y_ - sin(dAngle)*(dTextW + WordIntervalPoint);
+												 }
+											 }
+											 else
+											 {
+												 if (m_bIsVerticalToAngle)
+												 {
+													 dAngle -= 3 * M_PI / 2;
+													 double x_ = x - cos(dAngle)* dTextW / 2;
+													 double y_ = y - sin(dAngle)* dTextW / 2;
+													 x_show = x_ + sin(dAngle)*WordIntervalPoint;
+													 y_show = y_ - cos(dAngle)* WordIntervalPoint;
+												 }
+												 else
+												 {
+													 double dAngle_ = 2 * M_PI - dAngle;
+													 double x_ = x + sin(dAngle_)*dTextH / 2;
+													 double y_ = y + cos(dAngle_)*dTextH / 2;
+													 x_show = x_ + cos(dAngle_)*WordIntervalPoint;
+													 y_show = y_ - sin(dAngle_)*WordIntervalPoint;
+													 dAngle = -dAngle_;
+
+												 }
+											 }
+
+											 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+											 m_pTextSymbol->DrawAText(pClsCS, x_show, y_show, sUTF8, dAngle);
+											 break;
+	}
+	case SimpleLabelRenderer::dmapPointLabelPositionPeriphery:
+	{
+											cairo_text_extents_t extents;
+											cairo_text_extents(pClsCS->m_pCr, sUTF8, &extents);
+											double textW = extents.width, textH = extents.height;
+
+											for (int i = 0; i < 8; i++)
+											{
+												bool flag = false;
+												switch (m_i8[i])
+												{
+												case 1:{if (m_pTextSymbol->DrawAText(pClsCS, x - dotX - textW, y - dotY, sUTF8,-1,-1)) flag = true; break; }
+												case 2:{if (m_pTextSymbol->DrawAText(pClsCS, x - textW / 2, y - dotY, sUTF8,0,-1)) flag = true; break; }
+												case 3:{if (m_pTextSymbol->DrawAText(pClsCS, x + dotX, y - dotY, sUTF8,1,-1)) flag = true; break; }
+												case 4:{if (m_pTextSymbol->DrawAText(pClsCS, x + dotX, y + textH / 2, sUTF8,1,0)) flag = true; break; }
+												case 5:{if (m_pTextSymbol->DrawAText(pClsCS, x + dotX, y + dotY + textH, sUTF8,1,1)) flag = true; break; }
+												case 6:{if (m_pTextSymbol->DrawAText(pClsCS, x - textW / 2, y + dotY + textH, sUTF8,0,1)) flag = true; break; }
+												case 7:{if (m_pTextSymbol->DrawAText(pClsCS, x - dotX - textW, y + dotY + textH, sUTF8,-1,1)) flag = true; break; }
+												case 8:{if (m_pTextSymbol->DrawAText(pClsCS, x - dotX - textW, y + textH / 2, sUTF8,-1,0)) flag = true; break; }
+												default:break;
+												}
+												if (flag)
+													break;
+											}
+											break;
+	}
+	case SimpleLabelRenderer::dmapPointLabelPositionError:break;
+	default:break;
+	}
+
+	return true;
+}
+
+bool SimpleLabelRenderer::DrawMLine(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8)
+{
+	this->DoSetLineLabelPositionPlaces();
+	//m_iLineLabelPositionDirection = 2;
+	switch (m_iLineLabelPositionDirection)
+	{
+	case dmapLineLabelPositionLevel:
+		this->DrawMLineLevel(pClsCS, pStrMLine, sUTF8);
+		break;
+	case dmapLineLabelPositionParallel:
+		this->DrawMLineParallel(pClsCS, pStrMLine, sUTF8);
+		break;
+	case dmapLineLabelPositionCurved:
+		this->DrawMLineCurve5(pClsCS, pStrMLine, sUTF8);
+		break;
+	case dmapLineLabelPositionVertical:
+		this->DrawMLineVertical(pClsCS, pStrMLine, sUTF8);
+		break;
+	default:
+		break;
+	}
+	return true;
+}
+
+bool SimpleLabelRenderer::DrawMLineLevel(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8)
+{
+	double x = 0, y = 0;
+
+	clsStruct::GetGravity(x, y, pStrMLine);
+
+	/*switch (m_iLineLabelPositionStartOrEnd)
+	{
+	case dmapLineLabelPositionStart:
+		x = pStrMLine->p->p->x;
+		y = pStrMLine->p->p->y;
+		break;
+	case dmapLineLabelPositionEnd:
+		clsStruct::GetGravity(x, y, pStrMLine);
+		break;
+	case dmapLineLabelPositionCenter:
+		clsStruct::LINE* pLine = pStrMLine->p;
+		int nPoint = pLine->nPoint;
+		x = (pLine->p + nPoint - 1)->x;
+		y = (pLine->p + nPoint - 1)->y;
+		break;
+	default:
+		break;
+	}*/
+
+	cairo_text_extents_t extents;
+	cairo_text_extents(pClsCS->m_pCr, sUTF8, &extents);
+
+	
+
+	x = x - extents.width / 2;
+	y = y + extents.height / 2;
+	m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8);
+	return true;
+}
+bool SimpleLabelRenderer::DrawMLineParallel(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8)
+{
+	//先区分在起点还是终点或者是中心点
+	double x1, y1, x2, y2;
+
+
+	switch (m_iLineLabelPositionStartOrEnd)
+	{
+	case dmapLineLabelPositionStart:
+		clsStruct::GetStart(pStrMLine, x1, y1, x2, y2);
+		break;
+	case dmapLineLabelPositionEnd:
+		clsStruct::GetEnd(pStrMLine, x1, y1, x2, y2);
+		break;
+	case dmapLineLabelPositionCenter:
+		clsStruct::GetCenter(pStrMLine, x1, y1, x2, y2);
+		break;
+	default:
+		x1 = x2 = y1 = y2 = 0;
+		break;
+	}
+
+
+
+	cairo_text_extents_t extents;
+	cairo_text_extents(pClsCS->m_pCr, sUTF8, &extents);
+	double dW = extents.x_advance;
+	double dH = extents.height;
+
+
+
+	double dAngle = atan((y2 - y1) / (x2 - x1));
+	if (x1 > x2)
+		dAngle += M_PI;
+	bool bHaveDraw = false;
+	
+
+	for (int i = 0; i < 3; i++)
+	{
+		int iLineLabelPositionPlace = m_LineLabelPositionPlaces[i];
+
+		switch (iLineLabelPositionPlace)
+		{
+		case dmapLineLabelPositionLeft:
+		{
+										  if (x1 <= x2 && y1 <= y2)
+										  {
+											  double x = x1 + sin(dAngle)*WordIntervalLine;
+											  double y = y1 - cos(dAngle)*WordIntervalLine;
+											  bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle);
+										  }
+										  else
+										  if (x1 >= x2 && y1 >= y2)
+										  {
+											  double dAngle__ = dAngle - M_PI;
+											  double x__ = x1 - sin(dAngle__)* (WordIntervalLine + dH);
+											  double y__ = y1 + cos(dAngle__)* (WordIntervalLine + dH);
+											  double x = x__ - cos(dAngle__)*dW;
+											  double y = y__ - sin(dAngle__)*dW;
+											  bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+										  }
+										  else
+										  if (x1 > x2 && y1 < y2)
+										  {
+											  double dAngle__ = dAngle - M_PI / 2;
+											  double x__ = x1 + cos(dAngle__)*(WordIntervalLine + dH);
+											  double y__ = y1 + sin(dAngle__)*(WordIntervalLine + dH);
+											  double x = x__ - sin(dAngle__)*dW;
+											  double y = y__ + cos(dAngle__)*dW;
+											  bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__ - M_PI / 2);
+										  }
+										  else
+										  if (x1 < x2&& y1> y2)
+										  {
+											  double dAngle__ = 2 * M_PI - dAngle;
+											  double x = x1 - sin(dAngle__)*WordIntervalLine;
+											  double y = y1 - cos(dAngle__)*WordIntervalLine;
+											  bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle__);
+										  }
+										  break;
+		}
+		case dmapLineLabelPositionRight:
+		{
+										   if (x1 <= x2 && y1 <= y2)
+										   {
+											   double x = x1 - sin(dAngle)*(WordIntervalLine + dH);
+											   double y = y1 + cos(dAngle)*(WordIntervalLine + dH);
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle);
+										   }
+										   else
+										   if (x1 >= x2 && y1 >= y2)
+										   {
+											   double dAngle__ = dAngle - M_PI;
+											   double x__ = x1 + sin(dAngle__)*WordIntervalLine;
+											   double y__ = y1 - cos(dAngle__)*WordIntervalLine;
+											   double x = x__ - cos(dAngle__)*dW;
+											   double y = y__ - sin(dAngle__)*dW;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+
+										   }
+										   else
+										   if (x1 > x2 && y1 < y2)
+										   {
+											   double dAngle__ = dAngle - M_PI / 2;
+											   double x__ = x1 - cos(dAngle__)*WordIntervalLine;
+											   double y__ = y1 - sin(dAngle__)*WordIntervalLine;
+											   double x = x__ - sin(dAngle__)*dW;
+											   double y = y__ + cos(dAngle__)*dW;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__ - M_PI / 2);
+
+
+
+
+
+										   }
+										   else
+										   if (x1 < x2&& y1> y2)
+										   {
+											   double dAngle__ = 2 * M_PI - dAngle;
+											   double x = x1 + sin(dAngle__)*(WordIntervalLine + dH);
+											   double y = y1 + cos(dAngle__)*(WordIntervalLine + dH);
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle__);
+
+
+
+
+
+											   /*{ cairo_t* cr = pClsCS->m_pCr;
+											   cairo_set_source_rgba(cr, 1, 0.2, 0.2, 1);
+											   cairo_arc(cr, x1, y1, 5, 0, 2 * M_PI);
+											   cairo_fill(cr);
+											   cairo_arc(cr, x2, y2, 10, 0, 2 * M_PI);
+											   cairo_fill(cr);
+											   }*/
+										   }
+										   break;
+		}
+		case dmapLineLabelPositionOnTop:
+		{
+										   if (x1 <= x2 && y1 <= y2)
+										   {
+											   double x = x1 - sin(dAngle)*dH / 2;
+											   double y = y1 + cos(dAngle)*dH / 2;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle);
+										   }
+										   else
+										   if (x1 >= x2 && y1 >= y2)
+										   {
+
+											   double dAngle__ = dAngle - M_PI;
+											   double x__ = x1 - sin(dAngle__)*dH / 2;
+											   double y__ = y1 + cos(dAngle__)*dH / 2;
+											   double x = x__ - cos(dAngle__)*dW;
+											   double y = y__ - sin(dAngle__)*dW;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+
+										   }
+										   else
+										   if (x1 > x2 && y1 < y2)
+										   {
+
+											   double dAngle__ = dAngle - M_PI / 2;
+											   double x__ = x1 + cos(dAngle__)*dH / 2;
+											   double y__ = y1 + sin(dAngle__)*dH / 2;
+											   double x = x__ - sin(dAngle__)*dW;
+											   double y = y__ + cos(dAngle__)*dW;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__ - M_PI / 2);
+
+										   }
+										   else
+										   if (x1 < x2&& y1> y2)
+										   {
+											   double dAngle__ = 2 * M_PI - dAngle;
+											   double x = x1 + sin(dAngle__)*dH / 2;
+											   double y = y1 + cos(dAngle__)*dH / 2;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle__);
+
+
+
+											   /*{ cairo_t* cr = pClsCS->m_pCr;
+											   cairo_set_source_rgba(cr, 1, 0.2, 0.2, 1);
+											   cairo_arc(cr, x1, y1, 5, 0, 2 * M_PI);
+											   cairo_fill(cr);
+											   cairo_arc(cr, x2, y2, 10, 0, 2 * M_PI);
+											   cairo_fill(cr);
+											   }*/
+										   }
+										   break;
+		}
+		case dmapLineLabelPositionAbove:
+		{
+										   if (x1 <= x2 && y1 <= y2)
+										   {
+											   double x = x1 + sin(dAngle)*WordIntervalLine;
+											   double y = y1 - cos(dAngle)*WordIntervalLine;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle);
+										   }
+										   else
+										   if (x1 >= x2 && y1 >= y2)
+										   {
+											   double dAngle__ = dAngle - M_PI;
+											   double x__ = x1 + sin(dAngle__)*WordIntervalLine;
+											   double y__ = y1 - cos(dAngle__)*WordIntervalLine;
+											   double x = x__ - cos(dAngle__)*dW;
+											   double y = y__ - sin(dAngle__)*dW;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+
+
+
+										   }
+										   else
+										   if (x1 > x2 && y1 < y2)
+										   {
+											   double dAngle__ = dAngle - M_PI / 2;
+											   double x__ = x1 - cos(dAngle__)*WordIntervalLine;
+											   double y__ = y1 - sin(dAngle__)*WordIntervalLine;
+											   double x = x__ - sin(dAngle__)*dW;
+											   double y = y__ + cos(dAngle__)*dW;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__ - M_PI / 2);
+										   }
+										   else
+										   if (x1 < x2&& y1> y2)
+										   {
+											   double dAngle__ = 2 * M_PI - dAngle;
+											   double x = x1 - sin(dAngle__)*WordIntervalLine;
+											   double y = y1 - cos(dAngle__)*WordIntervalLine;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle__);
+										   }
+										   break;
+		}
+		case dmapLineLabelPositionBelow:
+		{
+										   if (x1 <= x2 && y1 <= y2)
+										   {
+											   double x = x1 - sin(dAngle)*(WordIntervalLine + dH);
+											   double y = y1 + cos(dAngle)*(WordIntervalLine + dH);
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle);
+										   }
+										   else
+										   if (x1 >= x2 && y1 >= y2)
+										   {
+
+											   double dAngle__ = dAngle - M_PI;
+											   double x__ = x1 - sin(dAngle__)* (WordIntervalLine + dH);
+											   double y__ = y1 + cos(dAngle__)* (WordIntervalLine + dH);
+											   double x = x__ - cos(dAngle__)*dW;
+											   double y = y__ - sin(dAngle__)*dW;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+
+										   }
+										   else
+										   if (x1 > x2 && y1 < y2)
+										   {
+											   double dAngle__ = dAngle - M_PI / 2;
+											   double x__ = x1 + cos(dAngle__)*(WordIntervalLine + dH);
+											   double y__ = y1 + sin(dAngle__)*(WordIntervalLine + dH);
+											   double x = x__ - sin(dAngle__)*dW;
+											   double y = y__ + cos(dAngle__)*dW;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__ - M_PI / 2);
+										   }
+										   else
+										   if (x1 < x2&& y1> y2)
+										   {
+											   double dAngle__ = 2 * M_PI - dAngle;
+											   double x = x1 + sin(dAngle__)*(WordIntervalLine + dH);
+											   double y = y1 + cos(dAngle__)*(WordIntervalLine + dH);
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle__);
+										   }
+										   break;
+		}
+		default:
+			break;
+		}
+		if (bHaveDraw)
+			break;
+	}
+	return true;
+}
+
+bool SimpleLabelRenderer::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,
+	int layerType,char* pFlag)
+{
+	return true;
+}
+
+bool SimpleLabelRenderer::DrawMLineCurve(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8)
+{
+	//计算出文字总长
+	cairo_t* cr = pClsCS->m_pCr;
+	cairo_text_extents_t extents;
+	m_pTextSymbol->SetCairo(pClsCS);
+	cairo_text_extents(cr, sUTF8, &extents);
+	double x_advance_all = extents.x_advance;
+	double y_height = extents.height;
+
+	//计算出标签的放置位置
+	double x, y; int iIndex;
+	clsStruct::GetGravity(x, y,iIndex, pStrMLine);
+
+
+	//分割文字
+	//暂时不考虑中文,直接分割每个字符
+	int len = strlen(sUTF8);
+
+	//计算每个文字的弧度
+	double dAdvanceCollect = 0;
+	double dHalfAdvance = x_advance_all / 2;
+	double x_show, y_show;
+	int i = len / 2;
+	double x_show_next = x, y_show_next = y;
+	for (i--; i >=0; i--)
+	{
+		char s_[2] = { sUTF8[i], '\0' };
+		cairo_text_extents(cr, s_, &extents);
+		double x_advance = extents.x_advance;
+		x_show = x_show_next;
+		y_show = y_show_next;
+		double dRadia = CalculateRadianRight(pStrMLine->p, x_advance, i, x_show, y_show, x_show_next, y_show_next);
+		m_pTextSymbol->DrawAText(pClsCS, x_show, y_show, s_, dRadia);
+	}
+	
+	x_show_next = x, y_show_next = y;
+	for (i = len / 2; i < len; i++)
+	{
+		char s_[2] = { sUTF8[i], '\0' };
+		cairo_text_extents(cr, s_, &extents);
+		double x_advance = extents.x_advance;
+		x_show = x_show_next;
+		y_show = y_show_next;
+		double dRadia = CalculateRadianLeft(pStrMLine->p, x_advance, i, x_show, y_show, x_show_next, y_show_next);
+		m_pTextSymbol->DrawAText(pClsCS, x_show, y_show, s_, dRadia);
+	}
+
+	return true;
+}
+
+bool SimpleLabelRenderer::DrawMLineVertical(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8)
+{
+	double x1, y1, x2, y2;
+	cairo_t* cr = pClsCS->m_pCr;
+
+
+	switch (m_iLineLabelPositionStartOrEnd)
+	{
+	case dmapLineLabelPositionStart:
+		clsStruct::GetStart(pStrMLine, x1, y1, x2, y2);
+		break;
+	case dmapLineLabelPositionEnd:
+		clsStruct::GetEnd(pStrMLine, x1, y1, x2, y2);
+		break;
+	case dmapLineLabelPositionOnTop:
+		clsStruct::GetCenter(pStrMLine, x1, y1, x2, y2);
+		break;
+	default:
+		break;
+	}
+
+
+	double dAngle = atan((y2 - y1) / (x2 - x1));
+	if (x1 > x2)
+		dAngle +=  M_PI;
+	bool bHaveDraw = false;
+
+
+
+	cairo_text_extents_t extents;
+	cairo_text_extents(pClsCS->m_pCr, sUTF8, &extents);
+	double dW = extents.x_advance;
+	double dH = extents.height;
+
+
+
+	for (int i = 0; i < 3; i++)
+	{
+		int iLineLabelPositionPlace = m_LineLabelPositionPlaces[i];
+
+		switch (iLineLabelPositionPlace)
+		{
+		case dmapLineLabelPositionLeft:
+		{
+										  if ((y1 <= y2) && (x1 <= x2))  //第一象限
+										  {
+											  double dAngle__ = dAngle - M_PI / 2.0;
+											  double x = x1 + cos(dAngle)*dH;
+											  double y = y1 + sin(dAngle)*dH;
+											  bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+										  }
+										  else
+										  if (x1 >= x2 && y1 >= y2)  //第三象限
+										  {
+											  double dAngle__ = 3.0*M_PI / 2 - dAngle;
+											  double a = cos(dAngle__);
+											  a = sin(dAngle__);
+											  double x = x1 - cos(dAngle__)*dW;
+											  double y = y1 + sin(dAngle__)*dW;
+											  bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle__);
+										  }
+										  else
+										  if (x1 > x2 && y1 < y2)
+										  {
+											  double dAngle__ = dAngle - M_PI / 2;
+											  double x = x1 - sin(dAngle__)*dH;
+											  double y = y1 + cos(dAngle__)*dH;
+											  bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+										  }
+										  else
+										  if (x1 < x2 && y1 > y2)
+										  {
+											  double dAngle__ = dAngle - 3.0*M_PI / 2;
+											  double x = x1 - cos(dAngle__)*dW;
+											  double y = y1 - sin(dAngle__)*dW;
+											  bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+										  }
+										  break;
+		}
+		case dmapLineLabelPositionRight:
+		{
+										   if (x1 <= x2 && y1 <= y2)
+										   {
+											   double dAngle__ = M_PI / 2 - dAngle;
+											   double x__ = x1 - cos(dAngle__)*dW;
+											   double y__ = y1 + sin(dAngle__)*dW;
+											   double x = x__ + cos(dAngle)*dH;
+											   double y = y__ + sin(dAngle)*dH;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle__);
+										   }
+										   else
+										   if (x1 >= x2 && y1 >= y2)
+										   {
+											   double dAngle__ = 3.0*M_PI / 2 - dAngle;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x1, y1, sUTF8, -dAngle__);
+										   }
+										   else
+										   if (x1 > x2 && y1 < y2)
+										   {
+											   double dAngle__ = M_PI - dAngle;
+											   double x__ = x1 - sin(dAngle__)* dW;
+											   double y__ = y1 - cos(dAngle__)*dW;
+											   double x = x__ - cos(dAngle__)*dH;
+											   double y = y__ + sin(dAngle__)*dH;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, M_PI / 2 - dAngle__);
+										   }
+										   else
+										   if (x1 < x2 && y1 > y2)
+										   {
+											   double dAngle__ = dAngle - 3 * M_PI / 2;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x1, y1, sUTF8, dAngle__);
+										   }
+										   break;
+		}
+
+		case dmapLineLabelPositionOnTop:
+		{
+										   if (x1 <= x2 && y1 <= y2)
+										   {
+											   double x = x1 - sin(dAngle)*dW / 2;
+											   double y = y1 + cos(dAngle)*dW / 2;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle - M_PI / 2);
+										   }
+										   else
+										   if (x1 >= x2 && y1 >= y2)
+										   {
+											   double dAngle__ = dAngle - M_PI;
+											   double x = x1 - sin(dAngle__)*dW / 2;
+											   double y = y1 + cos(dAngle__)*dW / 2;
+
+											   {
+												   cairo_set_source_rgba(cr, 1, 0.2, 0.2, 1);
+												   cairo_arc(cr, x1, y1, 3, 0, 2 * M_PI);
+												   cairo_fill(cr);
+												   cairo_arc(cr, x2, y2, 3, 0, 2 * M_PI);
+												   cairo_fill(cr);
+											   }
+
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__ - M_PI / 2);
+										   }
+										   else
+										   if (x1 > x2 && y1 < y2)
+										   {
+											   double dAngle__ = dAngle - M_PI / 2;
+											   double x__ = x1 - cos(dAngle__)*dW / 2;
+											   double y__ = y1 - sin(dAngle__)*dW / 2;
+											   double x = x__ - sin(dAngle__)*dH;
+											   double y = y__ + cos(dAngle__)*dH;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+
+										   }
+										   else
+										   if (x1 < x2 && y1 > y2)
+										   {
+											   double dAngle__ = 2 * M_PI - dAngle;
+											   double x = x1 - sin(dAngle__)*dW / 2;
+											   double y = y1 - cos(dAngle__)*dW / 2;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, M_PI / 2 - dAngle__);
+										   }
+										   break;
+		}
+		case dmapLineLabelPositionAbove:
+		{
+										   if (x1 <= x2 && y1 <= y2)
+										   {
+											   double dAngle__ = dAngle - M_PI / 2.0;
+											   double x = x1 + cos(dAngle)*dH;
+											   double y = y1 + sin(dAngle)*dH;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+										   }
+										   else
+										   if (x1 >= x2 && y1 >= y2)
+										   {
+											   double dAngle__ = 3.0*M_PI / 2 - dAngle;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x1, y1, sUTF8, -dAngle__);
+										   }
+										   else
+										   if (x1 > x2 && y1 < y2)
+										   {
+											   double dAngle__ = M_PI - dAngle;
+											   double x__ = x1 - sin(dAngle__)* dW;
+											   double y__ = y1 - cos(dAngle__)*dW;
+											   double x = x__ - cos(dAngle__)*dH;
+											   double y = y__ + sin(dAngle__)*dH;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, M_PI / 2 - dAngle__);
+										   }
+										   else
+										   if (x1 < x2 && y1 > y2)
+										   {
+											   double dAngle__ = dAngle - 3.0*M_PI / 2;
+											   double x = x1 - cos(dAngle__)*dW;
+											   double y = y1 - sin(dAngle__)*dW;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+										   }
+										   break;
+		}
+		case dmapLineLabelPositionBelow:
+		{
+										   if (x1 <= x2 && y1 <= y2)
+										   {
+											   double dAngle__ = M_PI / 2 - dAngle;
+											   double x__ = x1 - cos(dAngle__)*dW;
+											   double y__ = y1 + sin(dAngle__)*dW;
+											   double x = x__ + cos(dAngle)*dH;
+											   double y = y__ + sin(dAngle)*dH;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle__);
+										   }
+										   else if (x1 >= x2 && y1 >= y2)
+										   {
+											   double dAngle__ = 3.0*M_PI / 2 - dAngle;
+											   double a = cos(dAngle__);
+											   a = sin(dAngle__);
+											   double x = x1 - cos(dAngle__)*dW;
+											   double y = y1 + sin(dAngle__)*dW;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle__);
+										   }
+										   else if (x1 > x2 && y1 < y2)
+										   {
+											   double dAngle__ = dAngle - M_PI / 2;
+											   double x = x1 - sin(dAngle__)*dH;
+											   double y = y1 + cos(dAngle__)*dH;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+										   }
+										   else if (x1 < x2 && y1 > y2)
+										   {
+											   double dAngle__ = dAngle - 3 * M_PI / 2;
+											   bHaveDraw = m_pTextSymbol->DrawAText(pClsCS, x1, y1, sUTF8, dAngle__);
+										   }
+										   break;
+		}
+		default:
+			break;
+		}
+
+		if (bHaveDraw)
+			break;
+
+
+	}
+	
+	return true;
+}
+
+double SimpleLabelRenderer::CalculateRadianRight(clsStruct::LINE* pStrLine, double dTextWidth, int iIndex, double x, double y, double&x_show, double&y_show)
+{
+	//尝试一次性写下该文本
+	double x1 = (pStrLine->p + iIndex)->x;
+	double y1 = (pStrLine->p + iIndex)->y;
+	double dLength = sqrt((x-x1)*(x-x1) + (y-y1)*(y-y1));
+	if (dLength > dTextWidth)
+	{
+		//计算弧度
+		//求导
+		double dDerivative = (y - y1) / (x - x1);
+		//求出x,y方向上的距离
+		double x_ = sqrt(dTextWidth / (dDerivative*dDerivative + 1));
+		if (x<x1)
+			x_ = -x_;
+		double y_ = dDerivative*x_;
+
+		x_show = x - x_;
+		y_show = y - y_;
+
+		double dRadia = atan(y_ / x_);
+		return dRadia;
+	}
+	else
+	{
+		//连接该点与上一个点,该连线是否可以写下这个文本,不够的话再往上找点
+		for (iIndex--; iIndex >= 0; iIndex--)
+		{
+			x1 = (pStrLine->p + iIndex)->x;
+			y1 = (pStrLine->p + iIndex)->y;
+			dLength = sqrt((x - x1)*(x - x1) + (y - y1)*(y - y1));
+			if (dLength > dTextWidth)
+				break;
+		}
+
+		double dDerivative = (y - y1) / (x - x1);
+		//求出x,y方向上的距离
+		double x_ = sqrt(dTextWidth / (dDerivative*dDerivative + 1));
+		if (x<x1)
+			x_ = -x_;
+		double y_ = dDerivative*x_;
+
+		
+		x_show = x - x_;
+		y_show = y - y_;
+		double dRadia = atan(y_ / x_);
+
+		return dRadia;
+	}
+}
+
+double SimpleLabelRenderer::CalculateRadianLeft(clsStruct::LINE* pStrLine, double dTextWidth, int iIndex, double x, double y, double&x_show, double& y_show)
+{
+	//尝试一次性写下该文本
+	double x1 = (pStrLine->p + iIndex+1)->x;
+	double y1 = (pStrLine->p + iIndex+1)->y;
+	double dLength = sqrt((x - x1)*(x - x1) + (y - y1)*(y - y1));
+	if (dLength > dTextWidth)
+	{
+		//计算弧度
+		//求导
+		double dDerivative = (y1 - y) / (x1 - x);
+		//求出x,y方向上的距离
+		double x_ = sqrt(dTextWidth / (dDerivative*dDerivative + 1));
+		if (x<x1)
+			x_ = -x_;
+		double y_ = dDerivative*x_;
+
+		x_show = x + x_;
+		y_show = y + y_;
+
+		double dRadia = atan(y_ / x_);
+		return dRadia;
+	}
+	else
+	{
+		//连接该点与下一个点,该连线是否可以写下这个文本,不够的话再往上找点
+		int nPoint = pStrLine->nPoint;
+		for (iIndex++; iIndex < nPoint; iIndex++)
+		{
+			x1 = (pStrLine->p + iIndex+1)->x;
+			y1 = (pStrLine->p + iIndex+1)->y;
+			dLength = sqrt((x - x1)*(x - x1) + (y - y1)*(y - y1));
+			if (dLength > dTextWidth)
+				break;
+		}
+
+		double dDerivative = (y - y1) / (x - x1);
+		//求出x,y方向上的距离
+		double x_ = sqrt(dTextWidth / (dDerivative*dDerivative + 1));
+
+		if (x<x1)
+			x_ = -x_;
+
+		double y_ = dDerivative*x_;
+
+		x_show = x + x_;
+		y_show = y + y_;
+
+		double dRadia = atan(y_ / x_);
+
+		return dRadia;
+	}
+	return true;
+}
+
+bool SimpleLabelRenderer::DrawMLineCurve2(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8)
+{
+
+	//文字距离
+	cairo_t* cr = pClsCS->m_pCr;
+	cairo_text_extents_t extents;
+	m_pTextSymbol->SetCairo(pClsCS);
+	cairo_text_extents(cr, sUTF8, &extents);
+	double x_advance_all = extents.x_advance;
+	int strLen = strlen(sUTF8);
+	double x_advance = x_advance_all / strLen;
+
+
+	//中心点
+	double x_gravity, y_gravity; int iIndex;
+	clsStruct::GetGravity(x_gravity, y_gravity, iIndex, pStrMLine);
+
+	//计算出每个文字的弧度和位置,书写
+	int iHalfLen = strLen / 2;
+
+	//x_show = x_gravity,y_show = y_gravity
+	int iThisPointIndex = iIndex;
+	double x_show, y_show;
+	double x_show_next = x_gravity, y_show_next = y_gravity;
+	for (int i = iHalfLen; i < strLen; i++)
+	{
+		x_show = x_show_next; y_show = y_show_next;
+		double dRadia = this->CalculateRadianRight2(pStrMLine->p, x_advance,iThisPointIndex,x_show,y_show,x_show_next,y_show_next);
+
+		char s_[2] = {sUTF8[i],'\0'};
+		m_pTextSymbol->DrawAText(pClsCS, x_show, y_show,s_,dRadia);
+	}
+
+
+
+	return true;
+}
+double SimpleLabelRenderer::CalculateRadianRight2(clsStruct::LINE* pStrLine, double dTextWidth, int& iIndex, double x_show, double y_show, double &x_show_next, double&y_show_next)
+{
+	/*
+	参数解释:
+	dTextWidth,当前单个文字的宽度
+	iIndex , 当前书写文本时在线条上的上一个点的索引
+	x_show , 当前书写文字的开始位置
+	y_show , 
+	x_show_next, 得出下一个文字开始书写的位置
+	y_show_next
+
+
+	通过计算,得出当前这个文字的旋转弧度,得出下一个文字的其实位置,得出下一个文字落在第几个点到下一个点之间
+	*/
+
+
+	//尝试一次性写下该文字
+	double x1 = x_show;
+	double y1 = y_show;
+	double x2 = (pStrLine->p + iIndex + 1)->x;
+	double y2 = (pStrLine->p + iIndex + 1)->y;
+	double dLength = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1- y2));
+
+	if (dLength > dTextWidth)
+	{
+		//一次性可以写下
+		
+		//求导
+		double dDerivative = (y2 - y1) / (x2-x1);
+		double dRadia = atan(dDerivative);                                                                     //计算出弧度
+		this->CalculateIntersection(dTextWidth, x_show, y_show, x1, y1, x2, y2, x_show_next, y_show_next);     //计算出下一个文字的位置
+		
+		return dRadia;
+	}
+	else
+	{
+		//计算出另一端在哪两个点之间
+		int iPointCount = pStrLine->nPoint;
+		for (iIndex++; iIndex < iPointCount - 1; iIndex++)
+		{
+			x2 = (pStrLine->p + iIndex + 1)->x;
+			y2 = (pStrLine->p + iIndex + 1)->y;
+			double dLength = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+			if (dLength > dTextWidth)
+				break;
+		}
+
+		this->CalculateIntersection(dTextWidth, x_show, y_show, (pStrLine->p + iIndex)->x, (pStrLine->p + iIndex)->y, (pStrLine->p + iIndex + 1)->x, (pStrLine->p + iIndex + 1)->y,x_show_next,y_show_next);
+		double dRadia = (y_show_next - y_show) / (x_show_next-x_show);
+		return dRadia;
+	}
+
+	return 0;
+}
+double SimpleLabelRenderer::CalculateRadianLeft2(clsStruct::LINE* pStrLine, double dTextWidth, int &iIndex, double x_show, double y_show, double&x_show_next, double&y_show_next)
+{
+	return 0;
+}
+void SimpleLabelRenderer::CalculateIntersection(double dWidth, double x_from, double y_from, double x1, double y1, double x2, double y2, double&x_to, double&y_to)
+{
+	//计算交点
+	//从(x_from,y_from)为圆心,以dWidth为半径,与(x1,y1),(x2,y2)所连成的直线相交,得到交点(x_to,y_to)
+
+	//x1,y1,x2,y2计算直线式 y = k*x + b;
+	double k_, b_, a, b, c;
+	k_ = (y2 - y1) / (x2 - x1);
+	b_ = y1 - k_*x1;
+
+	//由于距离已确定
+	// (x_to - x_from) * (x_to - x_from ) + (y_to - y_from) * (y_to - y_from) = dWidth*dWidth
+	//加上 y = k*x + b
+	//组成2元方程式,可解
+	a = k_*k_ + 1;
+	b = 2 * k_*b_ - 2 * k_*y_from - 2 * x_from;
+	c = b_*b_ - 2 * b_*y_from + y_from*y_from + x_from*x_from - dWidth*dWidth;
+	double dDelta = b*b - 4 * a*c;   // 无需考虑,前面计算落在哪两个点之间时已经可以确定此时必然有交点
+	double dResult_x1 = (-b + sqrt(dDelta)) / (2 * a);
+	double dResult_x2 = (-b - sqrt(dDelta)) / (2 * a);
+	if (((dResult_x1 > x1) && (dResult_x1 < x2)) || ((dResult_x1 < x1) && (dResult_x1 >  x2)))
+		x_to = dResult_x1;
+	else
+		x_to = dResult_x2;
+	y_to = k_*x_to + b_;
+
+}
+
+
+
+
+
+
+
+
+bool SimpleLabelRenderer::DrawMLineCurve3(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8)
+{
+//	printf("11\r\n");
+	//平滑处理成一条新的线
+	vector<double> vX, vY;
+	this->LineToSmooth(pStrMLine->p, vX, vY);
+	//这个算法太耗资源了,时间也长
+	printf("vx size = %ld\r\n", vX.size());
+
+	//挑选最平滑的一段书写
+	//这个步骤好像不对,不需要这样做
+
+	cairo_t* cr = pClsCS->m_pCr;
+	//计算每个文字的弧度和位置并书写
+	{
+		
+		//将虚拟线条绘制出来
+		
+		/*cairo_set_line_width(cr, 1);
+		cairo_set_source_rgba(cr, 1, 0, 0, 0.3);
+		int sz = (int)(vX.size());
+		cairo_move_to(cr, vX[0], vY[0]);
+		for (int i = 1; i < sz; i++)
+			cairo_line_to(cr,vX[i], vY[i]);
+		cairo_stroke(cr);*/
+	}
+	//printf("22\r\n");
+	cairo_text_extents_t extents;
+	cairo_text_extents(cr, sUTF8, &extents);
+
+	double x_advance_all = extents.x_advance;
+
+	if (extents.x_advance == 0)
+	{
+		//printf("*****return\r\n");
+		return false;
+	}
+
+	//计算开始书写第一个文字的位置
+	double x_show_begin, y_show_begin;
+	int iPointIndex;
+	bool flag = this->CalculateShowBegin(vX, vY, x_advance_all, x_show_begin, y_show_begin, iPointIndex);
+
+	if (!flag)
+		return false;
+
+	int len = strlen(sUTF8);
+	double x_advance = x_advance_all / len;
+
+	int iIndex = iPointIndex;
+	double x_show, y_show;
+	double x_show_next = x_show_begin, y_show_next = y_show_begin;
+	double dRadia_this, dRadia_last;
+	for (int i = 0; i < len; i++)
+	{
+		x_show = x_show_next; y_show = y_show_next;
+
+		dRadia_this = this->CalculateRadianRight3(vX, vY, x_advance, iIndex, x_show, y_show, x_show_next, y_show_next);
+
+		{
+			//atan计算出的弧度只在 (-π/2,π/2)
+
+			//如果文字向下走,旋转弧度在 [0,π)之间
+			//如果文字向上走,旋转弧度在 [π,2π)之间
+			if ((y_show_next >  y_show) && (dRadia_this < 0))
+				dRadia_this = dRadia_this + M_PI;
+			if ((y_show_next < y_show) && (dRadia_this> 0))
+				dRadia_this = dRadia_this + M_PI;
+			
+		}
+		
+
+
+		if (!i)
+			dRadia_last = dRadia_this;
+		double dRadiaDisMax = M_PI / 6;  // 旋转弧度落差范围,上一个文字旋转弧度与下一个文字旋转弧度不得超过30度
+		if ((dRadia_this - dRadia_last) >dRadiaDisMax)
+			dRadia_this = dRadia_last + dRadiaDisMax;
+		if (dRadia_this - dRadia_last < -dRadiaDisMax)
+			dRadia_this = dRadia_last - dRadiaDisMax;
+		char s_[2] = { sUTF8[i], '\0' };
+		m_pTextSymbol->DrawAText(pClsCS, x_show, y_show, s_, dRadia_this);
+		dRadia_last = dRadia_this;
+	}
+	//("33\r\n");
+	return true;
+}
+
+
+bool SimpleLabelRenderer::LineToSmooth(clsStruct::LINE* pStrLine, vector<double>& vX, vector<double>& vY)
+{
+	int iPointCount = pStrLine->nPoint;
+	clsStruct::POINT* pp = pStrLine->p;
+	for (int i = 0; i < iPointCount; i++,pp++)
+	{
+		vX.push_back(pp->x);
+		vY.push_back(pp->y);
+	}
+
+	this->Douglas_Peucker_algorithm(vX, vY);
+	
+	int sz = (int)(vX.size());
+	double x1 = vX[0];
+	double x2 = vX[sz - 1];
+	if (x1 > x2)
+	{
+		//反转
+		vX.reserve(vX.size());
+		vY.reserve(vY.size());
+		//vX.reverse(vX.begin(), vX.end());
+		//reverse(vY.begin(), vY.end());
+	}
+
+	return true;
+}
+
+
+bool SimpleLabelRenderer::Douglas_Peucker_algorithm(vector<double> &vX, vector<double>& vY)
+{
+	double dTolerance = 5; // 限差
+
+	double x1 = vX[0], y1 = vY[0];
+	int sz = (int)(vX.size());
+	double x2 = vX[sz - 1], y2 = vY[sz - 1];
+
+	double x0, y0;
+	double dDistanceMax = 0;
+	int iMaxIndex = 0;
+	for (int i = 1; i < sz - 1; i++)
+	{
+		x0 = vX[i]; y0 = vY[i];
+		double dDistance = this->CalculateDistance(x0, y0, x1, y1, x2, y2);
+		if (dDistance > dDistanceMax)
+		{
+			dDistanceMax = dDistance;
+			iMaxIndex = i;
+		}
+	}
+
+	if (dDistanceMax < dTolerance)
+	{
+		vX.clear(); vY.clear();
+		vX.push_back(x1); vX.push_back(x2);
+		vY.push_back(y1); vY.push_back(y2);
+		return false;
+	}
+	else
+	{
+		vector<double> vX_left, vY_left, vX_right, vY_right;
+		copy(vX.begin(), vX.begin() + iMaxIndex, back_inserter(vX_left));
+		copy(vY.begin(), vY.begin() + iMaxIndex, back_inserter(vY_left));
+		copy(vX.begin() + iMaxIndex, vX.end(), back_inserter(vX_right));
+		copy(vY.begin() + iMaxIndex, vY.end(), back_inserter(vY_right));
+
+		this->Douglas_Peucker_algorithm(vX_left, vY_left);
+		this->Douglas_Peucker_algorithm(vX_right, vY_right);
+
+		vX.clear(); vY.clear();
+		copy(vX_left.begin(), vX_left.end(), back_inserter(vX));
+		copy(vY_left.begin(), vY_left.end(), back_inserter(vY));
+		copy(vX_right.begin()+1, vX_right.end(), back_inserter(vX));
+		copy(vY_right.begin()+1, vY_right.end(), back_inserter(vY));
+
+		return true;
+	}
+}
+
+
+double SimpleLabelRenderer::CalculateDistance(double x0, double y0, double x1, double y1, double x2, double y2)
+{
+	//(x1,y1)和(x2,y2) 组成直线,计算(x0,y0)到该直线的距离
+
+	//(x1,y1)和(x2,y2)组成直线 y = k1 * x + b1;
+
+	double k1, b1, k2, b2;
+	k1 = (y2 - y1) / (x2 - x1);
+	b1 = y1 - x1*k1;
+
+	k2 = 1 / k1;
+	b2 = y0 - k2*x0;
+
+	/*
+	y = k1 * x + b1  与  y = k2 * x + b2 相交, 得到交点
+	*/
+	double x = (b2 - b1) / (k1 - k2);
+	double y = k1 * x + b1;
+
+	double dDistance = sqrt((x - x0)*(x-x0) + (y-y0)*(y-y0));
+	//此处应该可以取巧,不用求根,直接将距离的平方作为返回值也可以
+
+	return dDistance;
+}
+
+bool SimpleLabelRenderer::CalculateShowBegin(vector<double> vX, vector<double> vY, double dW , double& x_show_begin, double& y_show_begin,int & iPointIndex)
+{
+	int sz = (int)(vX.size());
+
+	double x1, y1, x2, y2;
+
+	x2 = vX[0]; y2 = vY[0];
+
+	double dLength = 0, dL;
+	for (int i = 1; i < sz; i++)
+	{
+		x1 = x2; y1 = y2;
+		x2 = vX[i]; y2 = vY[i];
+		dL = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
+		dLength += dL;
+	}
+
+	if (dLength < dW)
+		return false;
+	double dLengthBegin = (dLength - dW) / 2;
+
+	x2 = vX[0]; y2 = vY[0];
+	double dLCollect = 0;
+	int i = 1;
+	for (; i < sz; i++)
+	{
+		x1 = x2; y1 = y2;
+		x2 = vX[i]; y2 = vY[i];
+		dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+		dLCollect += dL;
+		if (dLCollect >=  dLengthBegin)
+			break;
+	}
+
+	double dDis = dLCollect - dLengthBegin;
+	x_show_begin = x2 - (x2 - x1)*dDis / dL;
+	y_show_begin = y2 - (y2 - y1)*dDis / dL;
+
+	iPointIndex = i - 1;
+	return true;
+
+}
+
+double SimpleLabelRenderer::CalculateRadianRight3(vector<double> vX, vector<double> vY, double dTextWidth, int& iIndex, double x_show, double y_show, double &x_show_next, double&y_show_next)
+{
+	/*
+	参数解释:
+	dTextWidth,当前单个文字的宽度
+	iIndex , 当前书写文本时在线条上的上一个点的索引
+	x_show , 当前书写文字的开始位置
+	y_show ,
+	x_show_next, 得出下一个文字开始书写的位置
+	y_show_next
+
+
+	通过计算,得出当前这个文字的旋转弧度,得出下一个文字的其实位置,得出下一个文字落在第几个点到下一个点之间
+	*/
+	//尝试一次性写下该文字
+	double x1 = x_show;
+	double y1 = y_show;
+	double x2 = vX[iIndex + 1];
+	double y2 = vY[iIndex + 1];
+	double dLength = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+
+	if (dLength > dTextWidth)
+	{
+		//一次性可以写下
+
+		//求导
+		double dDerivative = (y2 - y1) / (x2 - x1);
+		double dRadia = atan(dDerivative);                                                                     //计算出弧度
+		this->CalculateIntersection(dTextWidth, x_show, y_show, x1, y1, x2, y2, x_show_next, y_show_next);     //计算出下一个文字的位置
+
+		return dRadia;
+	}
+	else
+	{
+		//计算出另一端在哪两个点之间
+		int iPointCount = (int)(vX.size());
+		for (iIndex++; iIndex < iPointCount - 1; iIndex++)
+		{
+			x2 = vX[iIndex + 1];
+			y2 = vY[iIndex + 1];
+			double dLength = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+			if (dLength > dTextWidth)
+				break;
+		}
+
+		this->CalculateIntersection(dTextWidth, x_show, y_show, vX[iIndex], vY[iIndex], vX[iIndex+1], vY[iIndex+1], x_show_next, y_show_next);
+		double dRadia = atan ((y_show_next - y_show) / (x_show_next - x_show));
+
+		return dRadia;
+	}
+}
+
+bool SimpleLabelRenderer::DrawMLineCurve4(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8)
+{
+	cairo_t* cr = pClsCS->m_pCr;
+	cairo_text_extents_t extents;
+	cairo_text_extents(cr, sUTF8, &extents);
+	double x_advance_all = extents.x_advance;
+
+	clsStruct::LINE* pLine = pStrMLine->p;
+
+
+	//计算开始书写第一个文字的位置
+	double x_show_begin, y_show_begin;        int iPointIndex;
+	bool flag = this->CalculateShowBegin(pLine, x_advance_all, x_show_begin, y_show_begin, iPointIndex);
+
+	if (!flag)
+		return false;
+
+	string words[500];
+	for (int i = 0; i < 50; i++)
+		words[i] = "";
+
+	//拆分字符串成文字数组
+	int iWordsCount = this->SplitUTF8(sUTF8, words, 50);
+
+	double x_show_this, y_show_this, x_show_next, y_show_next;
+
+	x_show_this = x_show_begin; y_show_this = y_show_begin;
+
+	//cairo_text_extents_t exents;
+	//{
+	//	//检查整个字符串的文字避让
+	//}
+
+	double dRadia_this, dRadia_last;
+	for (int i = 0; i < iWordsCount; i++)
+	{
+		char ss[5]; const char* ss__ = words[i].c_str(); strcpy(ss, ss__);
+		cairo_text_extents(cr, ss, &extents);
+		double dWordWidth = extents.x_advance;
+		int iIndex = iPointIndex;
+		dRadia_this = this->CalculateRadianRight4(pLine, dWordWidth, iIndex, x_show_this, y_show_this, x_show_next, y_show_next);
+
+		if (!i)
+			dRadia_last = dRadia_this;
+		double dRadiaDisMax = M_PI / 12;  // 旋转弧度落差范围,上一个文字旋转弧度与下一个文字旋转弧度不得超过30度
+		if ((dRadia_this - dRadia_last) >dRadiaDisMax)
+			dRadia_this = dRadia_last + dRadiaDisMax;
+		if (dRadia_this - dRadia_last < -dRadiaDisMax)
+			dRadia_this = dRadia_last - dRadiaDisMax;
+
+
+		bool bb = m_pTextSymbol->DrawAText(pClsCS, x_show_this, y_show_this, ss, dRadia_this);
+		bb = bb;
+		dRadia_last = dRadia_this;
+
+		
+		x_show_this = x_show_next; y_show_this = y_show_next;
+	}
+
+
+
+	return true;
+	
+	
+}
+
+
+
+bool SimpleLabelRenderer::DrawMLineCurve5(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8)
+{
+	cairo_t* cr = pClsCS->m_pCr;
+	cairo_text_extents_t extents;
+	cairo_text_extents(cr, sUTF8, &extents);
+	double x_advance_all = extents.x_advance;
+
+	clsStruct::LINE* pLine = pStrMLine->p;
+
+
+	//计算开始书写第一个文字的位置
+	double x_show_begin, y_show_begin;        int iPointIndex;
+
+	double dRadia = 0;
+	bool flag = this->CalculateShowBegin5(pLine, x_advance_all, x_show_begin, y_show_begin, iPointIndex, dRadia, pClsCS->m_iW, pClsCS->m_iH);
+
+	if (!flag)
+		return false;
+	if (pLine->nPoint<iPointIndex + 2)	return false;
+
+	double x_show_this, y_show_this, x_show_next, y_show_next;
+
+	x_show_this = x_show_begin; y_show_this = y_show_begin;
+
+	if (pLine->p[iPointIndex + 1].x > x_show_begin)
+	{
+		x_show_next = pLine->p[iPointIndex + 2].x;
+		y_show_next = pLine->p[iPointIndex + 2].y;
+	}
+	else
+	{
+
+		x_show_next = x_show_begin;
+		y_show_next = y_show_begin;
+
+		x_show_begin = pLine->p[iPointIndex + 2].x;
+		y_show_begin = pLine->p[iPointIndex + 2].y;
+	}
+
+	dRadia = atan2((y_show_next - y_show_begin),(x_show_next - x_show_begin));
+
+	m_pTextSymbol->DrawAText(pClsCS, x_show_begin, y_show_begin, sUTF8, dRadia);
+
+
+	return true;
+}
+
+
+/*
+
+bool SimpleLabelRenderer::DrawMLineCurve5(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8)
+{
+	cairo_t* cr = pClsCS->m_pCr;
+	cairo_text_extents_t extents;
+	cairo_text_extents(cr, sUTF8, &extents);
+	double x_advance_all = extents.x_advance;
+
+	clsStruct::LINE* pLine = pStrMLine->p;
+
+
+	//计算开始书写第一个文字的位置
+	double x_show_begin, y_show_begin;        int iPointIndex;
+
+	double dRadia = 0;
+	bool flag = this->CalculateShowBegin5(pLine, x_advance_all, x_show_begin, y_show_begin, iPointIndex, dRadia, pClsCS->m_iW, pClsCS->m_iH);
+
+	if (!flag)
+		return false;
+
+	string words[500];
+	for (int i = 0; i < 50; i++)
+		words[i] = "";
+
+	//拆分字符串成文字数组
+	int iWordsCount = this->SplitUTF8(sUTF8, words, 50);
+
+	double x_show_this, y_show_this, x_show_next, y_show_next;
+
+	x_show_this = x_show_begin; y_show_this = y_show_begin;
+
+	bool bb = m_pTextSymbol->DrawAText(pClsCS, x_show_this, y_show_this, sUTF8, dRadia);
+	//m_pTextSymbol->DrawAText(pClsCS, x_show_begin, y_show_begin, sUTF8);
+	return true;
+	//cairo_text_extents_t exents;
+	//{
+	//	//检查整个字符串的文字避让
+	//}
+
+	double dRadia_this, dRadia_last;
+	for (int i = 0; i < iWordsCount; i++)
+	{
+		char ss[5]; const char* ss__ = words[i].c_str(); strcpy(ss, ss__);
+		cairo_text_extents(cr, ss, &extents);
+		double dWordWidth = extents.x_advance;
+		int iIndex = iPointIndex;
+		dRadia_this = this->CalculateRadianRight4(pLine, dWordWidth, iIndex, x_show_this, y_show_this, x_show_next, y_show_next);
+
+		if (!i)
+			dRadia_last = dRadia_this;
+		double dRadiaDisMax = M_PI / 12;  // 旋转弧度落差范围,上一个文字旋转弧度与下一个文字旋转弧度不得超过30度
+		if ((dRadia_this - dRadia_last) >dRadiaDisMax)
+			dRadia_this = dRadia_last + dRadiaDisMax;
+		if (dRadia_this - dRadia_last < -dRadiaDisMax)
+			dRadia_this = dRadia_last - dRadiaDisMax;
+
+		if (dRadia_this == dRadia_this)
+		{
+			bool bb = m_pTextSymbol->DrawAText(pClsCS, x_show_this, y_show_this, sUTF8, dRadia_this);
+			bb = bb;
+			dRadia_last = dRadia_this;
+			x_show_this = x_show_next; y_show_this = y_show_next;
+			break;
+		}
+		else
+		{
+			printf("%f \r\n", dRadia_this);
+			return false;
+		}
+		
+	}
+
+	return true;
+}
+
+*/
+
+bool SimpleLabelRenderer::CalculateShowBegin(clsStruct::LINE* pLine, double dW, double& x_show_begin, double& y_show_begin, int & iPointIndex)
+{
+	switch (m_iLineLabelPositionStartOrEnd)
+	{
+	case dmapLineLabelPositionStart:
+	{
+
+									   clsStruct::POINT* pPoint = pLine->p;
+									   int nPoint = pLine->nPoint;
+
+									   double dLength = 0;
+
+									   double x1, x2, y1, y2;
+
+									   clsStruct::POINT* pp = pPoint;
+									   x2 = pp->x;
+									   y2 = pp->y;
+
+
+									   if (nPoint > 5)
+									   {
+										   int index = nPoint / 2;
+										   pp += index;
+										   x1 = x2; y1 = y2;
+										   x2 = pp->x;
+										   y2 = pp->y;
+										   double dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+										   dLength += dL;
+									   }
+
+									   if (nPoint > 1)
+									   {
+										   int index = nPoint - 1;
+										   pp += index;
+										   x1 = x2; y1 = y2;
+										   x2 = pp->x;
+										   y2 = pp->y;
+										   double dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+										   dLength += dL;
+									   }
+
+									   if (dLength > dW*1.5)
+									   {
+										   clsStruct::POINT* pp = pPoint;
+										   x2 = pp->x;
+										   y2 = pp->y;
+									   }
+									   else
+									   {
+										   return false;
+									   }
+									   return dLength;
+
+									   break;
+	}
+	case dmapLineLabelPositionEnd:
+	{
+									 clsStruct::POINT* p = pLine->p;
+									 int nPoint = pLine->nPoint;
+
+
+									 double x1, y1, x2, y2;
+
+									 int i = nPoint - 2;
+									 double dDistance = 0;
+
+
+									 double dD;
+									 while ((dDistance < dW) && (i >= 0))
+									 {
+										 i--;
+										 x1 = (p + i)->x;
+										 y1 = (p + i)->y;
+										 x2 = (p + i + 1)->x;
+										 y2 = (p + i + 1)->y;
+										 dD = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+
+										 dDistance += dD;
+									 }
+									 if (i < 0)
+										 return false;
+									 iPointIndex = i;
+
+									 double dSurplus = dDistance - dW;
+
+									 double x_begin1 = (p + iPointIndex)->x;
+									 double y_begin1 = (p + iPointIndex)->y;
+									 double x_begin2 = (p + iPointIndex + 1)->x;
+									 double y_begin2 = (p + iPointIndex + 1)->y;
+
+									 x_show_begin = dSurplus / dD *(x2 - x1) + x1;
+									 y_show_begin = dSurplus / dD *(y2 - y1) + y1;
+
+
+
+									 break;
+	}
+	case dmapLineLabelPositionCenter:
+	{
+										clsStruct::POINT* p = pLine->p;
+										int nPoint = pLine->nPoint;
+
+										int iIndex;
+										double x_gravity, y_gravity;
+										clsStruct::GetGravity(x_gravity, y_gravity, iIndex, pLine);
+
+										int i = iIndex + 1;
+										double dDistance = 0;
+
+										double x1, y1, x2, y2, dD;
+										while ((dDistance < dW) && (i >= 0))
+										{
+											i--;
+											x1 = (p + i)->x;
+											y1 = (p + i)->y;
+											x2 = (p + i + 1)->x;
+											y2 = (p + i + 1)->y;
+											dD = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+
+											dDistance += dD;
+										}
+
+										if (i < 0 || dDistance == 0)
+											return false;
+										iPointIndex = i;
+
+										double dSurplus = dDistance - dW;
+
+										double x_begin1 = (p + iPointIndex)->x;
+										double y_begin1 = (p + iPointIndex)->y;
+										double x_begin2 = (p + iPointIndex + 1)->x;
+										double y_begin2 = (p + iPointIndex + 1)->y;
+
+										x_show_begin = dSurplus / dD *(x2 - x1) + x1;
+										y_show_begin = dSurplus / dD *(y2 - y1) + y1;
+
+										break;
+	}
+	default:
+		break;
+	}
+
+	return true;
+}
+//
+//bool SimpleLabelRenderer::CalculateShowBegin(clsStruct::LINE* pLine, double dW, double& x_show_begin, double& y_show_begin, int & iPointIndex)
+//{
+//	switch (m_iLineLabelPositionStartOrEnd)
+//	{
+//	case dmapLineLabelPositionStart:
+//	{
+//
+//									   clsStruct::POINT* pPoint = pLine->p;
+//									   int nPoint = pLine->nPoint;
+//
+//									   double dLength = 0;
+//
+//									   double x1, x2, y1, y2;
+//
+//									   clsStruct::POINT* pp = pPoint;
+//									   x2 = pp->x;
+//									   y2 = pp->y;
+//									  
+//
+//									   if (nPoint > 5)
+//									   {
+//										   int index = nPoint / 2;
+//										   pp += index;
+//										   x1 = x2; y1 = y2;
+//										   x2 = pp->x;
+//										   y2 = pp->y;
+//										   double dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+//										   dLength += dL;
+//									   }
+//
+//									   if (nPoint > 1)
+//									   {
+//										   int index = nPoint -1;
+//										   pp += index;
+//										   x1 = x2; y1 = y2;
+//										   x2 = pp->x;
+//										   y2 = pp->y;
+//										   double dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+//										   dLength += dL;
+//									   }
+//
+//									   if (dLength > dW*1.2)
+//									   {
+//
+//									   }
+//
+//									   return dLength;
+//
+//
+//									   //double dLength = clsStruct::GetLength(pLine);
+//									   //if (dW > dLength)
+//										  // return false;
+//									   //clsStruct::POINT* p = pLine->p;
+//									   //x_show_begin = p->x;
+//									   //y_show_begin = p->y;
+//									   //iPointIndex = 0;
+//
+//
+//									   break;
+//	}
+//	case dmapLineLabelPositionEnd:
+//	{
+//									 clsStruct::POINT* p = pLine->p;
+//									 int nPoint = pLine->nPoint;
+//
+//									 
+//									 double x1, y1, x2, y2;
+//									 
+//									 int i = nPoint -2;
+//									 double dDistance = 0;
+//
+//									
+//									 double dD;
+//									 while ((dDistance < dW) && (i >= 0))
+//									 {
+//										 i--;
+//										 x1 = (p + i)->x;
+//										 y1 = (p + i)->y;
+//										 x2 = (p + i + 1)->x;
+//										 y2 = (p + i + 1)->y;
+//										 dD = sqrt((x1 - x2 )*(x1-x2) + (y1 - y2)*(y1 - y2));
+//
+//										 dDistance += dD ;
+//									 }
+//									 if (i < 0)
+//										 return false;
+//									 iPointIndex = i;
+//
+//									 double dSurplus = dDistance - dW;
+//									 
+//									 double x_begin1 = (p + iPointIndex)->x;
+//									 double y_begin1 = (p + iPointIndex)->y;
+//									 double x_begin2 = (p + iPointIndex + 1)->x;
+//									 double y_begin2 = (p + iPointIndex + 1)->y;
+//
+//									 x_show_begin = dSurplus / dD *(x2 - x1) + x1;
+//									 y_show_begin = dSurplus / dD *(y2 - y1) + y1;
+//									 
+//
+//
+//									 break;
+//	}
+//	case dmapLineLabelPositionCenter:
+//	{
+//										clsStruct::POINT* p = pLine->p;
+//										int nPoint = pLine->nPoint;
+//
+//										int iIndex;
+//										double x_gravity, y_gravity;
+//										clsStruct::GetGravity(x_gravity, y_gravity, iIndex, pLine);
+//
+//										int i = iIndex + 1;
+//										double dDistance = 0;
+//
+//										double x1, y1, x2, y2,dD;
+//										while ((dDistance < dW) && (i >= 0))
+//										{
+//											i--;
+//											x1 = (p + i)->x;
+//											y1 = (p + i)->y;
+//											x2 = (p + i + 1)->x;
+//											y2 = (p + i + 1)->y;
+//											dD = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+//
+//											dDistance += dD;
+//										}
+//
+//										if (i < 0 || dDistance==0)
+//											return false;
+//										iPointIndex = i;
+//
+//										double dSurplus = dDistance - dW;
+//
+//										double x_begin1 = (p + iPointIndex)->x;
+//										double y_begin1 = (p + iPointIndex)->y;
+//										double x_begin2 = (p + iPointIndex + 1)->x;
+//										double y_begin2 = (p + iPointIndex + 1)->y;
+//
+//										x_show_begin = dSurplus / dD *(x2 - x1) + x1;
+//										y_show_begin = dSurplus / dD *(y2 - y1) + y1;
+//
+//										break;
+//	}
+//	default:
+//		break;
+//	}
+//
+//	return true;
+//}
+//
+
+
+bool SimpleLabelRenderer::CalculateShowBegin5(clsStruct::LINE* pLine, double dW, double& x_show_begin, double& y_show_begin, int & iPointIndex,double& dRadia, int width, int height)
+{
+	switch (m_iLineLabelPositionStartOrEnd)
+	{
+	case dmapLineLabelPositionStart:
+	{
+									   double dLength = clsStruct::GetLength5(pLine, iPointIndex, x_show_begin, y_show_begin, dRadia, width, height, dW);
+									   if (dW > dLength)
+										   return false;
+									   break;
+	}
+	case dmapLineLabelPositionEnd:
+	{
+									 clsStruct::POINT* p = pLine->p;
+									 int nPoint = pLine->nPoint;
+
+
+									 double x1, y1, x2, y2;
+
+									 int i = nPoint - 2;
+									 double dDistance = 0;
+
+
+									 double dD;
+									 while ((dDistance < dW) && (i >= 0))
+									 {
+										 i--;
+										 x1 = (p + i)->x;
+										 y1 = (p + i)->y;
+										 x2 = (p + i + 1)->x;
+										 y2 = (p + i + 1)->y;
+										 dD = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+
+										 dDistance += dD;
+									 }
+									 if (i < 0)
+										 return false;
+									 iPointIndex = i;
+
+									 double dSurplus = dDistance - dW;
+
+									 double x_begin1 = (p + iPointIndex)->x;
+									 double y_begin1 = (p + iPointIndex)->y;
+									 double x_begin2 = (p + iPointIndex + 1)->x;
+									 double y_begin2 = (p + iPointIndex + 1)->y;
+
+									 x_show_begin = dSurplus / dD *(x2 - x1) + x1;
+									 y_show_begin = dSurplus / dD *(y2 - y1) + y1;
+
+
+
+									 break;
+	}
+	case dmapLineLabelPositionCenter:
+	{
+										clsStruct::POINT* p = pLine->p;
+										int nPoint = pLine->nPoint;
+
+										int iIndex;
+										double x_gravity, y_gravity;
+										clsStruct::GetGravity(x_gravity, y_gravity, iIndex, pLine);
+
+										int i = iIndex + 1;
+										double dDistance = 0;
+
+										double x1, y1, x2, y2, dD;
+										while ((dDistance < dW) && (i >= 0))
+										{
+											i--;
+											x1 = (p + i)->x;
+											y1 = (p + i)->y;
+											x2 = (p + i + 1)->x;
+											y2 = (p + i + 1)->y;
+											dD = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+
+											dDistance += dD;
+										}
+
+										if (i < 0 || dDistance == 0)
+											return false;
+										iPointIndex = i;
+
+										double dSurplus = dDistance - dW;
+
+										double x_begin1 = (p + iPointIndex)->x;
+										double y_begin1 = (p + iPointIndex)->y;
+										double x_begin2 = (p + iPointIndex + 1)->x;
+										double y_begin2 = (p + iPointIndex + 1)->y;
+
+										x_show_begin = dSurplus / dD *(x2 - x1) + x1;
+										y_show_begin = dSurplus / dD *(y2 - y1) + y1;
+
+										break;
+	}
+	default:
+		break;
+	}
+
+	return true;
+}
+
+
+
+
+double SimpleLabelRenderer::CalculateRadianRight4(clsStruct::LINE* pLine, double dTextWidth, int & iIndex, double x_show, double y_show, double &x_show_next, double& y_show_next)
+{
+	/*
+	参数解释:
+	dTextWidth,当前单个文字的宽度
+	iIndex , 当前书写文本时在线条上的上一个点的索引
+	x_show , 当前书写文字的开始位置
+	y_show ,
+	x_show_next, 得出下一个文字开始书写的位置
+	y_show_next
+	*/
+
+
+	/*
+	通过计算, 得出当前这个文字的旋转弧度, 得出下一个文字的其实位置, 得出下一个文字落在第几个点到下一个点之间
+	*/
+	//尝试一次性写下该文字
+	clsStruct::POINT* p = pLine->p;
+	int nPoint = pLine->nPoint;
+
+	double x1 = x_show;
+	double y1 = y_show;
+	double x2 = (p + iIndex + 1)->x;
+	double y2 = (p + iIndex + 1)->y;
+	double dLength = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+
+	if (dLength > dTextWidth)
+	{
+		//一次性可以写下
+
+		//求导
+		double dDerivative = (y2 - y1) / (x2 - x1);
+		double dRadia = atan(dDerivative);                                                                     //计算出弧度
+		this->CalculateIntersection(dTextWidth, x_show, y_show, x1, y1, x2, y2, x_show_next, y_show_next);     //计算出下一个文字的位置
+
+		return dRadia;
+	}
+	else
+	{
+		//计算出另一端在哪两个点之间
+		for (iIndex++; iIndex < nPoint - 1; iIndex++)
+		{
+			double x2 = (p + iIndex + 1)->x;
+			double y2 = (p + iIndex + 1)->y;
+			double dLength = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+			if (dLength > dTextWidth)
+				break;
+		}
+
+		double x1__, y1__, x2__, y2__;
+		x1__ = (p + iIndex)->x;         y1__ = (p + iIndex)->y;
+		x2__ = (p + iIndex + 1)->x;     y2__ = (p + iIndex + 1)->y;
+		this->CalculateIntersection(dTextWidth, x_show, y_show, x1__, y1__, x2__, y2__, x_show_next, y_show_next);
+		double dRadia = atan((y_show_next - y_show) / (x_show_next - x_show));
+
+		return dRadia;
+	}
+	return 0;
+}
+
+int SimpleLabelRenderer::SplitUTF8(char* sUTF8, string* pStr, int iStrCount)
+{
+	int len = strlen(sUTF8);
+	if (len > iStrCount)
+		return -1;
+	for (int i = 0; i < len; i++)
+	{
+		char s_[5];  memset(s_, 0, 5);
+		s_[0] = sUTF8[i];
+		pStr[i] = s_;
+		string s = pStr[i];
+	}
+		
+	return len;
+}
+
+
+bool SimpleLabelRenderer::DrawMPolygon(clsCrSurf* pClsCS, clsStruct::MPOLYGON* pStrMPolygon, char* sUTF8)
+{
+	switch (m_iPolygonLabelPositionDirection)
+	{
+	case dmapPolygonLabelPositionParallel:
+		this->DrawMPolygonParallel(pClsCS, pStrMPolygon, sUTF8);
+		break;
+	case dmapPolygonLabelPositionStraight:
+		this->DrawMPolygonStraight(pClsCS, pStrMPolygon, sUTF8);
+		break;
+	case dmapPolygonLabelPositionParallelAndStraight:
+		this->DrawMPolygonParallelAndStraight(pClsCS, pStrMPolygon, sUTF8);
+		break;
+	default:
+		break;
+	}
+	
+
+	return true;
+}
+
+
+bool SimpleLabelRenderer::DrawMPolygonParallel(clsCrSurf* pClsCS, clsStruct::MPOLYGON* pStrMPolygon, char* sUTF8)
+{
+
+	int iPolygonIndex = 0, iRingIndex = 0;
+	clsStruct::GetMaxRing(pStrMPolygon, iPolygonIndex, iRingIndex);
+	clsStruct::LINE* pMaxRing = (pStrMPolygon->p + iPolygonIndex)->p + iRingIndex;
+
+	double x, y;
+	clsStruct::GetRingGravity(x, y, pMaxRing);
+
+
+	cairo_text_extents_t extents;
+	cairo_text_extents(pClsCS->m_pCr, sUTF8, &extents);
+	double dTextW = extents.x_advance;
+	double dTextH = extents.height;
+	double x_show = x - dTextW / 2;
+	double y_show = y + dTextH / 2;
+
+	if (m_bLabelInPolygon)
+	{
+		double x2, y2, x3, y3, x4, y4;
+		x2 = x_show; y2 = y_show - dTextH;
+		x3 = x_show + dTextW; y3 = y_show - dTextH;
+		x4 = x_show + dTextW; y4 = y_show;
+
+		bool flag1 = clsStruct::GetIsInRing(pMaxRing, x_show, y_show);
+		bool flag2 = clsStruct::GetIsInRing(pMaxRing, x2, y2);
+		bool flag3 = clsStruct::GetIsInRing(pMaxRing, x3, y3);
+		bool flag4 = clsStruct::GetIsInRing(pMaxRing, x4, y4);
+
+		if (flag1 && flag2 && flag3 && flag4)
+			return m_pTextSymbol->DrawAText(pClsCS, x_show, y_show, sUTF8);
+		else
+			return false;
+	}
+	else
+	{
+		bool flag = m_pTextSymbol->DrawAText(pClsCS, x_show, y_show, sUTF8);
+		return flag;
+	}
+}
+
+bool SimpleLabelRenderer::DrawMPolygonStraight(clsCrSurf* pClsCS, clsStruct::MPOLYGON* pStrMPolygon, char* sUTF8)
+{
+	int iPolygonIndex, iRingIndex;
+	clsStruct::GetMaxRing(pStrMPolygon, iPolygonIndex,iRingIndex);
+	clsStruct::LINE* pMaxRing = (pStrMPolygon->p + iPolygonIndex)->p + iRingIndex;
+
+	vector<double> vX, vY;
+	clsStruct::GetConvexRing(pMaxRing, vX, vY);
+
+	
+
+
+	double x1, y1, x2, y2, x3, y3, x4, y4;
+	this->OBB_Algorithm(vX, vY, x1, y1, x2, y2, x3, y3, x4, y4, pClsCS);
+
+
+
+	double dW = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
+	double dH = sqrt((x3 - x2)*(x3 - x2) + (y3 - y2)*(y3 - y2));
+
+
+
+	double dXW1,dYW1, dXW2, dYW2;
+	dXW1 = x2; dYW1 = y2;
+	if (dW >= dH)
+	{
+		dXW2 = x1;
+		dYW2 = y1;
+	}
+	else
+	{
+		dXW2 = x3;
+		dYW2 = y3;
+	}
+
+	if (dXW1 > dXW2)
+	{
+		double x_temp = dXW1;  double y_temp = dYW1;
+		dXW1 = dXW2;           dYW1 = dYW2;
+		dXW2 = x_temp;         dYW2 = y_temp;
+	}
+
+	double dAngle;
+
+	if (dXW1 == dXW2)
+	{
+		if (dYW1 > dYW2)
+			dAngle = 3 * M_PI / 2;
+		else
+			dAngle = M_PI / 2;
+	}
+	else
+		dAngle = atan((dYW2-dYW1) / (dXW2 - dXW1));
+
+
+	double x_gravity, y_gravity;
+
+	clsStruct::GetGravity(x_gravity, y_gravity, pStrMPolygon);
+
+
+	double dTextW, dTextH;
+
+	cairo_text_extents_t extents;
+	cairo_text_extents(pClsCS->m_pCr, sUTF8, &extents);
+	dTextW = extents.x_advance;
+	dTextH = extents.height;
+
+	double x_ = x_gravity - cos(dAngle)*dTextW / 2;
+	double y_ = y_gravity - sin(dAngle)*dTextW / 2;
+	double x_show = x_ - sin(dAngle)*dTextH / 2;
+	double y_show = y_ + cos(dAngle)*dTextH / 2;
+
+	double x2_ = x_ + sin(dAngle)*dTextH / 2;
+	double y2_ = y_ - cos(dAngle)*dTextH / 2;
+
+	double x___ = x_gravity + cos(dAngle)*dTextW / 2;
+	double y___ = y_gravity + sin(dAngle)*dTextW / 2;
+	double x3_ = x___ + sin(dAngle)*dTextH / 2;
+	double y3_ = y___ - cos(dAngle)*dTextH / 2;
+	double x4_ = x___ - sin(dAngle)*dTextH / 2;
+	double y4_ = y___ + cos(dAngle)*dTextH / 2;
+
+
+	/*{
+		cairo_t* cr = pClsCS->m_pCr;
+		cairo_set_source_rgba(cr, 1, 1, 0, 0.5);
+		cairo_set_line_width(cr, 1);
+		cairo_move_to(cr, x_show, y_show);
+		cairo_line_to(cr, x2_, y2_);
+		cairo_line_to(cr, x3_, y3_);
+		cairo_line_to(cr, x4_, y4_);
+		cairo_close_path(cr);
+		cairo_stroke(cr);
+
+		cairo_new_path(cr); cairo_arc(cr, x_gravity, y_gravity, 5, 0, 2 * M_PI); cairo_fill(cr);
+	}*/
+	//四个点都必须在多边形内部
+	bool flag1 = clsStruct::GetIsInRing(pMaxRing, x_show, y_show);
+	bool flag2 = clsStruct::GetIsInRing(pMaxRing, x2_, y2_);
+	bool flag3 = clsStruct::GetIsInRing(pMaxRing, x3_, y3_);
+	bool flag4 = clsStruct::GetIsInRing(pMaxRing, x4_, y4_);
+
+	if (flag1 && flag2 && flag3 && flag4)
+	{
+		bool flag = m_pTextSymbol->DrawAText(pClsCS, x_show, y_show, sUTF8, dAngle);
+		return flag;
+	}
+	return false;
+		
+
+	
+
+
+	//计算最小外包矩形 OBB
+
+	/*int nPoint = pMaxRing->nPoint;*/
+
+	/*{
+
+		cairo_t* cr = pClsCS->m_pCr;
+		cairo_set_source_rgba(cr, 0, 1, 1, 0.5);
+		cairo_set_line_width(cr, 4);
+
+		int sz = (int)vX.size();
+		double x, y;
+
+		for (int i = 0; i < sz; i++)
+		{
+			x = vX[i]; y = vY[i];
+
+			if (i == 0)
+				cairo_move_to(cr, x, y);
+			else
+				cairo_line_to(cr, x, y);
+		}
+		cairo_close_path(cr);
+		cairo_stroke(cr);
+	}*/
+
+	/*{
+		int nPoint = pMaxRing->nPoint;
+		clsStruct::POINT* p = pMaxRing->p;
+
+		cairo_t* cr = pClsCS->m_pCr;
+		cairo_set_source_rgba(cr, 1, 0.2, 0.2, 1);
+		cairo_set_line_width(cr, 1);
+
+		for (int i = 0; i < nPoint; i++)
+		{
+			double x = (p + i)->x;
+			double y = (p + i)->y;
+			if (i == 0)
+			{
+				cairo_move_to(cr, x, y);
+			}
+			else
+			{
+				cairo_line_to(cr, x, y);
+			}
+		}
+		cairo_close_path(cr);
+		cairo_stroke(cr);
+	}*/
+
+	//计算最小外包矩形OBB
+	
+	
+
+	////调整矩形, (x1,y1) (x2,y2)所在边为较长边
+	//double dW = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
+	//double dH = sqrt((x2-x3)*(x2-x3) + (y2-y3)*(y2-y3));
+
+	//if (dW < dH)
+	//{
+	//	double d_temp = dW;
+	//	dW = dH; dH = d_temp;
+
+	//	double x_temp = x1;
+	//	double y_temp = y1;
+	//	{
+	//		x1 = x2; x2 = x3; x3 = x4; x4 = x_temp;
+	//		y1 = y2; y2 = y3; y3 = y4; y4 = y_temp;
+	//	}
+	//}
+
+
+	//double x_center = (x1 + x2) / 2;
+	//double y_center = (y1 + y2) / 2;
+
+	////在该矩形的中心书写文字,且必须要写在多边形内部
+	//cairo_text_extents_t extents;
+	//cairo_text_extents(pClsCS->m_pCr, sUTF8, &extents);
+	//double dTextW = extents.x_advance;
+	//double dTextH = extents.height;
+
+	//double dAngle = atan((y2 - y1)/(x2 -x1));
+	//if (x1 > x2)
+	//	dAngle += M_PI;
+
+	//if (x1 <= x2 && y1 <= y2)
+	//{
+	//	double dAngle__ = 2 * M_PI - dAngle;
+
+	//	double x__ = x_center - cos(dAngle__)*dW / 2;
+	//	double y__ = y_center - sin(dAngle__)*dW / 2;
+	//	double x = x__ - sin(dAngle__)*dH / 2;
+	//	double y = y__ + cos(dAngle__)*dH / 2;
+
+	//	m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+
+	//}
+	//else if (x1 >= x2 && y1 >= y2)
+	//{
+	//	double dAngle__ = M_PI - dAngle;
+
+	//	double x__ = x_center - cos(dAngle__)*dW / 2;
+	//	double y__ = y_center - sin(dAngle__)*dW / 2;
+	//	double x = x__ - sin(dAngle__)*dH / 2;
+	//	double y = y__ + cos(dAngle__)*dH / 2;
+
+	//	m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, dAngle__);
+	//}
+	//else if (x1 < x2 && y1 > y2)
+	//{
+	//	double x__ = x_center - cos(dAngle)*dTextW / 2;
+	//	double y__ = y_center + sin(dAngle)*dTextW / 2;
+	//	double x = x__ + cos(dAngle)*dTextH / 2;
+	//	double y = y__ + sin(dAngle)*dTextH / 2;
+
+	//	m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle);
+	//}
+	//else if (x1 > x2 && y1 < y2)
+	//{
+	//	double dAngle__ = dAngle - M_PI;
+	//	double x__ = x_center - cos(dAngle__)*dTextW / 2;
+	//	double y__ = y_center + sin(dAngle__)*dTextW / 2;
+	//	double x = x__ + cos(dAngle__)*dTextH / 2;
+	//	double y = y__ + sin(dAngle__)*dTextH / 2;
+
+	//	m_pTextSymbol->DrawAText(pClsCS, x, y, sUTF8, -dAngle__);
+	//}
+
+	return true;
+}
+bool SimpleLabelRenderer::DrawMPolygonParallelAndStraight(clsCrSurf* pClsCS, clsStruct::MPOLYGON* pStrMPolygon, char* sUTF8)// 先水平,其次平直
+{
+
+	bool bHaveDraw = this->DrawMPolygonParallel(pClsCS, pStrMPolygon, sUTF8);
+	if (bHaveDraw)
+		return true;
+
+	return this->DrawMPolygonStraight(pClsCS, pStrMPolygon, sUTF8);
+}
+
+
+bool SimpleLabelRenderer::OBB_Algorithm(std::vector<double> vX, std::vector<double> vY, double& x1, double& y1, double& x2, double& y2, double& x3, double& y3, double& x4, double& y4, clsCrSurf* pClsCS)
+{
+
+	int nPoint = (int)(vX.size());
+
+	double dMinArea;
+
+	int iMinAreaIndex = 0;
+
+	for (int i = 0; i < nPoint; i++)
+	{
+		double dArea = OBB_GetMBR(vX, vY, i, pClsCS);
+
+		if (i == 0)
+		{
+			dMinArea = dArea;
+			iMinAreaIndex = 0;
+		}
+		else
+		{
+			if (dArea < dMinArea)
+			{
+				dMinArea = dArea;
+				iMinAreaIndex = i;
+			}
+		}
+	}
+
+	this->OBB_GetMBR(vX,vY, iMinAreaIndex, x1, y1, x2, y2, x3, y3, x4, y4, pClsCS);
+
+	return true;
+}
+
+double SimpleLabelRenderer::OBB_GetMBR(std::vector<double> vX, std::vector<double> vY, int iPointIndex, clsCrSurf* pClsCS)
+{
+	int nPoint = (int)(vX.size());
+
+	double x1 = vX[iPointIndex];
+	double y1 = vY[iPointIndex];
+
+	double x2, y2;
+	if (iPointIndex == nPoint - 1)
+	{
+		x2 = vX[0];
+		y2 = vY[0];
+	}
+	else
+	{
+		x2 = vX[iPointIndex + 1];
+		y2 = vY[iPointIndex + 1];
+	}
+
+	bool bHaveChanged = false;
+	if (x1 > x2)
+	{
+		double x_temp, y_temp;
+		x_temp = x1; x1 = x2; x2 = x_temp;
+		y_temp = y1; y1 = y2; y2 = y_temp;
+		bHaveChanged = true;
+	}
+
+	double dAngle;
+	if (x2 == x1)
+	{
+		if (y2 > y1)
+			dAngle = M_PI / 2;
+		else
+			dAngle = 3 * M_PI / 2;
+	}
+	
+	else
+	{
+		dAngle = atan((y2 - y1) / (x2 - x1));
+		if (x2 < x1)
+			dAngle += M_PI;
+	}
+		
+	dAngle = -dAngle;
+
+	double dLeft = x1, dRight = x1, dTop = 0;
+	int iLeftIndex, iRightIndex, iTopIndex;
+	if (bHaveChanged)
+	{
+		if (iPointIndex == nPoint - 1)
+			iLeftIndex = iRightIndex = iTopIndex = 0;
+		else
+			iLeftIndex = iRightIndex = iTopIndex = iPointIndex + 1;
+	}
+	else
+		iLeftIndex = iRightIndex = iTopIndex = iPointIndex;
+
+
+	for (int i = 0; i < nPoint; i++)
+	{
+		double x_ = vX[i];
+		double y_ = vY[i];
+
+		double x_new = (x_ - x1)*cos(dAngle) - (y_ - y1)* sin(dAngle) + x1;
+		double y_new = (x_ - x1)*sin(dAngle) + (y_ - y1)* cos(dAngle) + y1;
+
+		if (x_new < dLeft)
+		{
+			dLeft = x_new;
+			iLeftIndex = i;
+		}
+		if (x_new > dRight)
+		{
+			dRight = x_new;
+			iRightIndex = i;
+		}
+		if (fabs(y_new - y1) > dTop)
+		{
+			dTop = fabs(y_new - y1);
+			iTopIndex = i;
+		}
+	}
+
+
+	//直接先得出旋转后的矩形
+	// x_rect_rotate_1
+
+
+	double x_rr_1, y_rr_1, x_rr_2, y_rr_2, x_rr_3, y_rr_3, x_rr_4, y_rr_4;
+	double x_l, y_l, x_r, y_r, x_t, y_t;
+	double x_l_new, y_l_new, x_r_new, y_r_new, x_t_new, y_t_new;
+	x_l = vX[iLeftIndex];        y_l = vY[iLeftIndex];        x_l_new = (x_l - x1)*cos(dAngle) - (y_l - y1)*sin(dAngle) + x1;   y_l_new = (x_l - x1)*sin(dAngle) + (y_l - y1)*cos(dAngle) + y1;
+	
+	x_r = vX[iRightIndex];       y_r = vY[iRightIndex];       x_r_new = (x_r - x1)*cos(dAngle) - (y_r - y1)*sin(dAngle) + x1;   y_r_new = (x_r - x1)*sin(dAngle) + (y_r - y1)*cos(dAngle) + y1;
+	x_t = vX[iTopIndex];         y_t = vY[iTopIndex];         x_t_new = (x_t - x1)*cos(dAngle) - (y_t - y1)*sin(dAngle) + x1;   y_t_new = (x_t - x1)*sin(dAngle) + (y_t - y1)*cos(dAngle) + y1; 
+	
+
+	x_rr_1 = x_l_new; y_rr_1 = y_t_new;
+	x_rr_2 = x_r_new; y_rr_2 = y_t_new;
+	x_rr_3 = x_r_new; y_rr_3 = y1;
+	x_rr_4 = x_l_new; y_rr_4 = y1;
+
+
+
+
+
+	double dW = sqrt((x_rr_2 - x_rr_1)*(x_rr_2 - x_rr_1) + (y_rr_2 - y_rr_1)*((y_rr_2 - y_rr_1)));
+	double dH = sqrt((x_rr_2 - x_rr_3)*(x_rr_2 - x_rr_3) + (y_rr_2 - y_rr_3)*((y_rr_2 - y_rr_3)));
+	double dArea = dW*dH;
+
+
+	return dArea;
+}
+
+bool   SimpleLabelRenderer::OBB_GetMBR(std::vector<double> vX, std::vector<double> vY, int iPointIndex, double& x01, double& y01, double& x02, double& y02, double& x03, double& y03, double& x04, double& y04, clsCrSurf* pClsCS)
+{
+
+	int nPoint = (int)(vX.size());
+
+	double x1 = vX[iPointIndex];
+	double y1 = vY[iPointIndex];
+
+	double x2, y2;
+	if (iPointIndex == nPoint - 1)
+	{
+		x2 = vX[0];
+		y2 = vY[0];
+	}
+	else
+	{
+		x2 = vX[iPointIndex + 1];
+		y2 = vY[iPointIndex + 1];
+	}
+
+	bool bHaveChanged = false;
+	if (x1 > x2)
+	{
+		double x_temp, y_temp;
+		x_temp = x1; x1 = x2; x2 = x_temp;
+		y_temp = y1; y1 = y2; y2 = y_temp;
+		bHaveChanged = true;
+	}
+
+	double dAngle;
+	if (x2 == x1)
+	{
+		if (y2 > y1)
+			dAngle = M_PI / 2;
+		else
+			dAngle = 3 * M_PI / 2;
+	}
+
+	else
+	{
+		dAngle = atan((y2 - y1) / (x2 - x1));
+		if (x2 < x1)
+			dAngle += M_PI;
+	}
+
+	dAngle = -dAngle;
+
+	double dLeft = x1, dRight = x1, dTop = 0;
+	int iLeftIndex, iRightIndex, iTopIndex;
+	if (bHaveChanged)
+	{
+		if (iPointIndex == nPoint - 1)
+			iLeftIndex = iRightIndex = iTopIndex = 0;
+		else
+			iLeftIndex = iRightIndex = iTopIndex = iPointIndex + 1;
+	}
+	else
+		iLeftIndex = iRightIndex = iTopIndex = iPointIndex;
+
+
+	for (int i = 0; i < nPoint; i++)
+	{
+		double x_ = vX[i];
+		double y_ = vY[i];
+
+		double x_new = (x_ - x1)*cos(dAngle) - (y_ - y1)* sin(dAngle) + x1;
+		double y_new = (x_ - x1)*sin(dAngle) + (y_ - y1)* cos(dAngle) + y1;
+
+		if (x_new < dLeft)
+		{
+			dLeft = x_new;
+			iLeftIndex = i;
+		}
+		if (x_new > dRight)
+		{
+			dRight = x_new;
+			iRightIndex = i;
+		}
+		if (fabs(y_new - y1) > dTop)
+		{
+			dTop = fabs(y_new - y1);
+			iTopIndex = i;
+		}
+	}
+
+
+	//直接先得出旋转后的矩形
+	// x_rect_rotate_1
+
+
+	double x_rr_1, y_rr_1, x_rr_2, y_rr_2, x_rr_3, y_rr_3, x_rr_4, y_rr_4;
+	double x_l, y_l, x_r, y_r, x_t, y_t;
+	double x_l_new, y_l_new, x_r_new, y_r_new, x_t_new, y_t_new;
+	x_l = vX[iLeftIndex];        y_l = vY[iLeftIndex];        x_l_new = (x_l - x1)*cos(dAngle) - (y_l - y1)*sin(dAngle) + x1;   y_l_new = (x_l - x1)*sin(dAngle) + (y_l - y1)*cos(dAngle) + y1;
+
+	x_r = vX[iRightIndex];       y_r = vY[iRightIndex];       x_r_new = (x_r - x1)*cos(dAngle) - (y_r - y1)*sin(dAngle) + x1;   y_r_new = (x_r - x1)*sin(dAngle) + (y_r - y1)*cos(dAngle) + y1;
+	x_t = vX[iTopIndex];         y_t = vY[iTopIndex];         x_t_new = (x_t - x1)*cos(dAngle) - (y_t - y1)*sin(dAngle) + x1;   y_t_new = (x_t - x1)*sin(dAngle) + (y_t - y1)*cos(dAngle) + y1;
+	
+
+	x_rr_1 = x_l_new; y_rr_1 = y_t_new;
+	x_rr_2 = x_r_new; y_rr_2 = y_t_new;
+	x_rr_3 = x_r_new; y_rr_3 = y1;
+	x_rr_4 = x_l_new; y_rr_4 = y1;
+
+	double x_rect_1, y_rect_1, x_rect_2, y_rect_2, x_rect_3, y_rect_3, x_rect_4, y_rect_4;
+
+	dAngle = -dAngle;
+
+	x_rect_1 = (x_rr_1 - x1)*cos(dAngle) - (y_rr_1 - y1)*sin(dAngle) + x1;    y_rect_1 = (x_rr_1 - x1)*sin(dAngle) + (y_rr_1 - y1)*cos(dAngle) + y1;
+	x_rect_2 = (x_rr_2 - x1)*cos(dAngle) - (y_rr_2 - y1)*sin(dAngle) + x1;    y_rect_2 = (x_rr_2 - x1)*sin(dAngle) + (y_rr_2 - y1)*cos(dAngle) + y1;
+	x_rect_3 = (x_rr_3 - x1)*cos(dAngle) - (y_rr_3 - y1)*sin(dAngle) + x1;    y_rect_3 = (x_rr_3 - x1)*sin(dAngle) + (y_rr_3 - y1)*cos(dAngle) + y1;
+	x_rect_4 = (x_rr_4 - x1)*cos(dAngle) - (y_rr_4 - y1)*sin(dAngle) + x1;    y_rect_4 = (x_rr_4 - x1)*sin(dAngle) + (y_rr_4 - y1)*cos(dAngle) + y1;
+
+	x01 = x_rect_1; y01 = y_rect_1;
+	x02 = x_rect_2; y02 = y_rect_2;
+	x03 = x_rect_3; y03 = y_rect_3;
+	x04 = x_rect_4; y04 = y_rect_4;
+
+
+	
+
+	return true;
+}
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//
+//#include "SimpleLabelRenderer.h"
+//#include"TextSymbol.h"
+//#include"clsXML.h"
+//#include"DataCollection.h"
+//#include"clsStruct.h"
+//#include"clsCrSurf.h"
+//#include"clsMalloc.h"
+//#include"clsUtil.h"
+//#include"StringHelp.h"
+//
+//
+//#define dotX 5
+//#define dotY 5
+//
+//
+//SimpleLabelRenderer::SimpleLabelRenderer()
+//{
+//	m_sField = "";
+//	m_pTextSymbol = new TextSymbol();
+//	m_sLabelPriorities = "2,2,1,4,5,3,2,4";
+//	this->SetPriority();
+//	m_iFeatureWeight=0;
+//	m_iLabelWeight = 0;
+//	m_iHowmanyLabels = 0;
+//	m_dLabelBufferRatio = 0;
+//	m_iLineLabelPosition = 0;
+//	m_sRotationlAngles = "0";
+//}
+//
+//
+//SimpleLabelRenderer::~SimpleLabelRenderer()
+//{
+//	if (m_pTextSymbol)
+//		m_pTextSymbol->Release();
+//}
+//int SimpleLabelRenderer::RendererType()
+//{
+//	return dmapSimpleLabelRenderer;
+//}
+//bool  SimpleLabelRenderer::Parse(rapidxml::xml_pt<char>* pt, AppendBuffer *f)
+//{
+//	if (!pt&&!f)return false;
+//	clsXML clsX(f, "SIMPLELABELRENDERER");
+//	clsXML::XMLAttrParse(pt, f, &m_sField, "field");
+//	clsXML::XMLAttrParse(pt, f, &m_sLabelPriorities, "labelpriorities");
+//	if (pt)
+//	{
+//		this->SetPriority();
+//	}
+//	clsX.closeProperties();
+//	if (pt)
+//	{
+//		m_pTextSymbol->Parse(pt->first_pt(), NULL);
+//	}
+//	else
+//	{
+//		m_pTextSymbol->Parse(NULL, f);
+//	}
+//	//m_pTextSymbol->Parse(pt->first_pt(), f);
+//	/*Renderer* pp = m_pTextSymbol;
+//	if (pt)
+//	{
+//		clsXML::XMLParse(pt->first_pt(), NULL, &pp);
+//		m_pTextSymbol = (TextSymbol*)pp;
+//	}
+//	else
+//		clsXML::XMLParse(NULL, f, &pp);*/
+//	return true;
+//}
+//
+//
+//
+//SimpleLabelRenderer* SimpleLabelRenderer::CreateNew()
+//{
+//	SimpleLabelRenderer* dest = new SimpleLabelRenderer();
+//	return dest;
+//}
+//const char*  SimpleLabelRenderer::GetField()
+//{
+//	return m_sField.c_str();
+//}
+//bool    SimpleLabelRenderer::SetField(const char* sField)
+//{
+//	m_sField = sField;
+//	return true;
+//}
+//const char*  SimpleLabelRenderer::GetLabelPriorities()
+//{
+//	return m_sLabelPriorities.c_str();
+//}
+//bool    SimpleLabelRenderer::SetLabelPriorities(const char* sLabelPriorities)
+//{
+//	bool flag = this->TrackPriorityString(sLabelPriorities);
+//	if (!flag)
+//		return false;
+//	m_sLabelPriorities = sLabelPriorities;
+//	this->SetPriority();
+//	return true;
+//}
+//TextSymbol* SimpleLabelRenderer::GetTextSymbol()
+//{
+//	if (m_pTextSymbol)
+//		m_pTextSymbol->AddRef();
+//	return m_pTextSymbol;
+//}
+//bool    SimpleLabelRenderer::SetTextSymbol(TextSymbol* ts)
+//{
+//	if (!ts)
+//		return false;
+//	ts->AddRef();
+//	if (m_pTextSymbol)
+//		m_pTextSymbol->Release();
+//	m_pTextSymbol = ts;
+//	return true;
+//}
+//int     SimpleLabelRenderer::GetFeatureWeight()
+//{
+//	return m_iFeatureWeight;
+//}
+//bool    SimpleLabelRenderer::SetFeatureWeight(int iFeatureWeight)
+//{
+//	m_iFeatureWeight = iFeatureWeight;
+//	return true;
+//}
+//int     SimpleLabelRenderer::GetLabelWeight()
+//{
+//	return m_iLabelWeight;
+//}
+//bool    SimpleLabelRenderer::SetLabelWeight(int iLabelWeight)
+//{
+//	m_iLabelWeight = iLabelWeight;
+//	return true;
+//}
+//int     SimpleLabelRenderer::GetHowmanyLabels()
+//{
+//	return m_iHowmanyLabels;
+//}
+//bool    SimpleLabelRenderer::SetHowmanyLabels(int iHowmanyLabels)
+//{
+//	m_iHowmanyLabels = iHowmanyLabels;
+//	return true;
+//}
+//double  SimpleLabelRenderer::GetLabelBufferRatio()
+//{
+//	return m_dLabelBufferRatio;
+//}
+//bool    SimpleLabelRenderer::SetLabelBufferRatio(double dLabelBufferRatio)
+//{
+//	m_dLabelBufferRatio = dLabelBufferRatio;
+//	return true;
+//}
+//int     SimpleLabelRenderer::GetLineLabelPosition()
+//{
+//	return m_iLineLabelPosition;
+//}
+//bool    SimpleLabelRenderer::SetLineLabelPosition(int iLineLabelPosition)
+//{
+//	m_iLineLabelPosition = iLineLabelPosition;
+//	return true;
+//}
+//const char* SimpleLabelRenderer::GetRotationalAngles()
+//{
+//	return m_sRotationlAngles.c_str();
+//}
+//bool    SimpleLabelRenderer::SetRotationalAngles(const char* sRotationalAngles)
+//{
+//	m_sRotationlAngles = sRotationalAngles;
+//	return true;
+//}
+//
+//
+//
+//
+///*
+//检查该字符串是否符合格式要求
+//格式为: "1,2,3,4,5,6,7,8"
+//8个数字用逗号或其他一字节符号隔开
+//*/
+//bool SimpleLabelRenderer::TrackPriorityString(const char* sPriority)
+//{
+//	int len = strlen(sPriority);
+//	if (len != 15)
+//		return false;
+//	for (int i = 0; i < 8; i++)
+//	{
+//		char c = sPriority[2 * i];
+//		if (c>'9' || c < '0')
+//			return false;
+//	}
+//	return true;
+//}
+//
+///*
+//处理传入的字符串,转化为8个数的数组,这8个数表示8个标签位的优先级
+//然后进一步处理,确定8个标签位先后出现的顺序,保存在 m_i8中
+//
+//比如   2 2 1 4 5 3 2 4
+//1 2 3 4 5 6 7 8
+//排序后 3 1 2 7 6 4 8 5
+//*/
+//bool SimpleLabelRenderer::SetPriority()
+//{
+//	const char* ss = m_sLabelPriorities.c_str();
+//
+//	int num[8]; // 这是从字符串接收来的8个数字
+//
+//	for (int i = 0; i < 8; i++)
+//	{
+//		num[i] = ss[2 * i];
+//		if (num[i] == 0)
+//			num[i] = 9;  //将0 暂时作为9处理
+//		m_i8[i] = i;
+//	}
+//
+//	int temp;
+//	for (int i = 0; i < 7; i++)
+//	{
+//		for (int j = 0; j < 7 - i; j++)
+//		{
+//			if (num[j] > num[j + 1])
+//			{
+//				temp = num[j]; num[j] = num[j + 1]; num[j + 1] = temp;
+//				temp = m_i8[j]; m_i8[j] = m_i8[j + 1]; m_i8[j + 1] = temp;
+//			}
+//		}
+//	}
+//	return true;
+//}
+//
+//bool SimpleLabelRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, char* pFlag)
+//{
+//	int iPartCount = data->m_iPartCount;
+//	cairo_surface_t* surface = pClsCS->m_pSurf;
+//	double surf_w = cairo_image_surface_get_width(surface);
+//	double surf_h = cairo_image_surface_get_height(surface);
+//
+//	m_lpt = this->GetLabelPositionType();
+//
+//	for (int i = 0; i < iPartCount; i++)
+//		this->DrawStruct(pClsCS, data, i, pFlag, (int)(surf_w), (int)(surf_h));
+//	return true;
+//}
+//void SimpleLabelRenderer::TryAddField(vector<string>&pvField)
+//{
+//	vector<string>::iterator it = find(pvField->begin(), pvField->end(), m_sField);
+//	if (it == pvField->end())
+//		pvField->push_back(m_sField);
+//}
+////这个地方还是有些不好处理,需要额外传递字符串进来
+//bool SimpleLabelRenderer::DrawStruct(clsCrSurf* pClsCS, DataCollection* data, int index, char* pFlag, int dcW, int dcH)
+//{
+//	int fieldCount = (int)(data->m_vFieldName.size());
+//	int fieldID = -1;
+//	for (int i = 0; i < fieldCount; i++)
+//	{
+//		if (m_sField == data->m_vFieldName[i])
+//		{
+//			fieldID = i;
+//			break;
+//		}
+//	}
+//	if (fieldID == -1)
+//		return false;
+//	string sText = data->m_vAllField[index][fieldID];
+//
+//	double x = 0, y = 0;// 这是几何图形的中心点,绘制文本在此基础上偏移
+//	int structType = data->m_iStructType;
+//	switch (structType)
+//	{
+//	case clsStruct::Struct_Point:{clsStruct::POINT* pPoint = (clsStruct::POINT*)(data->m_pData); x = (pPoint + index)->x; y = (pPoint + index)->y; break; }
+//	case clsStruct::Struct_Line:{clsStruct::LINE* pLine = (clsStruct::LINE*)(data->m_pData); clsStruct::GetCenter(x, y, pLine + index); break; }
+//	case clsStruct::Struct_MLine:{clsStruct::MLINE* pMLine = (clsStruct::MLINE*)(data->m_pData); clsStruct::GetCenter(x, y, pMLine + index); break; }
+//	case clsStruct::Struct_Polygon:{clsStruct::POLYGON* pPolygon = (clsStruct::POLYGON*)(data->m_pData); clsStruct::GetCenter(x, y, pPolygon + index); break; }
+//	case clsStruct::Struct_MPolygon:{clsStruct::MPOLYGON* pMPolygon = (clsStruct::MPOLYGON*)(data->m_pData); clsStruct::GetCenter(x, y, pMPolygon + index); break; }
+//	default:
+//		break;
+//	}
+//
+//	/*
+//	开始绘制文本
+//	*/
+//	const char* text_gbk = sText.c_str();
+//	int lenout = strlen(text_gbk) * 3 / 2 + 100;
+//	clsMalloc m(lenout);
+//	char * utf8 = m.mem;
+//	memset(utf8, 0, lenout);
+//	clsUtil::ConvertEnc("GBK", "UTF-8", text_gbk, utf8, lenout);
+//
+//	m_pTextSymbol->SetCairo(pClsCS);
+//
+//	cairo_t* cr = pClsCS->m_pCr;
+//	cairo_text_extents_t extents;
+//	cairo_text_extents(cr, utf8, &extents);
+//	double width_text = extents.width, height_text = extents.height;
+//	int textW = (int)width_text;
+//	int textH = (int)height_text;
+//
+//	//strcpy(utf8, text_gbk);
+//	for (int i = 0; i < 8; i++)
+//	{
+//		bool flag = false;
+//		switch (m_i8[i])
+//		{
+//		case 1:{if (m_pTextSymbol->DrawAText(pClsCS, x - dotX - textW, y - dotY, utf8, textW, textH, pFlag, dcW, dcH)) flag = true; break; }
+//		case 2:{if (m_pTextSymbol->DrawAText(pClsCS, x - textW / 2, y - dotY, utf8, textW, textH, pFlag, dcW, dcH)) flag = true; break; }
+//		case 3:{if (m_pTextSymbol->DrawAText(pClsCS, x + dotX, y - dotY, utf8, textW, textH, pFlag, dcW, dcH)) flag = true; break; }
+//		case 4:{if (m_pTextSymbol->DrawAText(pClsCS, x + dotX, y + textH / 2, utf8, textW, textH, pFlag, dcW, dcH)) flag = true; break; }
+//		case 5:{if (m_pTextSymbol->DrawAText(pClsCS, x + dotX, y + dotY + textH, utf8, textW, textH, pFlag, dcW, dcH)) flag = true; break; }
+//		case 6:{if (m_pTextSymbol->DrawAText(pClsCS, x - textW / 2, y + dotY + textH, utf8, textW, textH, pFlag, dcW, dcH)) flag = true; break; }
+//		case 7:{if (m_pTextSymbol->DrawAText(pClsCS, x - dotX - textW, y + dotY + textH, utf8, textW, textH, pFlag, dcW, dcH)) flag = true; break; }
+//		case 8:{if (m_pTextSymbol->DrawAText(pClsCS, x - dotX - textW, y + textH / 2, utf8, textW, textH, pFlag, dcW, dcH)) flag = true; break; }
+//		default:break;
+//		}
+//		if (flag)
+//			break;
+//	}
+//	return true;
+//}
+//
+//
+//bool SimpleLabelRenderer::DrawPOINT(clsCrSurf* pClsCS, clsStruct::POINT* pPoint, const char* sUTF8)
+//{
+//	/*
+//	转字符集
+//	*/
+//	///////////////////////////////////////////////////////////////////////////////////////////////////
+//	/*int lenout = strlen(text_gbk) * 3 / 2 + 100;
+//	clsMalloc m(lenout);
+//	char * utf8 = m.mem;
+//	memset(utf8, 0, lenout);
+//	clsUtil::ConvertEnc("GBK", "UTF-8", text_gbk, utf8, lenout);*/
+//	///////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//	m_pTextSymbol->SetCairo(pClsCS);
+//
+//
+//	/*
+//	获取文本宽高
+//	*/
+//	///////////////////////////////////////////////////////////////////////////////////////////////////
+//	cairo_t* cr = pClsCS->m_pCr;
+//	cairo_text_extents_t extents; //这个对象重复构造?!!
+//	cairo_text_extents(cr, sUTF8, &extents);
+//	double width_text = extents.width, height_text = extents.height;
+//	int textW = (int)width_text;
+//	int textH = (int)height_text;
+//	/////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//
+//	double x = pPoint->x;
+//	double y = pPoint->y;
+//	/*
+//	四种位置
+//	*/
+//	switch (m_lpt)
+//	{
+//	case SimpleLabelRenderer::dmapLabelPositionOnTopHorizontal:
+//	{
+//		x = x - textW/2.0;
+//		y = y + textH / 2.0;
+//		this->DrawAText(pClsCS, x, y, 0, sUTF8);
+//	}
+//		break;
+//	case SimpleLabelRenderer::dmapLabelPositionAngleNumber:
+//	{
+//															  int length = (int)(m_vdAngles.size());
+//															  bool flag = false;
+//															  for (int i = 0; i < length; i++)
+//															  {
+//																  double dAngle = m_vdAngles[i];
+//																  flag = this->DrawAText(pClsCS, x, y, dAngle, sUTF8);
+//																  if (flag)
+//																	  break;
+//															  }
+//	}
+//		break;
+//	case SimpleLabelRenderer::dmapLabelPositionAngleField:
+//	{
+//															 //额外查询一次数据库
+//
+//	}
+//		break;
+//	case SimpleLabelRenderer::dmapLabelPositionPeriphery:
+//	{
+//															
+//	}
+//		break;
+//	default:
+//		break;
+//	}
+//	return true;
+//}
+//bool SimpleLabelRenderer::DrawMPOINT(clsCrSurf* clsCr, clsStruct::LINE* pLine)
+//{
+//	return true;
+//}
+//bool SimpleLabelRenderer::DrawAText(clsCrSurf* clsCS, double x, double y, double dAngle, const char* sUTF8)
+//{
+//	
+//
+//
+//	return true;
+//}
+//
+//bool SimpleLabelRenderer::TrackRotationalAngles(const char* sRotationalAngles)
+//{
+//	char sAngleBackup[200];
+//	memset(sAngleBackup, 0, 200);
+//	int len = strlen(sRotationalAngles);
+//	memcpy(sAngleBackup, sRotationalAngles, len);
+//	char * ss[10];
+//	StringHelp::ParseStringTok(sAngleBackup, ',', ss, 10);
+//
+//	return true;
+//}
+//
+//SimpleLabelRenderer::LabelPositionType SimpleLabelRenderer::GetLabelPositionType()
+//{
+//	if (m_sLabelPriorities == "LE_PlaceOnTopHorizontal")
+//		return dmapLabelPositionOnTopHorizontal;
+//	if (m_sLabelPriorities == "0,0,0,0,0,0,0,0")
+//	{
+//		if (m_sRotationlAngles != "")
+//		{
+//			//const char* ss = m_sRotationlAngles.c_str();
+//			bool bTrackOK = this->TrackRotationalAngles(m_sRotationlAngles.c_str());
+//			if (bTrackOK)
+//				return dmapLabelPositionAngleNumber;
+//			return dmapLabelPositionAngleField;
+//		}
+//	}
+//	return dmapLabelPositionPeriphery;
+//}
+//
+//bool SimpleLabelRenderer::CalculateAngles()
+//{
+//	const char* sAngles = m_sRotationlAngles.c_str();
+//	char sAngleBackup[200];
+//	memset(sAngleBackup, 0, 200);
+//	int len = strlen(sAngles);
+//	memcpy(sAngleBackup, sAngles, len);
+//	char * ss[10];
+//	int count = StringHelp::ParseStringTok(sAngleBackup, ',', ss, 10);
+//	for (int i = 0; i < count; i++)
+//	{
+//		m_vdAngles[i] = stod(ss[i], NULL);
+//	}
+//
+//	return true;
+//}

+#pragma once
+#ifndef _SimpleLabelRenderer_H_
+#define _SimpleLabelRenderer_H_
+#include<string>
+#include<vector>
+using namespace std;
+#include"Renderer.h"
+#include"TextSymbol.h"
+#include"clsStruct.h"
+#define LLPSZ 10     //dmapLineLabelPosition__Size
+
+namespace DmapCore_30
+{
+	class CORE_EXPORT SimpleLabelRenderer :public Renderer
+	{
+	public:
+		SimpleLabelRenderer();
+		~SimpleLabelRenderer();
+		int RendererType();
+		virtual bool  Parse(boost::property_tree::ptree &pt, AppendBuffer *f);
+		virtual void ToJson(AppendBuffer *ab);
+		//virtual bool RendererString(Renderer** ppRen, const char** psXML);
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag = NULL);
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag = NULL);
+		virtual bool DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag= NULL);
+		string m_sField;
+		TextSymbol* m_pTextSymbol;
+
+
+		string m_sLabelPriorities;
+		string m_sRotationAngles;
+		//int m_iRotateMethod;
+		string m_sRotationAngleField;
+		bool m_bIsVerticalToAngle;
+
+		/*
+		LineLabelPosition分成3属性
+		*/
+		int m_iLineLabelPositionDirection;
+		int m_iLineLabelPositionStartOrEnd;
+		string m_sLineLabelPositionPlaces;
+		int m_LineLabelPositionPlaces[3];
+
+
+		int m_iPolygonLabelPositionDirection;
+		bool m_bLabelInPolygon;
+
+
+
+
+		bool DoSetLineLabelPositionPlaces();
+
+		void TryAddField(vector<string>&pvField);
+		bool TryFindHeatRenderer(){ return false; }
+		
+
+
+		static SimpleLabelRenderer* CreateNew();
+		const char*  GetField();
+		bool    SetField(const char* sField);
+		const char*  GetLabelPriorities();
+		bool    SetLabelPriorities(const char* sLableLabelPriorities);
+		TextSymbol* GetTextSymbol();
+		bool    SetTextSymbol(TextSymbol* ts);
+		const char* GetRotationAngles();
+		bool    SetRotationAngles(const char* sRotationalAngles);
+		const char*GetRotationAngleField();
+		bool    SetRotationAngleField(const char* sAngleField);
+		//int     GetRotateMethod();                //只对点有效
+		//bool    SetRotateMethod(int iRotateMethod);
+		int     GetLineLabelPositionDirection();
+		bool    SetLineLabelPositionDirection(int iLineLabelPositionDirection);
+		const char*GetLineLabelPositionPlace();
+		bool    SetLineLabelPositionPlace(const char* iLineLabelPositionPlace);
+		int     GetLineLabelPositionStartOrEnd();
+		bool    SetLineLabelPositionStartOrEnd(int iLineLabelPositionStartOrEnd);
+		int     GetPolygonLabelPositionDirection();
+		bool    SetPolygonLabelPositionDirection(int iPolygonLabelPositionDirection);
+		bool    GetLabelInPolygon();
+		bool    SetLabelInPolygon(bool bLabelInPolygon);
+		bool    GetIsVerticalToAngle();
+		bool    SetIsVerticalToAngle(bool bIsVerticalToAngle);
+
+
+
+	private:
+
+		/*
+		点样式类型使用规定
+		1.优先使用 m_sLabelPriorities , m_sLabelPriorities 可以赋值3种,第一种,确定各标签位优先级的8个数字,第二种,使用 DMap_PlaceOnTopHorizontal, 在点之上
+		第三种,使用8个0,则使用旋转角度书写文本
+		2. 优先使用AngleField,但每次设置旋转角度时,将AngleField重置为""
+		3. 使用旋转角度
+		*/
+		 enum PointLabelPositionType
+		{
+			dmapPointLabelPositionOnTopHorizontal = 0,
+			dmapPointLabelPositionAngleNumber = 1,
+			dmapPointLabelPositionAngleField = 2,
+			dmapPointLabelPositionPeriphery = 3,
+			dmapPointLabelPositionError,
+		};
+		PointLabelPositionType m_plpt;
+		SimpleLabelRenderer::PointLabelPositionType DoSetPointLabelPositionType();   //每次调用此函数,维护位置的类型 m_lpt
+
+
+
+	private:
+
+		vector<double> m_vdAngles;
+		int m_i8[8];    // 
+
+
+		bool CalculatePrioritiesNumber();     //处理 字符串,按8个标签的优先级排序1-8
+		bool CalculateAngles();               //处理 m_sRotationalAngles,存到 m_dAngles
+		bool TrackPriorityString(const char* sPriority);           //判断 m_sPriorities 字符串是否是8个数字
+		bool TrackRotationAngles(const char* sRotationalAngles);
+
+
+
+
+
+		/*
+		Draw部分
+		*/
+	public:
+		bool DrawStruct(clsCrSurf* pClsCS, DataCollection* data, int index);
+
+		/*
+		Point
+		*/
+		bool DrawPoint(clsCrSurf* pClsCS, DataCollection* data, int index, char* sUTF8);
+
+		/*
+		MLine
+		*/
+		bool DrawMLine(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8);
+		bool DrawMLineLevel(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8);    //水平放置
+		bool DrawMLineParallel(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8); //平行放置
+		bool DrawMLineCurve(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8);      //弯曲
+		bool DrawMLineVertical(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8); //垂直
+
+		double CalculateRadianRight(clsStruct::LINE* pStrLine, double dTextWidth, int iIndex, double x, double y, double&x_show, double&y_show);
+		double CalculateRadianLeft(clsStruct::LINE* pStrLine, double dTextWidth, int iIndex, double x, double y, double&x_show, double& y_show);
+
+		bool DrawMLineCurve2(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8);    //弯曲
+		double CalculateRadianRight2(clsStruct::LINE* pStrLine, double dTextWidth, int& iIndex, double x_show, double y_show, double &x_show_next, double&y_show_next);
+		double CalculateRadianLeft2(clsStruct::LINE* pStrLine, double dTextWidth, int& iIndex, double x_show, double y_show, double&x_show_next, double&y_show_next);
+		void CalculateIntersection(double dWidth, double x_from, double y_from, double x1, double y1, double x2, double y2, double&x_to, double&y_to);
+
+		bool DrawMLineCurve3(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8);
+		// DrawMLineCurve4(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8);
+		bool LineToSmooth(clsStruct::LINE* pStrLine, vector<double>& vX, vector<double>& vY);     //线条平滑处理
+		bool Douglas_Peucker_algorithm(vector<double> &vX, vector<double>& vY);
+
+		bool CalculateShowBegin(vector<double> vX, vector<double> vY, double dW, double& x_show_begin, double& y_show_begin, int & iPointIndex);
+		double CalculateRadianRight3(vector<double> vX, vector<double> vY, double dTextWidth, int& iIndex, double x_show, double y_show, double &x_show_next, double&y_show_next);
+
+
+		bool DrawMLineCurve4(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8);
+		bool DrawMLineCurve5(clsCrSurf* pClsCS, clsStruct::MLINE* pStrMLine, char* sUTF8);
+
+		double CalculateDistance(double x0, double y0, double x1, double y1, double x2, double y2);
+		bool CalculateShowBegin(clsStruct::LINE* pLine, double dW, double& x_show_begin, double& y_show_begin, int & iPointIndex);
+		bool CalculateShowBegin5(clsStruct::LINE* pLine, double dW, double& x_show_begin, double& y_show_begin, int & iPointIndex, double& dRadia, int width, int height);
+		double CalculateRadianRight4(clsStruct::LINE* pLine, double dTextWidth, int & iIndex, double x_show, double y_show, double &x_show_next, double& y_show_next);
+		int SplitUTF8(char* sUTF8, string* pStr, int iStrCount);
+
+
+
+
+		bool DrawMPolygon(clsCrSurf* pClsCS, clsStruct::MPOLYGON* pStrMPolygon, char* sUTF8);
+		bool DrawMPolygonParallel(clsCrSurf* pClsCS, clsStruct::MPOLYGON* pStrMPolygon, char* sUTF8);  //平行放置
+		bool DrawMPolygonStraight(clsCrSurf* pClsCS, clsStruct::MPOLYGON* pStrMPolygon, char* sUTF8);  //平直
+		bool DrawMPolygonParallelAndStraight(clsCrSurf* pClsCS, clsStruct::MPOLYGON* pStrMPolygon, char* sUTF8); // 先水平,其次平直
+
+
+		bool OBB_Algorithm(std::vector<double> vX, std::vector<double> vY, double& x1, double& y1, double& x2, double& y2, double& x3, double& y3, double& x4, double& y4, clsCrSurf* pClsCS);
+		double OBB_GetMBR(std::vector<double> vX, std::vector<double> vY, int i, clsCrSurf* pClsCS);
+		bool   OBB_GetMBR(std::vector<double> vX, std::vector<double> vY, int iPointIndex, double& x1, double& y1, double& x2, double& y2, double& x3, double& y3, double& x4, double& y4, clsCrSurf* pClsCS);
+
+
+
+	};
+
+
+
+}
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//#pragma once
+//#include<string>
+//using namespace std;
+//#include"Renderer.h"
+//#include"clsStruct.h"
+//class TextSymbol;
+//class clsCrSurf;
+//class DataCollection;
+//class SimpleLabelRenderer:public Renderer
+//{
+//public:
+//	SimpleLabelRenderer();
+//	~SimpleLabelRenderer();
+//	int RendererType();
+//	virtual bool  Parse(rapidxml::xml_node<char>* node, AppendBuffer *f);
+//	virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, char* pFlag);
+//
+//	string m_sField;
+//	string m_sLabelPriorities;
+//	TextSymbol* m_pTextSymbol;
+//	int m_iFeatureWeight;
+//	int m_iLabelWeight;
+//	int m_iHowmanyLabels;
+//	double m_dLabelBufferRatio;
+//	int m_iLineLabelPosition;
+//	string m_sRotationalAngles;
+//	
+//
+//
+//	static SimpleLabelRenderer* CreateNew();
+//	const char*  GetField();
+//	bool    SetField(const char* sField);
+//	const char*  GetLabelPriorities();
+//	bool    SetLabelPriorities(const char* sLableLabelPriorities);
+//	TextSymbol* GetTextSymbol();
+//	bool    SetTextSymbol(TextSymbol* ts);
+//	int     GetFeatureWeight();
+//	bool    SetFeatureWeight(int iFeatureWeight);
+//	int     GetLabelWeight();
+//	bool    SetLabelWeight(int iLabelWeight);
+//	int     GetHowmanyLabels();
+//	bool    SetHowmanyLabels(int iHowmanyLabels);
+//	double  GetLabelBufferRatio();
+//	bool    SetLabelBufferRatio(double dLabelBufferRatio);
+//	int     GetLineLabelPosition();
+//	bool    SetLineLabelPosition(int iLineLabelPosition);
+//	const char* GetRotationalAngles();
+//	bool    SetRotationalAngles(const char* sRotationalAngles);
+//
+//
+//	void TryAddField(vector<string>&pvField);
+//	bool DrawStruct(clsCrSurf* pClsCS, DataCollection* data, int index, char* pFlag, int dcW, int dcH);
+//
+//
+//	bool DrawPOINT(clsCrSurf* clsCS, clsStruct::POINT* pPoint, const char* sText);
+//	bool DrawMPOINT(clsCrSurf* clsCr, clsStruct::LINE* pLine);
+//
+//	bool DrawAText(clsCrSurf* clsCS, double x, double y,double dAngle, const char* sUTF8);
+//
+//
+//	//bool DrawPOINT(clsCairo* clsCr, clsStruct::POINT* pPoint);
+//
+//private:
+//
+//	/*
+//	1. labelPriorities优先,只在 labelPriorities 为"0,0,0,0,0,0,0,0"时,考虑 rotationalangles 属性
+//	2. labelPriorities 可以赋值为 "LE_PlaceOnTopHorizontal" ,在点之上放置,或者面内部,或者在线上
+//	3. rotationalAngles可以被赋值为 "45,30,60" 或者"objectid"两种方式
+//	*/
+//	
+//	
+//
+//	bool TrackPriorityString(const char* sPriority);
+//	bool SetPriority();
+//	bool TrackRotationalAngles(const char* sRotationalAngles);
+//	
+//
+//	/*
+//	标签位置部分
+//	*/
+//	static enum LabelPositionType
+//	{
+//		dmapLabelPositionOnTopHorizontal = 0,  //在点上,或者面上
+//		dmapLabelPositionAngleNumber = 1,      //使用数字弧度(固定值)
+//		dmapLabelPositionAngleField = 2,       //使用指定字段作为弧度
+//		dmapLabelPositionPeriphery = 3,        //使用周边的8个标签位 水平放置
+//	};
+//	LabelPositionType m_lpt;
+//	vector<double> m_vdAngles;
+//	int m_i8[8];    // 这是从LabelPriorities直接分割出来的数字
+//	int m_iLabelPriorities[8];  //这是经过处理后,依次优先的标签位置的顺序
+//
+//	SimpleLabelRenderer::LabelPositionType GetLabelPositionType();
+//	bool CalculatePrioritiesNumber();     //处理 m_i8,得出 m_iLabelPriorities
+//	bool CalculateAngles();               //处理 m_sRotationalAngles,存到 m_dAngles
+//
+//
+//
+//
+//	
+//};
+//

+
+#include "SimpleLineSymbol.h"
+#include "clsUtil.h"
+#include"clsXML.h"
+#include"clsCrSurf.h"
+#include "clsJson.h"
+#define _USE_MATH_DEFINES
+#include<math.h>
+namespace DmapCore_30
+{
+
+	SimpleLineSymbol::SimpleLineSymbol()
+	{
+		m_iAntialiasing = CAIRO_ANTIALIAS_DEFAULT;
+		m_iColor = clsUtil::RandomColor();
+		clsUtil::ToCairoColor(m_iColor, r, g, b, a);
+		//m_pClsSurfBackup =	NULL;
+		m_iType = 0;
+		m_sPNG = "";
+		m_dWidth = 1;
+		m_iCapType = 0;
+		m_iJionType = 0;
+		m_sXML = "";
+		//png = 0;
+		m_mustReloadPng = true;
+		m_simpleRenderer = true;
+	}
+	SimpleLineSymbol::~SimpleLineSymbol()
+	{
+		//if (png)
+		//{
+		//	delete png;
+		//}
+	}
+	SimpleLineSymbol* SimpleLineSymbol::CreateNew()
+	{
+		SimpleLineSymbol * dest = new SimpleLineSymbol();
+		return dest;
+	}
+	int SimpleLineSymbol::RendererType()
+	{
+		return dmapSimpleLineSymbol;
+	}
+
+	bool  SimpleLineSymbol::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
+	{
+		//if (!node&&!f)return false;
+		clsXML clsX(f, "SIMPLELINESYMBOL");
+		clsXML::ParseEnum("antialiasing", pt, f, &m_iAntialiasing, "antialias_default", "antialias_none", "antialias_gray", "antialias_subpixel", "antialias_fase", "antialias_good", "antialias_best", "true", "false");
+		clsXML::XMLAttrParse(pt, f, &m_sPNG, "png");
+		clsXML::ParseEnum("type", pt, f, &m_iType, "solid", "dash", "dot", "dash_dot", "dash_dot_dot");
+		clsXML::XMLAttrParseColor(pt, f, &m_iColor, "color", "transparency");
+		clsXML::XMLAttrParse(pt, f, &m_dWidth, "width");
+		clsXML::ParseEnum("captype", pt, f, &m_iCapType, "cap_butt", "cap_round", "cap_square");
+		clsXML::ParseEnum("jiontype", pt, f, &m_iJionType, "jion_miter", "jion_round", "jion_bevel");
+
+			if (m_sPNG != "")
+			{
+				m_sPNG = GetFilePath(m_sPNG);
+				if (FILE *file = fopen(m_sPNG.c_str(), "r")) {
+					fclose(file);
+				}
+				else {
+					m_sPNG = "";
+				}
+			}
+		clsUtil::ToCairoColor(m_iColor, r, g, b, a);
+		m_mustReloadPng = true;
+		return true;
+	}
+
+	void  SimpleLineSymbol::ToJson(AppendBuffer *ab)
+   {
+	   char buff[300] = {0};
+	   char resultbuff[5000] = {0};
+		strcat(resultbuff, R"("SIMPLELINESYMBOL":{"antialiasing":"antialias_default",)");
+		clsJson::JsonAttrParse("icon", resultbuff, buff, this->m_sPNG);
+		//clsJson::ParseEnum("type", resultbuff, buff, m_iAntialiasing, "antialias_default", "antialias_none", "antialias_gray", "antialias_subpixel", "antialias_fase", "antialias_good", "antialias_best", "true", "false");
+		clsJson::ParseEnum("type", resultbuff, buff, m_iType, "solid", "dash", "dot", "dash_dot", "dash_dot_dot");
+		clsJson::JsonAttrParseColor("color", "transparency", resultbuff, buff, m_iColor);
+		clsJson::JsonAttrParse("width", resultbuff, buff, m_dWidth);
+		
+		clsJson::ParseEnum("captype", resultbuff, buff, m_iCapType, "cap_butt", "cap_round", "cap_square");
+		clsJson::ParseEnum("jiontype", resultbuff, buff, m_iJionType, "jion_miter", "jion_round", "jion_bevel");
+		
+		clsJson::JsonAttrEnd(resultbuff);
+		ab->AppendString(resultbuff);
+   }
+
+	int                  SimpleLineSymbol::GetAntialiasing()
+	{
+		return  m_iAntialiasing;
+	}
+	bool                 SimpleLineSymbol::SetAntialiasing(int newVal)
+	{
+		m_iAntialiasing = newVal;
+		return true;
+	}
+	unsigned int        SimpleLineSymbol::GetColor()
+	{
+		return  m_iColor;
+	}
+	bool                 SimpleLineSymbol::SetColor(unsigned int color)
+	{
+		m_iColor = color;
+		clsUtil::ToCairoColor(color, r, g, b, a);
+		return true;
+	}
+	int                   SimpleLineSymbol::GetType()
+	{
+		return  m_iType;
+	}
+	bool                 SimpleLineSymbol::SetType(int type)
+	{
+		m_iType = type;
+		return true;
+	}
+	const char*               SimpleLineSymbol::GetPNG()
+	{
+		//m_sPNG = "中国人";
+		//clsMalloc clsM2;
+		//bool flag = clsUtil::ConvertEncGB18030_UTF8(m_sPNG.c_str(), clsM2);
+		//m_sPNG = clsM2.mem;
+		return  m_sPNG.c_str();
+	}
+	bool                 SimpleLineSymbol::SetPNG(const char* png)
+	{
+		m_sPNG = png;
+		m_mustReloadPng = true;
+		png = 0;
+		return true;
+	}
+	double               SimpleLineSymbol::GetWidth()
+	{
+		return  m_dWidth;
+	}
+	bool                 SimpleLineSymbol::SetWidth(double width)
+	{
+		if (width < 0)return false;
+		m_dWidth = width;
+		return true;
+	}
+	int                      SimpleLineSymbol::GetCapType()
+	{
+		return m_iCapType;
+	}
+	bool                     SimpleLineSymbol::SetCapType(int iCapType)
+	{
+		m_iCapType = iCapType;
+		return true;
+	}
+	int                      SimpleLineSymbol::GetJionType()
+	{
+		return m_iJionType;
+	}
+	bool                     SimpleLineSymbol::SetJionType(int iJionType)
+	{
+		m_iJionType = iJionType;
+		return true;
+	}
+
+	/*
+	*/
+	int SimpleLineSymbol::BytesPerLine(int nWidth, int nBitsPerPixel)  //像素宽度、每个像素多少位
+	{
+		return ((nWidth * nBitsPerPixel + 31) & (~31)) / 8;
+	}
+
+
+	bool SimpleLineSymbol::DrawLINESimple(clsCrSurf* clsCS, clsStruct::LINE*pLine)
+	{
+		if(pLine == NULL || pLine->p == NULL)
+			 return false;
+		cairo_t* cr = clsCS->m_pCr;
+		clsUtil::DoSetAntialias(m_iAntialiasing, cr);
+
+		int nPoint = pLine->nPoint;
+		clsStruct::POINT* pPoint = pLine->p;
+		cairo_new_path(cr);
+		for (int i = 0; i < nPoint; i++)
+		{
+			double x = pPoint[i].x;
+			double y = pPoint[i].y;
+
+			if (i == 0)
+			{
+				cairo_move_to(cr, x, y);
+			}
+			else
+				cairo_line_to(cr, x, y);
+		}
+		clsUtil::DoSetLineType(m_iType, cr);
+		cairo_set_source_rgba(cr, r, g, b, a);
+		cairo_set_line_width(cr, m_dWidth);
+		cairo_set_line_cap(cr, (cairo_line_cap_t)m_iCapType);
+		cairo_set_line_join(cr, (cairo_line_join_t)m_iJionType);
+		cairo_stroke(cr);
+		return true;
+	}
+
+	bool SimpleLineSymbol::DrawMLINESimple(clsCrSurf* clsCS, clsStruct::MLINE*pMLine)
+	{
+
+		if(pMLine == NULL || pMLine->p == NULL) return false;
+		cairo_t* cr = clsCS->m_pCr;
+		clsUtil::DoSetAntialias(m_iAntialiasing, cr);
+
+		int nLine = pMLine->nLine;
+		clsStruct::LINE* pLine = pMLine->p;
+		cairo_new_path(cr);
+	
+		for (int i = 0; i < nLine; i++)
+		{
+			int nPoint = (pLine + i)->nPoint;
+			clsStruct::POINT* pPoint = (pLine + i)->p;
+
+			if(pPoint == NULL) continue;
+			for (int j = 0; j < nPoint; j++)
+			{
+				double x = pPoint[j].x;
+				double y = pPoint[j].y;
+				if (j == 0)
+				{
+					cairo_move_to(cr, x, y);
+				}
+				else
+					cairo_line_to(cr, x, y);
+			}
+		}
+		clsUtil::DoSetLineType(m_iType, cr);
+		cairo_set_source_rgba(cr, r, g, b, a);
+		cairo_set_line_width(cr, m_dWidth);
+		cairo_set_line_cap(cr, (cairo_line_cap_t)m_iCapType);
+		cairo_set_line_join(cr, (cairo_line_join_t)m_iJionType);
+		cairo_stroke(cr);
+
+		return true;
+	}
+
+	bool SimpleLineSymbol::DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
+	{
+		/***********************************************************************************************/
+		/*
+		patta
+		*/
+		/*
+		if (m_sPNG != "")
+		{
+		if (m_pPatta != NULL)
+		TryDelete(m_pPatta);
+		this->TryCreatePatta(pClsCS);
+		}
+		*/
+		/***********************************************************************************************/
+		
+		int structType = data->m_iStructType;
+		int iPartCount = data->m_iPartCount;
+	
+       if (m_sPNG != "")
+	   {
+		cairo_t* cr = pClsCS->m_pCr;
+		cairo_new_path(cr);
+		cairo_arc(cr, 0, 0, 1, 0, 1 * M_PI);
+		cairo_set_source_rgba(cr, 1, 1, 1, 0.01);
+		cairo_fill(cr);  //不留边框填充
+	   }
+
+		switch (structType)
+		{
+		case clsStruct::Struct_Line:
+		{
+									   for (int i = 0; i < iPartCount; i++)
+									   {
+										   clsStruct::LINE* pLine = (clsStruct::LINE*)data->m_pData;
+										   this->DrawLINE(pClsCS, pLine + i);
+									   }
+									   break;
+		}
+		case clsStruct::Struct_MLine:
+		{
+										for (int i = 0; i < iPartCount; i++)
+										{
+											clsStruct::MLINE* pMLine = (clsStruct::MLINE*)data->m_pData;
+											this->DrawMLINE(pClsCS, pMLine + i);
+										}
+										break;
+		}
+		default:
+			break;
+		}
+		return true;
+	}
+
+	bool SimpleLineSymbol::DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag)
+	{
+		/***********************************************************************************************/
+		/*
+		patta
+		*/
+		/*
+		if (m_sPNG != "")
+		{
+		if (m_pPatta != NULL)
+		TryDelete(m_pPatta);
+		this->TryCreatePatta(pClsCS);
+		}
+		*/
+		/***********************************************************************************************/
+
+		int structType = data->m_iStructType;
+		int iPartCount = data->m_iPartCount;
+
+
+		switch (structType)
+		{
+		case clsStruct::Struct_Line:
+		{
+									   clsStruct::LINE* pLine = (clsStruct::LINE*)data->m_pData;
+									   this->DrawLINE(pClsCS, pLine + dataIndex);
+									   break;
+		}
+		case clsStruct::Struct_MLine:
+		{
+										clsStruct::MLINE* pMLine = (clsStruct::MLINE*)data->m_pData;
+										this->DrawMLINE(pClsCS, pMLine + dataIndex);
+										break;
+		}
+		default:
+			break;
+		}
+		return true;
+	}
+
+	bool SimpleLineSymbol::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag)
+	{
+		if(layerType != 1)
+			 return false;
+
+		pLegendParamater->next(pFlag);
+
+		cairo_t *cr = pClsCS->m_pCr;
+		if (pFlag)
+		{
+			cairo_set_source_rgb(cr, 0, 0, 0); //设置画笔颜色，也就是红，绿，蓝，这里设置成绿色。
+			cairo_select_font_face(cr, pLegendParamater->font.c_str(), 
+				CAIRO_FONT_SLANT_NORMAL, 
+				pLegendParamater->isbold? CAIRO_FONT_WEIGHT_BOLD:CAIRO_FONT_WEIGHT_NORMAL);
+
+			cairo_set_font_size(cr, pLegendParamater->fontSize);
+			cairo_move_to(cr, pLegendParamater->pixXIndex + pLegendParamater->size_x + 10, 
+						pLegendParamater->pixYIndex + pLegendParamater->size_y - 3);
+						
+			cairo_show_text(cr, pFlag);
+		}
+		if (m_sPNG != "")
+		{
+			//cairo_t* cr = pClsCS->m_pCr;
+			cairo_new_path(cr);
+			cairo_arc(cr, 0, 0, 1, 0, 1 * M_PI);
+			cairo_set_source_rgba(cr, 1, 1, 1, 0.01);
+			cairo_fill(cr); //不留边框填充
+		}
+
+		clsUtil::DoSetAntialias(m_iAntialiasing, cr);
+
+		//int nPoint = pLine->nPoint;
+		//clsStruct::POINT* pPoint = pLine->p;
+		cairo_new_path(cr);
+		cairo_move_to(cr, pLegendParamater->pixXIndex, pLegendParamater->pixYIndex + pLegendParamater->size_y/2);
+		cairo_line_to(cr, pLegendParamater->pixXIndex + pLegendParamater->size_x, pLegendParamater->pixYIndex + pLegendParamater->size_y/2);
+		
+		clsUtil::DoSetLineType(m_iType, cr);
+		cairo_set_source_rgba(cr, r, g, b, a);
+		cairo_set_line_width(cr, m_dWidth);
+		cairo_set_line_cap(cr, (cairo_line_cap_t)m_iCapType);
+		cairo_set_line_join(cr, (cairo_line_join_t)m_iJionType);
+		cairo_stroke(cr);
+		return true;
+	}
+	
+	bool SimpleLineSymbol::DrawLINE(clsCrSurf* pClsCS, clsStruct::LINE * pLine)
+	{
+		if (m_sPNG == "")
+			return this->DrawLINESimple(pClsCS, pLine);
+		else
+			return this->DrawLINEPNG(pClsCS, pLine);
+	}
+
+
+	bool SimpleLineSymbol::DrawMLINE(clsCrSurf* pClsCS, clsStruct::MLINE* pMLine)
+	{
+		if (m_sPNG == "")
+			return this->DrawMLINESimple(pClsCS, pMLine);
+		else
+			return this->DrawMLINEPNG(pClsCS, pMLine);
+	}
+
+	bool SimpleLineSymbol::DrawLINEPNG(clsCrSurf* pClsCS, clsStruct::LINE* pLine)
+	{
+		return true;
+	}
+	bool SimpleLineSymbol::DrawMLINEPNG(clsCrSurf* pClsCS, clsStruct::MLINE* pMLine)
+	{
+	
+		//	return true;
+		/*if (m_mustReloadPng == true || m_LastBGColor != pClsCS->m_iBGColor)
+		{
+			TryReadPng(pClsCS->m_iBGColor);
+		}
+	
+	  
+		cairo_surface_t* surface = pClsCS->m_pSurf;
+		int surf_w = cairo_image_surface_get_width(surface);
+		int surf_h = cairo_image_surface_get_height(surface);
+
+		unsigned char* buffer = cairo_image_surface_get_data(surface);
+		
+		//agg::rendering_buffer m_pRBuf(buffer, (unsigned int)surf_w, (unsigned int)surf_h, (int)(surf_w * 4));
+		//pixfmt m_pf(m_pRBuf);
+		//renderer_base m_pRen_base(m_pf);
+		//renderer_type m_pRen_img(m_pRen_base, *(png->patta));
+		//rasterizer_type m_pRas_img(m_pRen_img);
+	
+		/*int nLine = pMLine->nLine;
+		clsStruct::LINE * pLine = pMLine->p;
+
+		for (int j = 0; j < nLine; j++)
+		{
+			int nPoint = pLine[j].nPoint;
+			clsStruct::POINT * pPoint = pLine[j].p;
+
+			agg::path_storage path;
+			for (int k = 0; k < nPoint; k++)
+			{
+				double x = pPoint[k].x;
+				double y = pPoint[k].y;
+				if (k == 0)
+					path.move_to(x, y);
+				else
+					path.line_to(x, y);
+			}
+			m_pRas_img.add_path(path);
+		}*/
+		return true;
+
+
+	}
+
+	
+
+	bool SimpleLineSymbol::TryReadPng(unsigned int colorThis)
+	{
+		//m_mustReloadPng = false;
+	    //m_LastBGColor = colorThis;
+		//if (png)delete png; png = new clsPng();
+		//if (png->ReadPng(this->m_sPNG.c_str(), m_LastBGColor) == 1)
+		//{
+		//	delete png; png = 0;
+		//	return false;
+		//}
+
+		return true;
+	}
+
+	bool SimpleLineSymbol::TryCreatePatta(clsCrSurf * pClsCS)
+	{
+
+		return true;
+	}
+	bool SimpleLineSymbol::TryCreateRendererBase()
+	{
+
+		return true;
+	}
+}
\ No newline at end of file

+#pragma once
+
+#ifndef _SimpleLineSymbol_H_
+#define _SimpleLineSymbol_H_
+#include<string>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/foreach.hpp>
+#include "Renderer.h"
+#include "clsStruct.h"
+#include "clsCrSurf.h"
+#include "DataCollection.h"
+//#include "clsPng.h"
+
+using namespace std;
+
+namespace DmapCore_30
+{
+	class clsCrSurf;
+	class Path;
+	class DataCollection;
+	class CORE_EXPORT SimpleLineSymbol :public Renderer
+	{
+	public:
+
+		//没有实现 captype,jointype
+		SimpleLineSymbol();
+		~SimpleLineSymbol();
+		static SimpleLineSymbol* CreateNew();
+		virtual int RendererType();
+		virtual bool  Parse(boost::property_tree::ptree &pt, AppendBuffer *f);
+        virtual void ToJson(AppendBuffer *ab);
+		//virtual bool RendererString(Renderer** ppRen, const char** psXML);
+		virtual bool DrawData(clsCrSurf* clsCS, DataCollection* data, bool drawSimpleData, char* pFlag = NULL);
+		virtual bool DrawData(clsCrSurf* clsCS, DataCollection* data, int dataIndex, char* pFlag = NULL);
+		virtual bool DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag = NULL);
+
+
+		//clsPng *png;
+
+		/*
+		全局变量
+		*/
+		int  m_iAntialiasing;
+		unsigned int m_iColor;
+		int m_iType;
+		string m_sPNG;
+		double m_dWidth;
+		int m_iCapType;
+		int m_iJionType;
+
+		double r, g, b, a;
+
+		int                      GetAntialiasing();
+		bool                     SetAntialiasing(int newVal);
+		unsigned int             GetColor();
+		bool                     SetColor(unsigned int color);
+		int                      GetType();
+		bool                     SetType(int type);
+		const char*              GetPNG();
+		bool                     SetPNG(const char* png);
+		double                   GetWidth();
+		bool                     SetWidth(double width);
+		int                      GetCapType();
+		bool                     SetCapType(int iCapType);
+		int                      GetJionType();
+		bool                     SetJionType(int iJionType);
+
+
+		//此处传的 geom 都是屏幕坐标
+		int BytesPerLine(int nWidth, int nBitsPerPixel);
+
+
+
+
+		bool TryFindHeatRenderer(){ return false; }
+
+
+
+		//线条有点难办啊, 需要传surface宽和高,还要传 绘图 buffer指针
+
+		bool DrawLINE(clsCrSurf* clsCS, clsStruct::LINE * pLine);
+		bool DrawMLINE(clsCrSurf* clsCS, clsStruct::MLINE* pMLine);
+		bool DrawLINESimple(clsCrSurf* clsCS, clsStruct::LINE* pLine);
+		bool DrawLINEPNG(clsCrSurf* clsCS, clsStruct::LINE* pLine);
+		bool DrawMLINESimple(clsCrSurf* clsCS, clsStruct::MLINE* pMLine);
+		bool DrawMLINEPNG(clsCrSurf* clsCS, clsStruct::MLINE* pMLine);
+
+
+	private:
+		bool m_mustReloadPng;
+		unsigned int  m_LastBGColor;
+		bool TryReadPng(unsigned int colorThis);
+		//clsCrSurf* m_pClsSurfBackup;
+		bool TryCreatePatta(clsCrSurf * clsCS);
+		bool TryCreateRendererBase();
+	};
+
+}
+
+#endif
\ No newline at end of file

+
+#include "SimpleMarkerSymbol.h"
+#include "clsUtil.h"
+#include "clsCrSurf.h"
+#include "clsXML.h"
+#include "DataCollection.h"
+#include "clsJson.h"
+#define _USE_MATH_DEFINES
+#include <math.h>
+namespace DmapCore_30
+{
+	SimpleMarkerSymbol::SimpleMarkerSymbol()
+	{
+		m_iAntialiasing = CAIRO_ANTIALIAS_DEFAULT;
+		m_bBoundary = true;
+		m_iColor = clsUtil::RandomColor();
+		clsUtil::ToCairoColor(m_iColor, r, g, b, a);
+		m_iType = 0;
+		m_iOutline = 0xff000000;
+		clsUtil::ToCairoColor(m_iOutline, r1, g1, b1, a1);
+		m_sPNG = "";
+		m_dWidth = 1;
+		m_dSize = 5;
+		m_sXML = "";
+		m_simpleRenderer = false;
+	}
+
+	SimpleMarkerSymbol::~SimpleMarkerSymbol()
+	{
+		if (surfImage)
+		{
+			cairo_surface_destroy(surfImage);
+			surfImage = nullptr;
+		}
+	}
+	SimpleMarkerSymbol* SimpleMarkerSymbol::CreateNew()
+	{
+		SimpleMarkerSymbol * dest = new SimpleMarkerSymbol();
+		return dest;
+	}
+
+	int SimpleMarkerSymbol::RendererType()
+	{
+		return dmapSimpleMarkerSymbol;
+	}
+	bool SimpleMarkerSymbol::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
+	{
+	
+		
+		clsXML clsX(f, "SIMPLEMARKERSYMBOL");
+		clsXML::ParseEnum("antialiasing", pt, f, &m_iAntialiasing, "antialias_default", "antialias_none", "antialias_gray", "antialias_subpixel", "antialias_fase", "antialias_good", "antialias_best", "true", "false");
+		clsXML::XMLAttrParse(pt, f, &m_sPNG, "png");
+		clsXML::ParseEnum("type", pt, f, &m_iType, "circle", "triangle", "square", "cross", "star", "icon");
+		clsXML::XMLAttrParseColor(pt, f, &m_iColor, "color", "transparency");
+		clsXML::XMLAttrParse(pt, f, &m_bBoundary, "boundary");
+		clsXML::XMLAttrParseColor(pt, f, &m_iOutline, "outline", "outlinetransparency");
+		clsXML::XMLAttrParse(pt, f, &m_dWidth, "width");
+		clsXML::XMLAttrParse(pt, f, &m_dSize, "size");
+		//if (node)
+		{
+			clsUtil::ToCairoColor(m_iColor, r, g, b, a);
+			clsUtil::ToCairoColor(m_iOutline, r1, g1, b1, a1);
+			if (m_sPNG != "")
+			{
+				m_sPNG = GetFilePath(m_sPNG);
+				if (FILE *file = fopen(m_sPNG.c_str(), "r")) {
+					fclose(file);
+					surfImage = cairo_image_surface_create_from_png(m_sPNG.c_str());
+				}
+				else {
+					m_sPNG = "";
+				}
+			}
+		}
+		return true;
+	}
+
+	void  SimpleMarkerSymbol::ToJson(AppendBuffer* ab)
+   {
+
+	    char buff[300] = {0};
+		char resultbuff[5000] = {0};
+		sprintf(resultbuff, R"("SIMPLEMARKERSYMBOL":{"antialiasing":"antialias_default",)");
+		string png = this->m_sPNG;
+		if(png != "" && png.find("symbollib") != png.npos)
+		{
+			int pos = png.find("symbollib");
+			png = "../" + png.substr(pos,png.length() - pos);
+		}
+		clsJson::JsonAttrParse("png", resultbuff, buff, png);
+		clsJson::ParseEnum("type", resultbuff, buff, m_iType, "circle", "triangle", "square", "cross", "star", "icon");
+		clsJson::JsonAttrParseColor("color", "transparency", resultbuff, buff, m_iColor);
+		clsJson::JsonAttrParse("boundary", resultbuff, buff, m_bBoundary);
+		clsJson::JsonAttrParseColor("outline", "outlinetransparency", resultbuff, buff, m_iOutline);
+		clsJson::JsonAttrParse("width", resultbuff, buff, m_dWidth);
+		clsJson::JsonAttrParse("size", resultbuff, buff, m_dSize);
+		clsJson::JsonAttrEnd(resultbuff);
+		ab->AppendString(resultbuff);
+   }
+
+	int                 SimpleMarkerSymbol::GetAntialiasing()
+	{
+		return m_iAntialiasing;
+	}
+	bool                 SimpleMarkerSymbol::SetAntialiasing(int iAntialiasing)
+	{
+		m_iAntialiasing = iAntialiasing;
+		return true;
+	}
+	unsigned int                  SimpleMarkerSymbol::GetColor()
+	{
+		return  m_iColor;
+	}
+	bool                 SimpleMarkerSymbol::SetColor(unsigned  int color)
+	{
+		clsUtil::ToCairoColor(color, r, g, b, a);
+		m_iColor = color;
+		return true;
+	}
+	int                  SimpleMarkerSymbol::GetType()
+	{
+		return  m_iType;
+	}
+	bool                 SimpleMarkerSymbol::SetType(int type)
+	{
+		if (type<0 || type >6) return false;
+		m_iType = type;
+		return true;
+	}
+	bool                     SimpleMarkerSymbol::GetBoundary()
+	{
+		return m_bBoundary;
+	}
+	bool                     SimpleMarkerSymbol::SetBoundary(bool boundary)
+	{
+		m_bBoundary = boundary;
+		return true;
+	}
+	unsigned int                  SimpleMarkerSymbol::GetOutline()
+	{
+		return  m_iOutline;
+	}
+	bool                 SimpleMarkerSymbol::SetOutline(unsigned int outline)
+	{
+		clsUtil::ToCairoColor(outline, r1, g1, b1, a1);
+		m_iOutline = outline;
+		return true;
+	}
+	const char*               SimpleMarkerSymbol::GetPNG()
+	{
+		return  m_sPNG.c_str();
+	}
+	bool                 SimpleMarkerSymbol::SetPNG(const char* png)
+	{
+		surfImage = nullptr;
+		if (png == 0)m_sPNG = "";
+		else m_sPNG = png;
+		if (m_sPNG.size() > 0)
+		{
+			surfImage = cairo_image_surface_create_from_png(png);
+		}
+		return true;
+	}
+	double               SimpleMarkerSymbol::GetWidth()
+	{
+		return  m_dWidth;
+	}
+	bool                 SimpleMarkerSymbol::SetWidth(double width)
+	{
+		if (width < 0)return false;
+		m_dWidth = width;
+		return true;
+	}
+	double               SimpleMarkerSymbol::GetSize()
+	{
+		return  m_dSize;
+	}
+	bool                 SimpleMarkerSymbol::SetSize(double Size)
+	{
+		if (Size < 0)return false;
+		m_dSize = Size;
+		return true;
+	}
+
+
+
+	bool SimpleMarkerSymbol::DrawPOINT(clsCrSurf* clsCS, clsStruct::POINT*p)
+	{
+		double x = p->x;
+		double y = p->y;
+
+		cairo_t* cr = clsCS->m_pCr;
+	
+
+		double width = 0.5 * m_dSize;
+
+		if (m_sPNG != "")
+		{
+			//这样做实现不了边框!!!
+			// 是否该用 png　平铺一样的实现,提供边框
+			cairo_surface_t* image = surfImage;// m_pImage->m_pSurf;
+			if (image == 0)return false;
+			double w = cairo_image_surface_get_width(image);
+			double h = cairo_image_surface_get_height(image);
+			cairo_set_source_surface(cr, image, x - 0.5*w, y - 0.5*h);
+			cairo_paint(cr);
+		}
+		else
+		{
+			switch (m_iType)
+			{
+			case dmapPointTypeCross:
+			{
+									   cairo_move_to(cr, x - width, y);
+									   cairo_line_to(cr, x + width, y);
+									   cairo_move_to(cr, x, y - width);
+									   cairo_line_to(cr, x, y + width);
+									   cairo_set_source_rgba(cr, r, g, b, a);
+									   cairo_set_line_width(cr, 1);
+									   cairo_stroke(cr);
+									   break;
+			}
+			case dmapPointTypeCircle:
+			{
+										cairo_new_path(cr);
+										cairo_arc(cr, x, y, width, 0, 2 * M_PI);
+										cairo_set_source_rgba(cr, r, g, b, a);
+										if (m_bBoundary)
+										{
+											cairo_fill_preserve(cr);//留边框填充
+											/* 接下来是画边框 */
+											cairo_set_line_width(cr, m_dWidth);
+											cairo_set_source_rgba(cr, r1, g1, b1, a1);
+											cairo_stroke(cr);
+										}
+										else
+										{
+											cairo_fill(cr);  //不留边框填充
+										}
+										//cairo_fill(cr);  //不留边框填充
+										break;
+			}
+			case dmapPointTypeTriangle:
+			{
+										  cairo_new_sub_path(cr);
+										  cairo_move_to(cr, x - width, y + width * 0.57735026918962576450914878050196);
+										  cairo_line_to(cr, x + width, y + width * 0.57735026918962576450914878050196);
+										  cairo_line_to(cr, x, y - width * 1.154700538379251529018297561004);
+										  cairo_close_path(cr);
+										  cairo_set_source_rgba(cr, r, g, b, a);
+
+										  if (m_bBoundary)
+										  {
+											  cairo_fill_preserve(cr);//留边框填充
+
+											  /* 接下来是画边框 */
+											  cairo_set_line_width(cr, m_dWidth);
+											  cairo_set_source_rgba(cr, r1, g1, b1, a1);
+											  cairo_stroke(cr);
+										  }
+										  else
+										  {
+											  cairo_fill(cr);  //不留边框填充
+										  }
+										  break;
+			}
+			case dmapPointTypeSquare:
+			{
+										cairo_new_sub_path(cr);
+										cairo_move_to(cr, x - width, y - width);
+										cairo_line_to(cr, x - width, y + width);
+										cairo_line_to(cr, x + width, y + width);
+										cairo_line_to(cr, x + width, y - width);
+										cairo_close_path(cr);
+										cairo_set_source_rgb(cr, r, g, b);
+
+										if (m_bBoundary)
+										{
+											cairo_fill_preserve(cr);//留边框填充
+
+											/* 接下来是画边框 */
+											cairo_set_line_width(cr, m_dWidth);
+											cairo_set_source_rgba(cr, r1, g1, b1, a1);
+											cairo_stroke(cr);
+										}
+										else
+										{
+											cairo_fill(cr);  //不留边框填充
+										}
+										break;
+			}
+			case dmapPointTypeStar:
+			{
+									  double  radx[5] = { -7.0534, 7.0534, 11.4127, 0.0000, -11.4127 };
+									  double  rady[5] = { -9.7082, -9.7082, 3.7082, 12.0000, 3.7082 };
+									  double  Radx[5] = { -38.0423, -0.0000, 38.0423, 23.5114, -23.5114 };
+									  double  Rady[5] = { -12.3607, -40.0000, -12.3607, 32.3607, 32.3607 };
+									  cairo_new_sub_path(cr);
+									  double rat = width / 40;
+									  for (int i = 0; i < 5; i++)
+									  {
+										  if (i == 0)
+										  {
+											  cairo_move_to(cr, x + Radx[i] * rat, y + Rady[i] * rat);
+											  cairo_line_to(cr, x + radx[i] * rat, y + rady[i] * rat);
+										  }
+										  else
+										  {
+											  cairo_line_to(cr, x + Radx[i] * rat, y + Rady[i] * rat);
+											  cairo_line_to(cr, x + radx[i] * rat, y + rady[i] * rat);
+										  }
+									  }
+									  cairo_close_path(cr);
+									  cairo_set_source_rgba(cr, r, g, b, a);
+
+									  if (m_bBoundary)
+									  {
+										  cairo_fill_preserve(cr);//留边框填充
+
+										  /* 接下来是画边框 */
+										  cairo_set_line_width(cr, m_dWidth);
+										  cairo_set_source_rgba(cr, r1, g1, b1, a1);
+										  cairo_stroke(cr);
+									  }
+									  else
+									  {
+										  cairo_fill(cr);  //不留边框填充
+									  }
+									  break;
+			}
+			default:
+				break;
+			}
+		}
+		return true;
+	}
+
+	bool SimpleMarkerSymbol::DrawMPOINT(clsCrSurf* pClsCS, clsStruct::LINE* pLine)
+	{
+		int nPoint = pLine->nPoint;
+		clsStruct::POINT* pPoint = pLine->p;
+
+		for (int i = 0; i < nPoint; i++)
+			this->DrawPOINT(pClsCS, pPoint + i);
+		return true;
+	}
+
+
+
+	bool SimpleMarkerSymbol::DrawData(clsCrSurf* clsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
+	{
+		int structType = data->m_iStructType;
+		int iPartCount = data->m_iPartCount;
+
+		clsUtil::DoSetAntialias(m_iAntialiasing, clsCS->m_pCr);
+		switch (structType)
+		{
+		case clsStruct::Struct_Point:
+		{
+										clsStruct::POINT* pPoint = (clsStruct::POINT*)data->m_pData;
+
+										for (int i = 0; i < iPartCount; i++)
+										{
+											this->DrawPOINT(clsCS, pPoint + i);
+										}
+										break;
+		}
+		case clsStruct::Struct_Line:
+		{
+									   for (int i = 0; i < iPartCount; i++)
+									   {
+										   clsStruct::LINE* pMPoint = (clsStruct::LINE*)data->m_pData;
+										   this->DrawMPOINT(clsCS, pMPoint + i);
+									   }
+									   break;
+		}
+		default:
+			break;
+		}
+		return true;
+	}
+
+	bool SimpleMarkerSymbol::DrawData(clsCrSurf* clsCS, DataCollection* data, int dataIndex, char* pFlag)
+	{
+		int structType = data->m_iStructType;
+		int iPartCount = data->m_iPartCount;
+
+		clsUtil::DoSetAntialias(m_iAntialiasing, clsCS->m_pCr);
+		switch (structType)
+		{
+		case clsStruct::Struct_Point:
+		{
+										clsStruct::POINT* pPoint = (clsStruct::POINT*)data->m_pData;
+
+										this->DrawPOINT(clsCS, pPoint + dataIndex);
+										break;
+		}
+		case clsStruct::Struct_Line:
+		{
+									   clsStruct::LINE* pMPoint = (clsStruct::LINE*)data->m_pData;
+									   this->DrawMPOINT(clsCS, pMPoint + dataIndex);
+									   break;
+		}
+		default:
+			break;
+		}
+		return true;
+	}
+
+	bool SimpleMarkerSymbol::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag)
+	{
+		if(layerType != 0)
+			 return false;
+	    pLegendParamater->next(pFlag);
+
+		cairo_t* cr = pClsCS->m_pCr;
+		if(pFlag)
+		{
+ 			cairo_set_source_rgb(cr, 0, 0, 0); //设置画笔颜色，也就是红，绿，蓝，这里设置成绿色。
+        	cairo_select_font_face(cr, pLegendParamater->font.c_str(), 
+				CAIRO_FONT_SLANT_NORMAL, 
+				pLegendParamater->isbold? CAIRO_FONT_WEIGHT_BOLD:CAIRO_FONT_WEIGHT_NORMAL);
+				
+        	cairo_set_font_size(cr, pLegendParamater->fontSize);
+        	cairo_move_to(cr, pLegendParamater->pixXIndex + pLegendParamater->size_x + 10,
+			 pLegendParamater->pixYIndex + pLegendParamater->size_y -3);
+        	cairo_show_text(cr, pFlag);
+		}
+		double x = pLegendParamater->pixXIndex + pLegendParamater->size_x/2;
+		double y = pLegendParamater->pixYIndex + pLegendParamater->size_y/2 - 1 ;
+
+		double width = 0.5 * m_dSize;
+
+		if (m_sPNG != "")
+		{
+			//这样做实现不了边框!!!
+			// 是否该用 png　平铺一样的实现,提供边框
+			cairo_surface_t* image = surfImage;// m_pImage->m_pSurf;
+			if (image == 0)return false;
+			double w = cairo_image_surface_get_width(image);
+			double h = cairo_image_surface_get_height(image);
+			cairo_set_source_surface(cr, image, x - 0.5*w, y - 0.5*h);
+			cairo_paint(cr);
+		}
+		else
+		{
+			switch (m_iType)
+			{
+			case dmapPointTypeCross:
+			{
+									   cairo_move_to(cr, x - width, y);
+									   cairo_line_to(cr, x + width, y);
+									   cairo_move_to(cr, x, y - width);
+									   cairo_line_to(cr, x, y + width);
+									   cairo_set_source_rgba(cr, r, g, b, a);
+									   cairo_set_line_width(cr, 1);
+									   cairo_stroke(cr);
+									   break;
+			}
+			case dmapPointTypeCircle:
+			{
+										cairo_new_path(cr);
+										cairo_arc(cr, x, y, width, 0, 2 * M_PI);
+										cairo_set_source_rgba(cr, r, g, b, a);
+										if (m_bBoundary)
+										{
+											cairo_fill_preserve(cr);//留边框填充
+											/* 接下来是画边框 */
+											cairo_set_line_width(cr, m_dWidth);
+											cairo_set_source_rgba(cr, r1, g1, b1, a1);
+											cairo_stroke(cr);
+										}
+										else
+										{
+											cairo_fill(cr);  //不留边框填充
+										}
+										//cairo_fill(cr);  //不留边框填充
+										break;
+			}
+			case dmapPointTypeTriangle:
+			{
+										  cairo_new_sub_path(cr);
+										  cairo_move_to(cr, x - width, y + width * 0.57735026918962576450914878050196);
+										  cairo_line_to(cr, x + width, y + width * 0.57735026918962576450914878050196);
+										  cairo_line_to(cr, x, y - width * 1.154700538379251529018297561004);
+										  cairo_close_path(cr);
+										  cairo_set_source_rgba(cr, r, g, b, a);
+
+										  if (m_bBoundary)
+										  {
+											  cairo_fill_preserve(cr);//留边框填充
+
+											  /* 接下来是画边框 */
+											  cairo_set_line_width(cr, m_dWidth);
+											  cairo_set_source_rgba(cr, r1, g1, b1, a1);
+											  cairo_stroke(cr);
+										  }
+										  else
+										  {
+											  cairo_fill(cr);  //不留边框填充
+										  }
+										  break;
+			}
+			case dmapPointTypeSquare:
+			{
+										cairo_new_sub_path(cr);
+										cairo_move_to(cr, x - width, y - width);
+										cairo_line_to(cr, x - width, y + width);
+										cairo_line_to(cr, x + width, y + width);
+										cairo_line_to(cr, x + width, y - width);
+										cairo_close_path(cr);
+										cairo_set_source_rgb(cr, r, g, b);
+
+										if (m_bBoundary)
+										{
+											cairo_fill_preserve(cr);//留边框填充
+
+											/* 接下来是画边框 */
+											cairo_set_line_width(cr, m_dWidth);
+											cairo_set_source_rgba(cr, r1, g1, b1, a1);
+											cairo_stroke(cr);
+										}
+										else
+										{
+											cairo_fill(cr);  //不留边框填充
+										}
+										break;
+			}
+			case dmapPointTypeStar:
+			{
+									  double  radx[5] = { -7.0534, 7.0534, 11.4127, 0.0000, -11.4127 };
+									  double  rady[5] = { -9.7082, -9.7082, 3.7082, 12.0000, 3.7082 };
+									  double  Radx[5] = { -38.0423, -0.0000, 38.0423, 23.5114, -23.5114 };
+									  double  Rady[5] = { -12.3607, -40.0000, -12.3607, 32.3607, 32.3607 };
+									  cairo_new_sub_path(cr);
+									  double rat = width / 40;
+									  for (int i = 0; i < 5; i++)
+									  {
+										  if (i == 0)
+										  {
+											  cairo_move_to(cr, x + Radx[i] * rat, y + Rady[i] * rat);
+											  cairo_line_to(cr, x + radx[i] * rat, y + rady[i] * rat);
+										  }
+										  else
+										  {
+											  cairo_line_to(cr, x + Radx[i] * rat, y + Rady[i] * rat);
+											  cairo_line_to(cr, x + radx[i] * rat, y + rady[i] * rat);
+										  }
+									  }
+									  cairo_close_path(cr);
+									  cairo_set_source_rgba(cr, r, g, b, a);
+
+									  if (m_bBoundary)
+									  {
+										  cairo_fill_preserve(cr);//留边框填充
+
+										  /* 接下来是画边框 */
+										  cairo_set_line_width(cr, m_dWidth);
+										  cairo_set_source_rgba(cr, r1, g1, b1, a1);
+										  cairo_stroke(cr);
+									  }
+									  else
+									  {
+										  cairo_fill(cr);  //不留边框填充
+									  }
+									  break;
+			}
+			default:
+				break;
+			}
+		}
+		return true;
+	}
+
+}
\ No newline at end of file

+#pragma once
+#ifndef _SimpleMarkerSymbol_H_
+#define _SimpleMarkerSymbol_H_
+#include<string>
+using namespace std;
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/foreach.hpp>
+//#include<cairo.h>
+#include"clsStruct.h"
+#include"Renderer.h"
+
+namespace DmapCore_30
+{
+	class clsCrSurf;
+	class DataCollection;
+	class CORE_EXPORT SimpleMarkerSymbol :public Renderer
+	{
+	public:
+
+		//没有实现 shadow,需要实现?
+		SimpleMarkerSymbol();
+		~SimpleMarkerSymbol();
+		static SimpleMarkerSymbol* CreateNew();
+		virtual int RendererType();
+		virtual bool DrawData(clsCrSurf* clsCS, DataCollection* data, bool drawSimpleData, char* pFlag = NULL);
+		virtual bool DrawData(clsCrSurf* clsCS, DataCollection* data, int dataIndex, char* pFlag = NULL);
+		virtual bool DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater, int layerType,char* pFlag = NULL);
+		virtual bool Parse(boost::property_tree::ptree &pt, AppendBuffer *f);
+        virtual void ToJson(AppendBuffer* ab);
+
+		bool TryFindHeatRenderer(){ return false; }
+
+
+		int m_iAntialiasing;
+		bool m_bBoundary;
+		unsigned int m_iColor;
+		int m_iType;
+		unsigned int m_iOutline;
+		string m_sPNG;
+		double m_dWidth;  //边框宽度
+		double m_dSize;    //大小
+
+
+		double r, g, b, a;   //填充颜色
+		double r1, g1, b1, a1;  //边框颜色
+
+
+
+		int                      GetAntialiasing();
+		bool                     SetAntialiasing(int bAntialiasing);
+		unsigned int             GetColor();
+		bool                     SetColor(unsigned int color);
+		int                      GetType();
+		bool                     SetType(int type);
+		bool                     GetBoundary();
+		bool                     SetBoundary(bool boundary);
+		unsigned int             GetOutline();
+		bool                     SetOutline(unsigned int outline);
+		const char*              GetPNG();
+		bool                     SetPNG(const char* png);
+		double                   GetWidth();
+		bool                     SetWidth(double width);
+		double                   GetSize();
+		bool                     SetSize(double Size);
+
+
+		/*
+		2015_12_24最新
+		*/
+		bool DrawPOINT(clsCrSurf* clsCS, clsStruct::POINT* pPoint);
+		bool DrawMPOINT(clsCrSurf* clsCr, clsStruct::LINE* pLine);
+
+	private:
+		cairo_surface_t* surfImage = nullptr;
+		//clsCrSurf* m_pImage;
+		/*
+		变量维护:
+		1: 这个变量是 png 构造的surface 的包装类型, 初始为 NULL
+		2.获取 Png surface 后,直接构造一个 m_pImage, destroy 动作交给 析构完成
+		3.每次 SetPNG 时, 只要检测到字符串与当前字符串不一致, Release 前一个, 构造新一个
+		4.绘制图形时,检测到有 m_pImage,并且长宽都不为0(PNG 字符串错误时, 构造 surface 完全正常, 只是长宽为0) , 必然使用PNG 绘制点
+		5. 这样做有一个地方需要注意, 只要该样式中存在PNG 字符串, 想要使用其他点类型是不能实现的, 外界必须将字符串重置为""
+		*/
+	};
+
+}
+
+#endif
\ No newline at end of file

+
+#include "SimplePolygonSymbol.h"
+#include"clsUtil.h"
+#include"clsCrSurf.h"
+#include"clsXML.h"
+#include "clsJson.h"
+#include"clsStruct.h"
+#include "DataCollection.h"
+
+namespace DmapCore_30
+{
+	SimplePolygonSymbol::SimplePolygonSymbol()
+	{
+		m_iAntialiasing = CAIRO_ANTIALIAS_DEFAULT;
+		m_iBackgroundColor = clsUtil::RandomColor();
+		clsUtil::ToCairoColor(m_iBackgroundColor, r, g, b, a);
+		m_iLineType = 0;
+		m_dWidth = 0.3;
+		m_bBoundary = true;
+		m_iBoundaryColor = 0xff000000;
+		clsUtil::ToCairoColor(m_iBoundaryColor, r1, g1, b1, a1);
+		m_sPNG = "";
+		//m_sLinePNG = "";
+		//m_pPattern = NULL;
+		m_pRepeatSurface = NULL;
+		m_iFillType = 0;
+		m_iBoundaryCapType = 0;
+		m_iBoundaryJionType = 0;
+		m_lFillInterval = 25;
+		m_bNeedFill = false;
+		m_bNeedBackground = false;
+		m_iFillColor = 0xff000000;
+		m_simpleRenderer = true;
+		m_iFillsize = 10;
+		m_lCharacter = 33;
+		{
+			memset(m_sUTF8, 0, 5);
+			m_sUTF8[0] = 33;
+		}
+	}
+	SimplePolygonSymbol::~SimplePolygonSymbol()
+	{
+		if (m_pRepeatSurface)
+		{
+			delete m_pRepeatSurface;
+		}
+		if(m_Pattern )
+		{
+			cairo_pattern_destroy(m_Pattern);
+			m_Pattern= nullptr;
+		}
+	}
+	SimplePolygonSymbol* SimplePolygonSymbol::CreateNew()
+	{
+		SimplePolygonSymbol * dest = new SimplePolygonSymbol();
+		return dest;
+	}
+
+
+	int SimplePolygonSymbol::RendererType()
+	{
+		return dmapSimplePolygonSymbol;
+	}
+
+	bool SimplePolygonSymbol::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
+	{
+		//公有属性 iFillType antialiasing fillcolor filltransparency boundary
+		//有属性 m_sPNG
+		//如果有边框  有属性 boundarywidth,boundarycolor,boundarytype,boundarytransparency
+
+
+		clsXML clsX(f, "SIMPLEPOLYGONSYMBOL");
+		clsXML::ParseEnum("antialiasing", pt, f, &m_iAntialiasing, "antialias_default", "antialias_none", "antialias_gray", "antialias_subpixel", "antialias_fase", "antialias_good", "antialias_best", "true", "false");
+		clsXML::XMLAttrParse(pt, f, &m_sPNG, "icon");
+
+		clsXML::XMLAttrParse(pt, f, &m_bBoundary, "boundary");
+		clsXML::XMLAttrParse(pt, f, &m_dWidth, "width");
+		clsXML::ParseEnum("linetype", pt, f, &m_iLineType, "solid", "dash", "dot", "dash_dot", "dash_dot_dot");
+		clsXML::XMLAttrParseColor(pt, f, &m_iBoundaryColor, "boundarycolor", "boundarytransparency");
+		clsXML::XMLAttrParse(pt, f, &m_lFillInterval, "fillinterval");
+		
+		clsXML::ParseEnum("filltype", pt, f, &m_iFillType, "solid", "bdiagonal", "fdiagonal", "cross", "diagcross", "horizontal", "vertical", "gray", "lightgray", "darkgray", "icon", "character");
+		
+		
+		clsXML::XMLAttrParse(pt, f, &m_bNeedFill, "needfill");
+		clsXML::XMLAttrParseColor(pt, f, &m_iFillColor, "fillcolor", "filltransparency");
+
+		clsXML::XMLAttrParse(pt, f, &m_bNeedBackground, "needbackground");
+	    clsXML::XMLAttrParseColor(pt, f, &m_iBackgroundColor, "backgroundcolor", "backgroundtransparency");
+      
+	    clsXML::XMLAttrParse(pt, f, &m_iFillsize, "fillsize"); 
+		clsXML::XMLAttrParse(pt, f, &m_diagalignment, "diagalignment");
+
+		if(m_iFillType == dmapFillTypeCharacter)
+		{
+			clsXML::XMLAttrParse(pt, f, &m_lCharacter, "character");
+			clsXML::XMLAttrParse(pt, f, &m_sFont, "font");
+			clsXML::XMLAttrParse(pt, f, &m_sFontname, "fontname");
+
+			if(m_sFont == "" || m_sFontname == "")
+			{
+				m_bNeedFill = false;
+			}
+
+			if (m_iFillType == dmapFillTypeCharacter)
+			{
+				this->SetCharacter(m_lCharacter);
+			}
+		}
+		
+
+		{
+			clsUtil::ToCairoColor(m_iFillColor, r, g, b, a);
+			clsUtil::ToCairoColor(m_iBoundaryColor, r1, g1, b1, a1);
+			clsUtil::ToCairoColor(m_iBackgroundColor, r_b, g_b, b_b, a_b);
+			
+			this->SetFillType(m_iFillType);
+			if (m_sPNG != "")
+			{
+				
+				if(m_sPNG.find("symbollib") == string::npos && m_sPNG.find("/")!=0 && m_sPNG.find(".")!=0)
+				{
+					 m_sJDPNG = GetFilePath("../symbollib/" + m_sPNG);
+				}
+				this->SetPNG(m_sJDPNG.c_str());
+			}
+		}
+		return true; 
+	}
+	void SimplePolygonSymbol::ToJson(AppendBuffer *ab)
+	{
+		char buff[300] = {0};
+		char resultbuff[5000] = {0};
+		strcat(resultbuff, R"("SIMPLEPOLYGONSYMBOL":{"antialiasing":"antialias_default",)");
+		clsJson::JsonAttrParse("icon", resultbuff, buff, this->m_sPNG);
+		clsJson::ParseEnum("filltype", resultbuff, buff, m_iFillType, "solid", "bdiagonal", "fdiagonal", "cross", "diagcross", "horizontal", "vertical", "gray", "lightgray", "darkgray", "icon","character" ),
+		clsJson::JsonAttrParseColor("fillcolor", "filltransparency", resultbuff, buff, m_iFillColor);
+
+		clsJson::JsonAttrParse("boundary", resultbuff, buff, m_bBoundary);
+		clsJson::JsonAttrParse("width", resultbuff, buff, m_dWidth);
+		clsJson::ParseEnum("linetype", resultbuff, buff, m_iLineType, "solid", "dash", "dot", "dash_dot", "dash_dot_dot");
+		clsJson::JsonAttrParseColor("boundarycolor", "boundarytransparency", resultbuff, buff, m_iBoundaryColor);
+		clsJson::JsonAttrParse("fillinterval", resultbuff, buff, m_lFillInterval);
+		clsJson::JsonAttrParse("needfill", resultbuff, buff, m_bNeedFill);
+
+		clsJson::JsonAttrParse("needbackground", resultbuff, buff, m_bNeedBackground);
+		clsJson::JsonAttrParseColor("backgroundcolor", "backgroundtransparency", resultbuff, buff, m_iBackgroundColor);
+
+		clsJson::JsonAttrParse("fillsize", resultbuff, buff, m_iFillsize);
+
+		clsJson::JsonAttrParse("diagalignment", resultbuff, buff, m_diagalignment);
+		if(m_iFillType == dmapFillTypeCharacter)
+		{
+			clsJson::JsonAttrParse("character", resultbuff, buff, m_lCharacter);
+			clsJson::JsonAttrParse("font", resultbuff, buff, m_sFont);
+			clsJson::JsonAttrParse("fontname", resultbuff, buff, m_sFontname);
+		}
+		
+		clsJson::JsonAttrEnd(resultbuff);
+		ab->AppendString(resultbuff);
+	}
+
+	bool   SimplePolygonSymbol::SetCharacter(long lCharacter)
+	{
+		m_lCharacter = lCharacter;
+		memset(m_sUTF8, 0, 5);
+		if (lCharacter < 256)
+		{
+			m_sUTF8[0] = ((char*)(&lCharacter))[0];
+		}
+		else
+		{
+			m_sUTF8[0] = ((char*)(&m_lCharacter))[1];
+			m_sUTF8[1] = ((char*)(&m_lCharacter))[0];
+		}
+		
+		int flag = this->GetRepeatSurface();  //尝试用 PNG 构造 surface
+		if (flag == false)  //这里只有 png 构造错误的情况下返回 false
+		{
+			m_sPNG = "";  //注意 png 字符串重置
+			return false;
+		}
+		return true;
+	}
+
+	int                     SimplePolygonSymbol::GetAntialiasing()
+	{
+		return  m_iAntialiasing;
+	}
+	bool                    SimplePolygonSymbol::SetAntialiasing(int newVal)
+	{
+		m_iAntialiasing = (newVal);
+		//重新构造平铺模型
+		this->SetFillType(m_iFillType);
+		return true;
+	}
+	unsigned int              SimplePolygonSymbol::GetColor()
+	{
+		return  m_iFillColor;
+	}
+	bool                 SimplePolygonSymbol::SetColor(unsigned int color)
+	{
+		m_iFillColor = color;
+		clsUtil::ToCairoColor(color, r, g, b, a);
+		//重新构造平铺模型?
+		this->SetFillType(m_iFillType);
+		return true;
+	}
+	int               SimplePolygonSymbol::GetLineType()
+	{
+		return  m_iLineType;
+	}
+	bool                 SimplePolygonSymbol::SetLineType(int type)
+	{
+		m_iLineType = type;
+		return true;
+	}
+	const char*               SimplePolygonSymbol::GetPNG()
+	{
+		return  m_sPNG.c_str();
+	}
+	bool                 SimplePolygonSymbol::SetPNG(const char* png)
+	{
+		if (png == 0)m_sPNG = "";
+		//else m_sPNG = png;
+		int flag = this->GetRepeatSurface();  //尝试用 PNG 构造 surface
+		if (flag == false)  //这里只有 png 构造错误的情况下返回 false
+		{
+			m_sPNG = "";  //注意 png 字符串重置
+			return false;
+		}
+		if (m_pRepeatSurface == NULL)
+			return true;
+
+		cairo_surface_t* surface = m_pRepeatSurface->m_pSurf;
+		cairo_pattern_t* pattern = cairo_pattern_create_for_surface(surface);
+
+		/*
+		delete 查下资料, 千万不能出错
+		*/
+		cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);   //平铺模板
+		cairo_matrix_t   matrix;
+		
+
+		cairo_matrix_init_scale(&matrix, 1, 1);    //平铺模型,转换模型 , 表示长宽都是 1倍的图片大小, 不缩放
+		cairo_pattern_set_matrix(pattern, &matrix);
+
+		if(m_Pattern )
+		{
+			cairo_pattern_destroy(m_Pattern);
+			m_Pattern= nullptr;
+		}
+		m_Pattern = pattern;
+
+		return true;
+	}
+	double               SimplePolygonSymbol::GetWidth()
+	{
+		return  m_dWidth;
+	}
+	bool                 SimplePolygonSymbol::SetWidth(double width)
+	{
+
+		if (width < 0)return false;
+		m_dWidth = (width);
+		return true;
+	}
+	bool                 SimplePolygonSymbol::GetBoundary()
+	{
+
+		return  m_bBoundary;
+	}
+	bool                 SimplePolygonSymbol::SetBoundary(bool boundary)
+	{
+		m_bBoundary = (boundary);
+		return true;
+	}
+	unsigned int                  SimplePolygonSymbol::GetBoundaryColor()
+	{
+		return  m_iBoundaryColor;
+	}
+	bool                 SimplePolygonSymbol::SetBoundaryColor(unsigned int boundaryColor)
+	{
+		m_iBoundaryColor = (boundaryColor);
+		clsUtil::ToCairoColor(boundaryColor, r1, g1, b1, a1);
+		return true;
+	}
+	//const char*              SimplePolygonSymbol::GetLinePNG()
+	//{
+	//	return m_sLinePNG.c_str();
+	//}
+	//bool                     SimplePolygonSymbol::SetLinePNG(const char* png)
+	//{
+	//	m_sLinePNG = png;
+	//	return true;
+	//}
+	int                      SimplePolygonSymbol::GetFillType()
+	{
+		return m_iFillType;
+	}
+	bool                     SimplePolygonSymbol::SetFillType(int iFillType)
+	{
+		m_iFillType = iFillType;
+
+		//尝试构造 平铺 surface,如果不为 NULL, 构造 pattern
+		if (m_sPNG != "")
+			return true;   //如果有PNG 字段,无需构造,使用 PNG 平铺
+
+		if ((iFillType == dmapFillTypeSolid) || (iFillType == dmapFillTypeGray) || (iFillType == dmapFillTypeLightGray) || (iFillType == dmapFillTypeDarkGray))
+		{
+			//如果是三种纯色填充,重置平铺pattern
+			if(m_Pattern )
+		    {
+			    cairo_pattern_destroy(m_Pattern);
+			     m_Pattern= nullptr;
+		     }
+		     m_Pattern = nullptr;
+			if (m_pRepeatSurface)
+			{
+				delete m_pRepeatSurface;
+				m_pRepeatSurface = NULL;
+			}
+		}
+		this->GetRepeatSurface(); // 返回值无用
+
+		if (m_pRepeatSurface == NULL)
+			return true;             // 如果构造出的为 NULL, 使用颜色填充, 如果 filltype 为 灰色等,需要在画图的时候进一步处理
+
+
+		cairo_surface_t* surface = m_pRepeatSurface->m_pSurf;
+		cairo_pattern_t* pattern = cairo_pattern_create_for_surface(surface);
+		cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);   //平铺模板
+		cairo_matrix_t   matrix;
+		cairo_matrix_init_scale(&matrix, 1, 1);    //平铺模型,转换模型 , 表示长宽都是 1倍的图片大小, 不缩放
+		cairo_pattern_set_matrix(pattern, &matrix);
+		if(m_Pattern )
+		{
+			cairo_pattern_destroy(m_Pattern);
+			m_Pattern= nullptr;
+		}
+		m_Pattern = pattern;
+		
+		return true;
+	}
+
+	int                      SimplePolygonSymbol::GetBoundaryCapType()
+	{
+		return m_iBoundaryCapType;
+	}
+	bool                     SimplePolygonSymbol::SetBoundaryCapType(int iBoundaryCapType)
+	{
+		m_iBoundaryCapType = iBoundaryCapType;
+		return true;
+	}
+	int                      SimplePolygonSymbol::GetBoundaryJionType()
+	{
+		return m_iBoundaryJionType;
+	}
+	bool                     SimplePolygonSymbol::SetBoundaryJionType(int iBoundaryJionType)
+	{
+		m_iBoundaryJionType = iBoundaryJionType;
+		return true;
+	}
+	long                     SimplePolygonSymbol::GetFillInterval()
+	{
+		return m_lFillInterval;
+	}
+	bool                     SimplePolygonSymbol::SetFillInterval(long lFillInterval)
+	{
+		m_lFillInterval = lFillInterval;
+		this->SetFillType(m_iFillType);
+		return true;
+	}
+	bool                     SimplePolygonSymbol::GetNeedFill()
+	{
+		return m_bNeedFill;
+	}
+	bool                     SimplePolygonSymbol::SetNeedFill(bool bNeedFill)
+	{
+		m_bNeedFill = bNeedFill;
+		return true;
+	}
+
+
+
+    bool SimplePolygonSymbol::SetBackground(cairo_t* cr,double dSurfW,double dSurfH)
+	{
+		if(m_bNeedBackground)
+		{
+			double r = 0, g = 0, b = 0, a = 1;
+			clsUtil::ToCairoColor(m_iBackgroundColor, r, g, b, a);						
+			cairo_set_source_rgba(cr, r, g, b, a);
+			cairo_rectangle (cr, 0, 0, dSurfW, dSurfH);
+			cairo_fill(cr);
+			return true;
+		}
+		return false;
+	}
+
+	//注意, 这里是有可能PNG路径错误
+	//此函数只做一件事, 构造 平铺需要的 surface,构造出来的 surface　保存在类变量　m_pRepeatSurface 中
+	//此函数必然重置 m_pRepeatSurface ,不使用平铺则为NULL
+	//这里的返回值只有一个作用, 就是 png 路径错误返回 false, 但 构造的 surface 同样不为 NULL
+#define G2  1.4142135623730950488016887242097
+	bool SimplePolygonSymbol::GetRepeatSurface()
+	{
+		if (m_pRepeatSurface) //这个判定可靠吗???  不存在必然是 NULL吗? PNG 构造时路径错误,也不为NULL,销毁是否能正常执行?
+		{
+			m_pRepeatSurface->Release();
+			m_pRepeatSurface = NULL;
+		}
+
+		if (m_sPNG != "")
+		{
+			cairo_surface_t *image_surface = cairo_image_surface_create_from_png(m_sJDPNG.c_str());
+            clsCrSurf mClsSurfDC(image_surface);
+			double w = cairo_image_surface_get_width(image_surface);
+		    double h = cairo_image_surface_get_height(image_surface);
+
+			if(w ==0 || h == 0)
+			{
+				cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 100, 100);
+				m_pRepeatSurface = new clsCrSurf(surface);
+				cairo_t *cr = m_pRepeatSurface->m_pCr;
+				this->SetBackground( m_pRepeatSurface->m_pCr,100, 100);
+				return true;
+			}
+
+			double size = 5 + max(w,h)  + m_lFillInterval;
+
+			if (m_diagalignment)
+			{
+
+				cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, size*2, size * 2 );
+				if (m_pRepeatSurface)
+				{
+					delete m_pRepeatSurface;
+					m_pRepeatSurface = 0;
+				}
+				m_pRepeatSurface = new clsCrSurf(surface);
+				cairo_t *cr = m_pRepeatSurface->m_pCr;
+
+				this->SetBackground(cr,size*2, size * 2);
+
+				cairo_set_source_surface(cr, image_surface,2, 2 + m_iFillsize);
+			    cairo_paint(cr);
+
+				cairo_set_source_surface(cr, image_surface,2, 2 + m_iFillsize);
+			    cairo_paint(cr);
+				return true;
+			}
+			else
+			{
+				
+				cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, size, size);
+				if (m_pRepeatSurface)
+				{
+					delete m_pRepeatSurface;
+					m_pRepeatSurface = 0;
+				}
+				m_pRepeatSurface = new clsCrSurf(surface);
+				cairo_t *cr = m_pRepeatSurface->m_pCr;
+
+				this->SetBackground(cr,size, size);
+
+				cairo_set_source_surface(cr, image_surface,2, 2 + m_iFillsize);
+			    cairo_paint(cr);
+				return true;
+			}
+
+                
+		}
+
+		if (m_iFillType == dmapFillTypeCharacter)
+		{
+			if (m_diagalignment)
+			{
+				int size = 5 + m_iFillsize + m_lFillInterval;
+
+				cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, size*2, size * 2 );
+				if (m_pRepeatSurface)
+				{
+					delete m_pRepeatSurface;
+					m_pRepeatSurface = 0;
+				}
+				m_pRepeatSurface = new clsCrSurf(surface);
+				cairo_t *cr = m_pRepeatSurface->m_pCr;
+
+				this->SetBackground(cr,size*2, size * 2);
+
+				double r = 0, g = 0, b = 0, a = 1;
+				clsUtil::ToCairoColor(m_iFillColor, r, g, b, a);
+				cairo_set_source_rgba(cr, r, g, b, a);
+				cairo_select_font_face(cr, m_sFont.c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
+				cairo_set_font_size(cr, m_iFillsize);
+
+				cairo_move_to(cr, 2, 2 + m_iFillsize);
+				cairo_show_text(cr, m_sUTF8);
+
+				cairo_move_to(cr, 2+ size, 2 + m_iFillsize + size);
+				cairo_show_text(cr, m_sUTF8);
+
+				return true;
+			}
+			else
+			{
+				int size = 5 + m_iFillsize + m_lFillInterval;
+
+				cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, size, size);
+				if (m_pRepeatSurface)
+				{
+					delete m_pRepeatSurface;
+					m_pRepeatSurface = 0;
+				}
+				m_pRepeatSurface = new clsCrSurf(surface);
+				cairo_t *cr = m_pRepeatSurface->m_pCr;
+
+				this->SetBackground(cr,size, size);
+
+				double r = 0, g = 0, b = 0, a = 1;
+				clsUtil::ToCairoColor(m_iFillColor, r, g, b, a);
+				cairo_set_source_rgba(cr, r, g, b, a);
+				cairo_select_font_face(cr, m_sFont.c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
+				cairo_set_font_size(cr, m_iFillsize);
+				cairo_move_to(cr, 2, 2 + m_iFillsize);
+				cairo_show_text(cr, m_sUTF8);
+				return true;
+			}
+		}
+
+		if(m_lFillInterval==0)m_lFillInterval=1;
+		if (m_iFillType == dmapFillTypeBDiagonal ||
+		    m_iFillType == dmapFillTypeFDiagonal || 
+			m_iFillType == dmapFillTypeCross || 
+			m_iFillType == dmapFillTypeDiagCross || 
+			m_iFillType == dmapFillTypeHorizontal || 
+			m_iFillType == dmapFillTypeVertical)
+		{
+			if (m_lFillInterval == 0)
+			{
+				cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 100, 100);
+				if (m_pRepeatSurface)
+				{
+					delete m_pRepeatSurface;
+					m_pRepeatSurface = 0;
+				}
+				m_pRepeatSurface = new clsCrSurf(surface);
+				cairo_t* cr = m_pRepeatSurface->m_pCr;
+				cairo_set_source_rgba(cr, 0, 0, 0, 1);
+				cairo_fill(cr);
+				return true;
+			}
+		}
+
+		
+
+		if(m_iFillType == dmapFillTypeBDiagonal || 
+		   m_iFillType == dmapFillTypeFDiagonal || 
+		   m_iFillType == dmapFillTypeCross || 
+		   m_iFillType == dmapFillTypeDiagCross || 
+		   m_iFillType == dmapFillTypeHorizontal || 
+		   m_iFillType == dmapFillTypeVertical
+		){
+
+
+		double dLineWidth = 2;
+		double m = 25;
+		int n = 10;
+		m = m_lFillInterval;
+
+		n = (int) (128/ (m_lFillInterval + dLineWidth));
+		m = 128.0/n - dLineWidth;
+
+		double dSurfW = 128;
+	    double dSurfH = 128;
+
+		cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, (int)dSurfW, (int)dSurfH);
+		//cairo_surface_t* surface = cairo_pdf_surface_create_for_stream(nullptr,nullptr, (int)dSurfW, (int)dSurfH);
+	    if (m_pRepeatSurface)
+		{
+			 delete m_pRepeatSurface;
+			 m_pRepeatSurface = 0;
+		}
+		 m_pRepeatSurface = new clsCrSurf(surface);
+		cairo_t* cr = m_pRepeatSurface->m_pCr;
+		cairo_set_antialias(cr, (cairo_antialias_t)m_iAntialiasing);
+		
+		this->SetBackground(cr,dSurfW, dSurfH);
+		
+
+		
+
+		
+		double x, y;
+		double x_dis, y_dis;
+
+		switch (m_iFillType)
+		{
+			//构造 100*100的画布,做平铺使用
+		case dmapFillTypeBDiagonal:
+		{
+				for (int i = 0; i <= 2*n; i++)
+				{
+					x = -1;
+					y = i* (m + dLineWidth) +1;
+					x_dis = y;
+				    y_dis = -x_dis;
+				    cairo_move_to(cr, x, y);
+					cairo_rel_line_to(cr, x_dis, y_dis);
+				}
+				
+									 /* for (int i = 0; i < n; i++)
+									  {
+										  x = dLineWidth*G2 / 2 + i*G2 *(m + dLineWidth);
+										  y = dSurfH;
+										  x_dis = dSurfH - x;
+										  y_dis = -x_dis;
+										  cairo_move_to(cr, x, y);
+										  cairo_rel_line_to(cr, x_dis, y_dis);
+									  }*/
+
+									  /*for (int i = 0; i < n; i++)
+									  {
+										  x = 0;
+										  y = i*G2*(m + dLineWidth) + dLineWidth*G2 / 2  ;
+										  x_dis = y;
+										  y_dis = -x_dis;
+										  cairo_move_to(cr, x, y);
+										  cairo_rel_line_to(cr, x_dis, y_dis);
+									  }*/
+									  break;
+		}
+		case dmapFillTypeFDiagonal:
+		{
+			for (int i = 0; i <= 2*n; i++)
+				{
+					x = -1 - dSurfW + i* (m + dLineWidth);
+					y = -1;
+					x_dis = dSurfW + 2;
+				    y_dis = dSurfW + 2;
+				    cairo_move_to(cr, x, y);
+					cairo_rel_line_to(cr, x_dis, y_dis);
+				}
+
+
+									 /* for (int i = 0; i < n; i++)
+									  {
+										  x = dLineWidth*G2 / 2 + i*G2 *(m + dLineWidth);
+										  y = 0;
+										  x_dis = dSurfH - x;
+										  y_dis = x_dis;
+										  cairo_move_to(cr, x, y);
+										  cairo_rel_line_to(cr, x_dis, y_dis);
+									  }
+									  for (int i = 0; i < n; i++)
+									  {
+										  x = 0;
+										  y = dSurfH - i*G2*(m + dLineWidth) - dLineWidth*G2 / 2;
+										  x_dis = dSurfH - y;
+										  y_dis = x_dis;
+										  cairo_move_to(cr, x, y);
+										  cairo_rel_line_to(cr, x_dis, y_dis);
+									  }*/
+
+									  break;
+		}
+
+		case dmapFillTypeCross:
+		{
+								  for (int i = 0; i < n; i++)
+								  {
+									  x = dLineWidth / 2 + i *(m + dLineWidth);
+									  y = 0;
+									  x_dis = 0;
+									  y_dis = dSurfH;
+									  cairo_move_to(cr, x, y);
+									  cairo_rel_line_to(cr, x_dis, y_dis);
+								  }
+								  for (int i = 0; i < n; i++)
+								  {
+									  x = 0;
+									  y = i*(m + dLineWidth) + dLineWidth / 2;
+									  x_dis = dSurfW;
+									  y_dis = 0;
+									  cairo_move_to(cr, x, y);
+									  cairo_rel_line_to(cr, x_dis, y_dis);
+								  }
+								  break;
+		}
+		case dmapFillTypeDiagCross:
+		{
+			for (int i = 0; i <= 2*n; i++)
+				{
+					x = -1;
+					y = i* (m + dLineWidth) +1;
+					x_dis = y;
+				    y_dis = -x_dis;
+				    cairo_move_to(cr, x, y);
+					cairo_rel_line_to(cr, x_dis, y_dis);
+				}
+					for (int i = 0; i <= 2*n; i++)
+				{
+					x = -1 - dSurfW + i* (m + dLineWidth);
+					y = -1;
+					x_dis = dSurfW + 2;
+				    y_dis = dSurfW + 2;
+				    cairo_move_to(cr, x, y);
+					cairo_rel_line_to(cr, x_dis, y_dis);
+				}
+
+									/*  for (int i = 0; i < n; i++)
+									  {
+										  x = dLineWidth*G2 / 2 + i*G2 *(m + dLineWidth);
+										  y = dSurfH;
+										  x_dis = dSurfH - x;
+										  y_dis = -x_dis;
+										  cairo_move_to(cr, x, y);
+										  cairo_rel_line_to(cr, x_dis, y_dis);
+									  }
+									  for (int i = 0; i < n; i++)
+									  {
+										  x = 0;
+										  y = i*G2*(m + dLineWidth) + dLineWidth*G2 / 2;
+										  x_dis = y;
+										  y_dis = -x_dis;
+										  cairo_move_to(cr, x, y);
+										  cairo_rel_line_to(cr, x_dis, y_dis);
+									  }
+									  for (int i = 0; i < n; i++)
+									  {
+										  x = dLineWidth*G2 / 2 + i*G2 *(m + dLineWidth);
+										  y = 0;
+										  x_dis = dSurfH - x;
+										  y_dis = x_dis;
+										  cairo_move_to(cr, x, y);
+										  cairo_rel_line_to(cr, x_dis, y_dis);
+									  }
+									  for (int i = 0; i < n; i++)
+									  {
+										  x = 0;
+										  y = dSurfH - i*G2*(m + dLineWidth) - dLineWidth*G2 / 2;
+										  x_dis = dSurfH - y;
+										  y_dis = x_dis;
+										  cairo_move_to(cr, x, y);
+										  cairo_rel_line_to(cr, x_dis, y_dis);
+									  }*/
+
+									  break;
+		}
+		case dmapFillTypeHorizontal:
+		{
+									   for (int i = 0; i < n; i++)
+									   {
+										   x = 0;
+										   y = i*(m + dLineWidth) + dLineWidth / 2;
+										   x_dis = dSurfW;
+										   y_dis = 0;
+										   cairo_move_to(cr, x, y);
+										   cairo_rel_line_to(cr, x_dis, y_dis);
+									   }
+									   break;
+		}
+		case dmapFillTypeVertical:
+		{
+									
+									 for (int i = 0; i < n; i++)
+									 {
+										 x = dLineWidth / 2 + i *(m + dLineWidth);
+										 y = 0;
+										 x_dis = 0;
+										 y_dis = dSurfH;
+										 cairo_move_to(cr, x, y);
+										 cairo_rel_line_to(cr, x_dis, y_dis);
+									 }
+									
+									 break;
+		}
+		default:
+			break;
+		}
+
+		 double r = 0, g = 0, b = 0, a = 1;
+									 clsUtil::ToCairoColor(m_iFillColor, r, g, b, a);
+									 cairo_set_line_width(cr, dLineWidth);
+									 cairo_set_source_rgba(cr, r, g, b, a);
+									 cairo_stroke(cr);
+
+
+		}
+	 
+
+		
+		
+		return true;
+	}
+#undef G2
+
+	//这里的指针是一个环
+	bool SimplePolygonSymbol::DrawRING(clsCrSurf* clsCS, clsStruct::LINE* pRing)
+	{
+		cairo_t* cr = clsCS->m_pCr;
+		clsUtil::DoSetAntialias(m_iAntialiasing, cr);
+		if(pRing ==NULL || pRing->p == NULL)
+			return false;
+		int nPoint = pRing->nPoint;
+		clsStruct::POINT* pPoint = pRing->p;
+		cairo_new_path(cr);
+		for (int i = 0; i < nPoint; i++)
+		{
+			double x = pPoint[i].x;
+			double y = pPoint[i].y;
+
+			if (i == 0)
+			{
+				cairo_move_to(cr, x, y);
+			}
+
+			else if (i == nPoint - 1)
+				cairo_close_path(cr);
+			else
+				cairo_line_to(cr, x, y);
+		}
+
+
+		//加一块不需要填充的部分
+		if (!m_bNeedFill )
+		{
+			if(m_bNeedBackground)
+			{
+				cairo_set_source_rgba(cr, r_b, g_b, b_b, a_b);
+			}
+
+			if (m_bBoundary)
+			{
+				clsUtil::DoSetLineType(m_iLineType, cr);
+				cairo_set_source_rgba(cr, r1, g1, b1, a1);
+				cairo_set_line_width(cr, m_dWidth);
+				cairo_set_line_cap(cr, (cairo_line_cap_t)m_iBoundaryCapType);
+				cairo_set_line_join(cr, (cairo_line_join_t)m_iBoundaryJionType);
+				cairo_stroke(cr);
+			}
+			return true;
+		}
+
+		if(m_bNeedBackground)
+		{
+			cairo_set_source_rgba(cr, r_b, g_b, b_b, a_b);
+		}
+
+		if (m_Pattern)
+		{
+			cairo_set_source(cr, m_Pattern);
+		}
+		//此处需要进一步判断是哪种 纯颜色填充
+		//这里只考虑纯颜色填充的四种填充方式
+		switch (m_iFillType)
+		{
+		case dmapFillTypeSolid:
+			cairo_set_source_rgba(cr, r, g, b, a);
+			break;
+		case dmapFillTypeGray:
+		{
+								 //灰色颜色为 169 169 169
+								 double r_, g_, b_;
+								 r_ = g_ = b_ = ((double)169) / 255;
+								 cairo_set_source_rgba(cr, r_, g_, b_, 1.0);
+								 break;
+		}
+		case dmapFillTypeLightGray:
+		{
+									  //浅灰色颜色为 211 211 211
+									  double r_, g_, b_;
+									  r_ = g_ = b_ = ((double)211) / 255;
+									  cairo_set_source_rgba(cr, r_, g_, b_, 1.0);
+									  break;
+		}
+		case dmapFillTypeDarkGray:
+		{
+									 //深灰色颜色为 128 128 128
+									 double r_, g_, b_;
+									 r_ = g_ = b_ = ((double)128) / 255;
+									 cairo_set_source_rgba(cr, r_, g_, b_, 1.0);
+									 break;
+		}
+		default:
+			return false; // 这里表示已出错
+			break;
+		}
+		if (m_bBoundary)
+		{
+			cairo_fill_preserve(cr);
+			clsUtil::DoSetLineType(m_iLineType, cr);
+			cairo_set_source_rgba(cr, r1, g1, b1, a1);
+			cairo_set_line_width(cr, m_dWidth);
+			cairo_set_line_cap(cr, (cairo_line_cap_t)m_iBoundaryCapType);
+			cairo_set_line_join(cr, (cairo_line_join_t)m_iBoundaryJionType);
+			cairo_stroke(cr);
+		}
+		else
+		{
+			cairo_fill(cr);
+		}
+
+		return true;
+	}
+	bool SimplePolygonSymbol::DrawPOLYGON(clsCrSurf* clsCS, clsStruct::POLYGON* pPolygon)
+	{
+		cairo_t* cr = clsCS->m_pCr;
+
+		//这个结构会用???
+		return true;
+	}
+	bool SimplePolygonSymbol::DrawMPOLYGON(clsCrSurf* clsCS, clsStruct::MPOLYGON* pMPolygon)
+	{
+		cairo_t* cr = clsCS->m_pCr;
+		clsUtil::DoSetAntialias(m_iAntialiasing, cr);
+		if(pMPolygon ==NULL || pMPolygon->p == NULL)
+			return false;
+		int nPolygon = pMPolygon->nPolygon;
+		clsStruct::POLYGON* pPolygon = pMPolygon->p;
+
+		cairo_new_path(cr);
+		for (int i = 0; i < nPolygon; i++)
+		{
+			int nRing = pPolygon[i].nRing;
+			clsStruct::LINE* pRing = pPolygon[i].p;
+			if(pRing == NULL)continue;
+			for (int j = 0; j < nRing; j++)
+			{
+				int nPoint = pRing[j].nPoint;
+				clsStruct::POINT* pPoint = pRing[j].p;
+				if(pPoint == NULL)continue;
+				if(nPoint == 1)
+				{//小比例尺 
+					if (m_bBoundary)
+					{
+						double x = pPoint[0].x;
+						double y = pPoint[0].y;
+						cairo_new_path(cr);
+						cairo_arc(cr, x, y, 1.3, 0, 2 * M_PI); 
+						cairo_set_source_rgba(cr, r1, g1, b1, a1);
+						//cairo_set_source_rgba(cr, r, g, b, a);
+						cairo_fill(cr);
+						return true;
+					}
+					else if(m_bNeedBackground)
+					{
+						double x = pPoint[0].x;
+						double y = pPoint[0].y;
+						cairo_new_path(cr);
+						cairo_arc(cr, x, y, 1.3, 0, 2 * M_PI);
+						//cairo_set_source_rgba(cr, r1, g1, b1, a1);
+					    cairo_set_source_rgba(cr, r_b, g_b, b_b, a_b);
+						cairo_fill(cr);
+						return true;
+					}
+					
+				}
+				else
+				{
+					for (int k = 0; k < nPoint; k++)
+					{
+						double x = pPoint[k].x;
+						double y = pPoint[k].y;
+
+						if (k == 0)
+						{
+							cairo_move_to(cr, x, y);
+						}
+						else if (k == nPoint - 1)
+							cairo_close_path(cr);
+						else
+							cairo_line_to(cr, x, y);
+					}
+				}
+			}
+		}
+
+		
+
+
+		/*
+		加一块不需要填充的部分
+		*/
+		if (!m_bNeedFill)
+		{
+			if(m_bNeedBackground)
+			{
+				cairo_set_source_rgba(cr, r_b, g_b, b_b, a_b);
+				cairo_fill_preserve(cr);
+			}
+
+			if (m_bBoundary)
+			{
+				clsUtil::DoSetLineType(m_iLineType, cr);
+				cairo_set_source_rgba(cr, r1, g1, b1, a1);
+				cairo_set_line_width(cr, m_dWidth);
+				cairo_set_line_cap(cr, (cairo_line_cap_t)m_iBoundaryCapType);
+				cairo_set_line_join(cr, (cairo_line_join_t)m_iBoundaryJionType);
+				cairo_stroke(cr);
+			}
+			return true;
+		}
+
+
+		//cairo_set_source_rgba(cr, 1, 0.5, 0.5, 0.5);
+		//cairo_fill_preserve(cr);
+
+		
+		/*
+		接下来是对应各种样式, 填充
+		*/
+		cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
+		if (m_Pattern)
+		{
+			cairo_set_source(cr, m_Pattern);
+		}
+		else
+		{
+			//此处需要进一步判断是哪种 纯颜色填充
+			//这里只考虑纯颜色填充的四种填充方式
+			switch (m_iFillType)
+			{
+			case dmapFillTypeSolid:
+				cairo_set_source_rgba(cr, r, g, b, a);
+				break;
+			case dmapFillTypeGray:
+			{
+									 //灰色颜色为 169 169 169
+									 double r_, g_, b_;
+									 r_ = g_ = b_ = ((double)169) / 255;
+									 cairo_set_source_rgba(cr, r_, g_, b_, 1.0);
+									 break;
+			}
+			case dmapFillTypeLightGray:
+			{
+										  //浅灰色颜色为 211 211 211
+										  double r_, g_, b_;
+										  r_ = g_ = b_ = ((double)211) / 255;
+										  cairo_set_source_rgba(cr, r_, g_, b_, 1.0);
+										  break;
+			}
+			case dmapFillTypeDarkGray:
+			{
+										 //深灰色颜色为 128 128 128
+										 double r_, g_, b_;
+										 r_ = g_ = b_ = ((double)128) / 255;
+										 cairo_set_source_rgba(cr, r_, g_, b_, 1.0);
+										 break;
+			}
+			default:
+				return false; // 这里表示已出错
+				break;
+			}
+		}
+		if (m_bBoundary)
+		{
+			//cairo_set_source_rgba(cr, 1, 0.5, 0.5, 0.5);
+			cairo_fill_preserve(cr);
+			clsUtil::DoSetLineType(m_iLineType, cr);
+			cairo_set_source_rgba(cr, r1, g1, b1, a1);
+			cairo_set_line_width(cr, m_dWidth);
+			cairo_set_line_cap(cr, (cairo_line_cap_t)m_iBoundaryCapType);
+			cairo_set_line_join(cr, (cairo_line_join_t)m_iBoundaryJionType);
+			cairo_stroke(cr);
+		}
+		else
+		{
+			cairo_fill(cr);
+		}
+		return true;
+	}
+
+	bool  SimplePolygonSymbol::DrawTexture(clsCrSurf* pClsCS,clsStruct::MPOLYGON* pMPolygon)
+	{
+		return false;
+
+	}
+
+
+	bool SimplePolygonSymbol::DrawData(clsCrSurf *pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
+	{
+		int structType = data->m_iStructType;
+		int iPartCount = data->m_iPartCount;
+
+		switch (structType)
+		{
+		case clsStruct::Struct_Line:
+		{
+									   for (int i = 0; i < iPartCount; i++)
+									   {
+										   clsStruct::LINE* pRing = (clsStruct::LINE*)data->m_pData;
+										   this->DrawRING(pClsCS, pRing + i);
+									   }
+									   break;
+		}
+		case clsStruct::Struct_Polygon:
+		{
+										  for (int i = 0; i < iPartCount; i++)
+										  {
+											  clsStruct::POLYGON*pPolygon = (clsStruct::POLYGON*)data->m_pData;
+											  this->DrawPOLYGON(pClsCS, pPolygon + i);
+										  }
+										  break;
+		}
+		case clsStruct::Struct_MPolygon:
+		{
+										   for (int i = 0; i < iPartCount; i++)
+										   {
+											   clsStruct::MPOLYGON* pMPolygon = (clsStruct::MPOLYGON*)data->m_pData;
+											   this->DrawMPOLYGON(pClsCS, pMPolygon + i);
+										   }
+										   break;
+		}
+		default:
+			break;
+		}
+		return true;
+	}
+
+
+	bool SimplePolygonSymbol::DrawData(clsCrSurf *pClsCS, DataCollection* data, int dataIndex, char* pFlag)
+	{
+		int structType = data->m_iStructType;
+		int iPartCount = data->m_iPartCount;
+		if (iPartCount <= dataIndex)return false;
+		switch (structType)
+		{
+		case clsStruct::Struct_Line:
+		{
+									//   for (int i = 0; i < iPartCount; i++)
+									   {
+										   clsStruct::LINE* pRing = (clsStruct::LINE*)data->m_pData;
+										   this->DrawRING(pClsCS, pRing + dataIndex);
+									   }
+									   break;
+		}
+		case clsStruct::Struct_Polygon:
+		{
+										 // for (int i = 0; i < iPartCount; i++)
+										  {
+											  clsStruct::POLYGON*pPolygon = (clsStruct::POLYGON*)data->m_pData;
+											  this->DrawPOLYGON(pClsCS, pPolygon + dataIndex);
+										  }
+										  break;
+		}
+		case clsStruct::Struct_MPolygon:
+		{
+										  // for (int i = 0; i < iPartCount; i++)
+										   {
+											   clsStruct::MPOLYGON* pMPolygon = (clsStruct::MPOLYGON*)data->m_pData;
+											   this->DrawMPOLYGON(pClsCS, pMPolygon + dataIndex);
+										   }
+										   break;
+		}
+		default:
+			break;
+		}
+		return true;
+	}
+
+
+	bool SimplePolygonSymbol::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag)
+	{
+		if(layerType != 2)
+			 return false;
+         pLegendParamater->next(pFlag);
+
+		 cairo_t *cr = pClsCS->m_pCr;
+		 clsUtil::DoSetAntialias(m_iAntialiasing, cr);
+
+		 if(pFlag)
+		 {
+ 			cairo_set_source_rgb(cr, 0, 0, 0); //设置画笔颜色，也就是红，绿，蓝，这里设置成绿色。
+        	cairo_select_font_face(cr, pLegendParamater->font.c_str(), 
+				CAIRO_FONT_SLANT_NORMAL, 
+				pLegendParamater->isbold? CAIRO_FONT_WEIGHT_BOLD:CAIRO_FONT_WEIGHT_NORMAL);
+        	cairo_set_font_size(cr, pLegendParamater->fontSize);
+        	cairo_move_to(cr, pLegendParamater->pixXIndex + pLegendParamater->size_x + 10, pLegendParamater->pixYIndex + pLegendParamater->size_y -3);
+        	cairo_show_text(cr, pFlag);
+		 }
+		 
+		cairo_new_path(cr);
+		cairo_move_to(cr, pLegendParamater->pixXIndex, pLegendParamater->pixYIndex );
+		cairo_line_to(cr, pLegendParamater->pixXIndex, pLegendParamater->pixYIndex + pLegendParamater->size_y);
+		cairo_line_to(cr, pLegendParamater->pixXIndex + pLegendParamater->size_x, pLegendParamater->pixYIndex + pLegendParamater->size_y);
+		cairo_line_to(cr, pLegendParamater->pixXIndex + pLegendParamater->size_x, pLegendParamater->pixYIndex);
+		cairo_close_path(cr);
+	
+		 /*
+		加一块不需要填充的部分
+		*/
+		 if (!m_bNeedFill)
+		 {
+			 if (m_bNeedBackground)
+			 {
+				 cairo_set_source_rgba(cr, r_b, g_b, b_b, a_b);
+				 cairo_fill_preserve(cr);
+			 }
+
+			 if (m_bBoundary)
+			 {
+				 clsUtil::DoSetLineType(m_iLineType, cr);
+				 cairo_set_source_rgba(cr, r1, g1, b1, a1);
+				 cairo_set_line_width(cr, m_dWidth);
+				 cairo_set_line_cap(cr, (cairo_line_cap_t)m_iBoundaryCapType);
+				 cairo_set_line_join(cr, (cairo_line_join_t)m_iBoundaryJionType);
+				 cairo_stroke(cr);
+			 }
+			 return true;
+		 }
+
+		 //cairo_set_source_rgba(cr, 1, 0.5, 0.5, 0.5);
+		 //cairo_fill_preserve(cr);
+
+		 /*
+		接下来是对应各种样式, 填充
+		*/
+		 cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
+		 if (m_Pattern)
+		 {
+			 cairo_set_source(cr, m_Pattern);
+		 }
+		 else
+		 {
+			 //此处需要进一步判断是哪种 纯颜色填充
+			 //这里只考虑纯颜色填充的四种填充方式
+			 switch (m_iFillType)
+			 {
+			 case dmapFillTypeSolid:
+				 cairo_set_source_rgba(cr, r, g, b, a);
+				 break;
+			 case dmapFillTypeGray:
+			 {
+				 //灰色颜色为 169 169 169
+				 double r_, g_, b_;
+				 r_ = g_ = b_ = ((double)169) / 255;
+				 cairo_set_source_rgba(cr, r_, g_, b_, 1.0);
+				 break;
+			 }
+			 case dmapFillTypeLightGray:
+			 {
+				 //浅灰色颜色为 211 211 211
+				 double r_, g_, b_;
+				 r_ = g_ = b_ = ((double)211) / 255;
+				 cairo_set_source_rgba(cr, r_, g_, b_, 1.0);
+				 break;
+			 }
+			 case dmapFillTypeDarkGray:
+			 {
+				 //深灰色颜色为 128 128 128
+				 double r_, g_, b_;
+				 r_ = g_ = b_ = ((double)128) / 255;
+				 cairo_set_source_rgba(cr, r_, g_, b_, 1.0);
+				 break;
+			 }
+			 default:
+				 return false; // 这里表示已出错
+				 break;
+			 }
+		 }
+		 if (m_bBoundary)
+		 {
+			 //cairo_set_source_rgba(cr, 1, 0.5, 0.5, 0.5);
+			 cairo_fill_preserve(cr);
+			 clsUtil::DoSetLineType(m_iLineType, cr);
+			 cairo_set_source_rgba(cr, r1, g1, b1, a1);
+			 cairo_set_line_width(cr, m_dWidth);
+			 cairo_set_line_cap(cr, (cairo_line_cap_t)m_iBoundaryCapType);
+			 cairo_set_line_join(cr, (cairo_line_join_t)m_iBoundaryJionType);
+			 cairo_stroke(cr);
+		 }
+		 else
+		 {
+			 cairo_fill(cr);
+		 }
+		 return true;
+	}
+}
\ No newline at end of file

+#pragma once
+#ifndef _SimplePolygonSymbol_H_
+#define _SimplePolygonSymbol_H_
+#include<string>
+
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/foreach.hpp>
+#include"Renderer.h"
+#include"clsStruct.h"
+#include <math.h>
+using namespace std;
+namespace DmapCore_30
+{
+
+   enum PolygonFillType
+{
+	dmapFillTypeSolid = 0,  //实体填充
+	dmapFillTypeBDiagonal = 1,     //左下到右上
+	dmapFillTypeFDiagonal = 2,     //左上到右下
+	dmapFillTypeCross = 3,         //十字架
+	dmapFillTypeDiagCross = 4,     //斜十字架
+	dmapFillTypeHorizontal = 5,    //横线
+	dmapFillTypeVertical = 6,      //竖线
+	dmapFillTypeGray = 7,    //灰色
+	dmapFillTypeLightGray = 8,   //浅灰色
+	dmapFillTypeDarkGray = 9,     //深灰色
+
+	dmapFillTypeIcon = 10,   //图片纹理
+	dmapFillTypeCharacter = 11 //字体纹理
+};
+
+	class clsCrSurf;
+	class DataCollection;
+	class CORE_EXPORT SimplePolygonSymbol :public Renderer
+	{
+	public:
+		SimplePolygonSymbol();
+		~SimplePolygonSymbol();
+		static SimplePolygonSymbol* CreateNew();
+		virtual int RendererType();
+		virtual bool Parse(boost::property_tree::ptree &pt, AppendBuffer *f);
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag = NULL);
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag = NULL);
+		virtual bool DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag = NULL);
+		virtual void ToJson(AppendBuffer *ab);
+		int  m_iAntialiasing;
+
+		bool TryFindHeatRenderer(){ return false; }
+		
+		string m_sPNG;
+		string m_sJDPNG;
+		double m_dWidth;
+		bool m_bBoundary;
+		unsigned int m_iBoundaryColor;
+		int m_iLineType;
+		int m_iFillType;
+		int m_iBoundaryCapType;
+		int m_iBoundaryJionType;
+		long m_lFillInterval;
+
+		bool m_bNeedBackground;
+		unsigned int m_iBackgroundColor;
+
+
+		string m_sFont;
+		string m_sFontname;
+		char m_sUTF8[5];
+		long  m_lCharacter;
+		long m_iFillsize;
+
+
+		bool m_diagalignment;
+		bool m_bNeedFill;
+		//是否设置填充颜色
+	//	bool m_bNeedFillTextureColor;
+		unsigned int   m_iFillColor;
+
+		double r, g, b, a;
+		double r1, g1, b1, a1;
+		double r_b, g_b, b_b, a_b;
+
+		cairo_pattern_t* m_Pattern = nullptr;
+		/*
+		设置纯颜色填充时,重置为NULL
+		*/
+		clsCrSurf* m_pRepeatSurface;   //这个 surface 虽然不直接调用, 但也不能作为局部变量, 因为他必须在 pattern 的整个生命期存在, 他甚至比 Pattern 后销毁
+		/*
+		此变量小心维护:
+		1. 只要不是简单的填充颜色, 都是使用 此 pattern平铺
+		2. 初始化为 NULL
+		3. 绘图时, 检测到有 png 字段, 构造 png surface , 只要 surface 长宽都不为0 , 使用 png 填充
+		4. 在设置 Png或者 filltype 时 维护, 绘图时直接调用
+		*/
+
+		//cairo_surface_t* m_pRepeatSurface;
+
+
+        bool                     SetCharacter(long lCharacter);
+
+		int                      GetAntialiasing();
+		bool                     SetAntialiasing(int newVal);
+		unsigned int             GetColor();
+		bool                     SetColor(unsigned int color);
+		int                      GetLineType();
+		bool                     SetLineType(int type);
+		const char*              GetPNG();
+		bool                     SetPNG(const char* png);
+		double                   GetWidth();
+		bool                     SetWidth(double width);
+		bool                     GetBoundary();
+		bool                     SetBoundary(bool boundary);
+		unsigned int             GetBoundaryColor();
+		bool                     SetBoundaryColor(unsigned int boundaryColor);
+		/*const char*              GetLinePNG();
+		bool                     SetLinePNG(const char* png);*/
+		int                      GetFillType();
+		bool                     SetFillType(int iFillType);
+		int                      GetBoundaryCapType();
+		bool                     SetBoundaryCapType(int iBoundaryCapType);
+		int                      GetBoundaryJionType();
+		bool                     SetBoundaryJionType(int iBoundaryJionType);
+		long                     GetFillInterval();
+		bool                     SetFillInterval(long iFillInterval);
+		bool                     GetNeedFill();
+		bool                     SetNeedFill(bool bNeedFill);
+
+
+
+		bool GetRepeatSurface();
+		bool SetBackground(cairo_t* cr,double dSurfW,double dSurfH);
+
+		bool DrawRING(clsCrSurf* pClsCS, clsStruct::LINE* pRing);
+		bool DrawPOLYGON(clsCrSurf* pClsCS, clsStruct::POLYGON* pPolygon);
+		bool DrawMPOLYGON(clsCrSurf* pClsCS, clsStruct::MPOLYGON* pMPolygon);
+
+		bool DrawTexture(clsCrSurf* pClsCS,clsStruct::MPOLYGON* pMPolygon);
+	};
+}
+
+#endif
\ No newline at end of file

+
+#include "SimpleRenderer.h"
+#include"clsXML.h"
+#include"clsUtil.h"
+
+#include"DataCollection.h"
+#include"SimpleMarkerSymbol.h"
+#include"SimpleLabelRenderer.h"
+#include"SimpleLineSymbol.h"
+#include"SimplePolygonSymbol.h"
+#include"ValueMapRenderer.h"
+//#include"RangeMapRenderer.h"
+#include"GroupRenderer.h"
+namespace DmapCore_30
+{
+	SimpleRenderer::SimpleRenderer()
+	{
+		m_pRen = NULL;
+		m_dUpper = 1e308;
+		m_dLower = 0;
+		m_alwaysShow = true;
+		this->m_simpleRenderer = true;
+	}
+
+
+	SimpleRenderer::~SimpleRenderer()
+	{
+		if (m_pRen)
+			m_pRen->Release();
+	}
+
+	int SimpleRenderer::RendererType()
+	{
+		return dmapSimpleRenderer;
+	}
+
+	bool SimpleRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
+	{
+		double r = data->m_dScaleDenominator;
+		//double r = r__ / (3779.52755905);
+		if (r <m_dLower || (r > m_dUpper && m_dUpper< 100000000) || m_pRen == 0)
+			return false;
+		return m_pRen->DrawData(pClsCS, data, pFlag);
+	}
+
+	bool SimpleRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag)
+	{
+		double r = data->m_dScaleDenominator;
+		//double r = r__ / (3779.52755905);
+		if (r <m_dLower || r > m_dUpper || m_pRen == 0)
+			return false;
+		return m_pRen->DrawData(pClsCS, data, dataIndex, pFlag);
+	}
+
+	bool SimpleRenderer::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
+	{
+		clsXML clsX(f, "SIMPLERENDERER");
+		//bool alwaysShow = true; //  
+		clsXML::XMLAttrParse(pt, f, &m_dUpper, "maxscale");
+		clsXML::XMLAttrParse(pt, f, &m_dLower, "minscale");
+
+		bool definedAlwaysShow = this->m_dLower == 0 && this->m_dUpper>10000000000;
+		clsXML::XMLAttrParse(pt, f, &m_alwaysShow, "alwaysShow",definedAlwaysShow);
+	
+		
+		clsX.closeProperties();
+		//if (node)
+		{
+			//rapidxml::xml_node<char>* node__ = node->first_node();
+			for(auto ptchild = pt.begin(); ptchild != pt.end(); ptchild++)
+			{
+				if(ptchild->first == "<xmlattr>")
+					continue;
+				clsXML::XMLParse(ptchild->first, ptchild->second, &m_pRen);
+			   if (m_pRen == 0)
+			   {
+				  return false;
+			   }
+			}
+			
+
+			this->m_simpleRenderer = m_pRen->m_simpleRenderer;
+			return true;
+		}
+		//clsXML::XMLParse(NULL, f, &m_pRen);
+
+		if (m_pRen != NULL)
+		{
+			this->m_simpleRenderer = m_pRen->m_simpleRenderer;
+		}
+	
+
+		return true;
+	}
+
+   void  SimpleRenderer::ToJson(AppendBuffer *ab)
+   {
+	   char buff[600];
+	   //bool alwaysShow =  this->m_dLower == 0 && this->m_dUpper>10000000000;
+	  
+	   char buff_maxscale[100];
+	   char buff_minscale[100];
+	   if(this->m_dUpper>100000000)
+	   {
+		    sprintf(buff_maxscale,"%e",  this->m_dUpper);
+	   }
+	   else
+	   {
+		   sprintf(buff_maxscale,"%.0f",  this->m_dUpper);
+	   }
+
+	   if(this->m_dLower>100000000)
+	   {
+		    sprintf(buff_minscale,"%e",  this->m_dLower);
+	   }
+	   else
+	   {
+		   sprintf(buff_minscale,"%.0f",  this->m_dLower);
+	   }
+	   
+
+	   sprintf(buff,R"({"maxscale":"%s", "minscale":"%s", "alwaysShow":"%s" %s )", 
+	   buff_maxscale,
+	   buff_minscale,
+	   m_alwaysShow?"true":"false",
+	   this->m_pRen?",":"");
+
+	   //strcat(resultbuff,buff);
+	   ab->AppendString(buff);
+	   if(this->m_pRen)
+	   {
+		   this->m_pRen->ToJson(ab);
+	   }
+	   ab->AppendString("}");
+	   //strcat(resultbuff,"}");
+   }
+
+	bool SimpleRenderer::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag)
+	{
+		double r = pLegendParamater->m_dScaleDenominator;
+		//double r = r__ / (3779.52755905);
+		if (r <m_dLower || (r > m_dUpper && m_dUpper< 100000000) || m_pRen == 0)
+			return false;
+		return m_pRen->DrawLegend(pClsCS, pLegendParamater,layerType, pFlag);
+	}
+
+	bool SimpleRenderer::TryFindHeatRenderer()
+	{
+		if (m_pRen == 0)return false;
+		return m_pRen->TryFindHeatRenderer();
+	}
+
+
+
+	void SimpleRenderer::TryAddField(vector<string>&pvField)
+	{
+		if (m_pRen == 0)return;
+		m_pRen->TryAddField(pvField);
+	}
+
+	Renderer* SimpleRenderer::GetRenderer()
+	{
+		if (m_pRen)
+			m_pRen->AddRef();
+		return m_pRen;
+	}
+	bool SimpleRenderer::SetRenderer(Renderer* pRen)
+	{
+		if (!pRen)
+			return false;
+		pRen->AddRef();
+		m_pRen = pRen;
+		return true;
+	}
+
+	double SimpleRenderer::GetUpper()
+	{
+		return m_dUpper;
+	}
+	bool SimpleRenderer::SetUpper(double dUpper)
+	{
+		m_dUpper = dUpper;
+		return true;
+	}
+	double SimpleRenderer::GetLower()
+	{
+		return m_dLower;
+	}
+	bool SimpleRenderer::SetLower(double dLower)
+	{
+		m_dLower = dLower;
+		return true;
+	}
+}
\ No newline at end of file

+#pragma once
+#ifndef _SimpleRenderer_H_
+#define _SimpleRenderer_H_
+#include"Renderer.h"
+#include<vector>
+using namespace std;
+namespace DmapCore_30
+{
+	class CORE_EXPORT SimpleRenderer :public Renderer
+	{
+	public:
+		SimpleRenderer();
+		~SimpleRenderer();
+		virtual int RendererType();
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag = NULL);
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag = NULL);
+		virtual bool DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag = NULL);
+		virtual bool Parse(boost::property_tree::ptree &pt, AppendBuffer *f);
+		virtual void ToJson(AppendBuffer *ab);
+		void TryAddField(vector<string>&pvField);
+        bool TryFindHeatRenderer();
+
+		Renderer* GetRenderer();
+		bool SetRenderer(Renderer* pRen);
+		double GetUpper();
+		bool SetUpper(double dUpper);
+		double GetLower();
+		bool SetLower(double dLower);
+
+	private:
+		Renderer* m_pRen;
+		double m_dUpper;
+		double m_dLower;
+		bool m_alwaysShow;
+	};
+
+}
+#endif
\ No newline at end of file

+#include "TextSymbol.h"
+#include"clsCrSurf.h"
+#include"clsXML.h"
+#include"clsUtil.h"
+#include"clsMalloc.h"
+#include "clsJson.h"
+#include <math.h>
+namespace DmapCore_30
+{
+	TextSymbol::TextSymbol()
+	{
+		m_pCrExtents = new cairo_text_extents_t();
+		m_sFont = "Sans";
+		m_dXdis = 0;
+		m_dYdis = 0;
+		m_bBackGround = false;
+		m_bGlowing = false;      //发光
+		m_bShadow = false; // 阴影
+		m_iAntialiasing = false;  //防走样
+		m_iSlant = 0;         //斜体
+		m_iWeight = 0;          //加粗
+		m_iFontSize = 10;       //字体大小
+		m_iFontColor = 0xff000000;        //字体颜色 默认黑色
+		r_font = 0; g_font = 0; b_font = 0; a_font = 1;
+		m_iBGColor = 0xffffff00;          //背景颜色,默认白色
+		r_bg = 1; g_bg = 1; b_bg = 0; a_bg = 1;
+		m_iGlowingColor = 0xffff3333;     //发光色  默认(1,0.2,0.2,1)(rgba);
+		r_glowing = 1; g_glowing = 0.2; b_glowing = 0.2; a_glowing = 1;
+		m_iShadowColor = 0xff0000ff;      //阴影色  默认蓝色
+		r_shadow = 0; g_shadow = 0; b_shadow = 1; a_shadow = 1;
+	}
+
+
+	TextSymbol::~TextSymbol()
+	{
+		if (m_pCrExtents)
+			delete m_pCrExtents;
+	}
+	bool TextSymbol::AddRef()
+	{
+		m_iN++;
+		return true;
+	}
+	bool TextSymbol::Release()
+	{
+		m_iN--;
+		if (m_iN < 0)
+			return false;
+		if (!m_iN)
+			delete this;
+		return true;
+	}
+
+	int TextSymbol::RendererType()
+	{
+		return dmapTextSymbol;
+	}
+
+	bool TextSymbol::DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
+	{
+		return true;
+	}
+	bool  TextSymbol::DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag)
+	{
+		return true;
+	}
+
+	bool TextSymbol::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
+	{
+		clsXML clsX(f, "TEXTSYMBOL");
+		clsXML::XMLAttrParse(pt, f, &m_sFont, "font");
+		clsXML::XMLAttrParse(pt, f, &m_iFontSize, "fontsize");
+		clsXML::XMLAttrParseColor(pt, f, &m_iFontColor, "fontcolor", "fonttransparency");
+		clsXML::XMLAttrParse(pt, f, &m_dXdis, "x_dis");
+		clsXML::XMLAttrParse(pt, f, &m_dYdis, "y_dis");
+		clsXML::ParseEnum("antialiasing", pt, f, &m_iAntialiasing, "antialias_default", "antialias_none", "antialias_gray", "antialias_subpixel", "antialias_fase", "antialias_good", "antialias_best", "true", "false");
+		clsXML::ParseEnum("slant", pt, f, &m_iSlant, "normal", "italic", "oblique");
+		clsXML::ParseEnum("weight", pt, f, &m_iWeight, "normal", "bold");
+
+		clsXML::XMLAttrParse(pt, f, &m_bBackGround, "background");
+		if (m_bBackGround)
+			clsXML::XMLAttrParseColor(pt, f, &m_iBGColor, "bgcolor", "bgtransparency");
+		clsXML::XMLAttrParse(pt, f, &m_bGlowing, "glowing");
+		if (m_bGlowing)
+			clsXML::XMLAttrParseColor(pt, f, &m_iGlowingColor, "glowingcolor", "glowingtransparency");
+		clsXML::XMLAttrParse(pt, f, &m_bShadow, "shadow");
+		if (m_bShadow)
+			clsXML::XMLAttrParseColor(pt, f, &m_iShadowColor, "shadowcolor", "shadowtransparency");
+		//if (pt)
+		{
+			this->SetFontColor(m_iFontColor);
+			this->SetBGColor(m_iBGColor);
+			this->SetShadowColor(m_iShadowColor);
+			this->SetGlowingColor(m_iGlowingColor);
+		}
+		return true;
+	}
+
+	void  TextSymbol::ToJson(AppendBuffer *ab)
+   {
+	   char buff[300] = {0};
+	   char resultbuff[5000] ={0};
+		sprintf(resultbuff, R"("TEXTSYMBOL":{"antialiasing":"antialias_default",)");
+		clsJson::JsonAttrParse("font", resultbuff, buff, this->m_sFont);
+		clsJson::JsonAttrParse("fontsize", resultbuff, buff, this->m_iFontSize);
+		//
+		clsJson::JsonAttrParseColor("fontcolor", "fonttransparency", resultbuff, buff, m_iFontColor);
+		clsJson::JsonAttrParse("x_dis", resultbuff, buff, this->m_dXdis);
+		clsJson::JsonAttrParse("y_dis", resultbuff, buff, this->m_dYdis);
+		//clsJson::ParseEnum("antialiasing", resultbuff, buff, m_iAntialiasing, "antialias_default", "antialias_none", "antialias_gray", "antialias_subpixel", "antialias_fase", "antialias_good", "antialias_best", "true", "false");
+		clsJson::ParseEnum("slant", resultbuff, buff, m_iSlant,"normal", "italic", "oblique");
+		clsJson::ParseEnum("weight", resultbuff, buff, m_iWeight, "normal", "bold");
+		clsJson::JsonAttrParse("background", resultbuff, buff, m_bBackGround);
+		if (m_bBackGround)
+			clsJson::JsonAttrParseColor("bgcolor", "bgtransparency", resultbuff, buff, m_iBGColor);
+		
+		clsJson::JsonAttrParse("glowing", resultbuff, buff, m_bGlowing);
+		if (m_bGlowing)
+		 	clsJson::JsonAttrParseColor("glowingcolor", "glowingtransparency", resultbuff, buff, m_iBGColor);
+		
+
+		clsJson::JsonAttrParse("shadow", resultbuff, buff, m_bGlowing);
+		if (m_bGlowing)
+		 	clsJson::JsonAttrParseColor("shadowcolor", "shadowtransparency", resultbuff, buff, m_iShadowColor);
+
+		clsJson::JsonAttrEnd(resultbuff);
+		ab->AppendString(resultbuff);
+   }
+
+
+	const char* TextSymbol::GetFont()
+	{
+		return m_sFont.c_str();
+	}
+	bool   TextSymbol::SetFont(const char* sFont)
+	{
+		m_sFont = sFont;
+		return true;
+	}
+	double TextSymbol::GetXdis()
+	{
+		return m_dXdis;
+	}
+	bool   TextSymbol::SetXdis(double dXdis)
+	{
+		m_dXdis = dXdis;
+		return true;
+	}
+	double TextSymbol::GetYdis()
+	{
+		return m_dYdis;
+	}
+	bool   TextSymbol::SetYdis(double dYdis)
+	{
+		m_dYdis = dYdis;
+		return true;
+	}
+
+	bool   TextSymbol::GetBackGround()
+	{
+		return m_bBackGround;
+	}
+	bool   TextSymbol::SetBackGround(bool bBackGround)
+	{
+		m_bBackGround = bBackGround;
+		return  true;
+	}
+	bool   TextSymbol::GetGlowing()
+	{
+		return m_bGlowing;
+	}
+	bool   TextSymbol::SetGlowing(bool bGlowing)
+	{
+		m_bGlowing = bGlowing;
+		return true;
+	}
+	bool   TextSymbol::GetShadow()
+	{
+		return m_bShadow;
+	}
+	bool   TextSymbol::SetShadow(bool bShadow)
+	{
+		m_bShadow = bShadow;
+		return true;
+	}
+	int    TextSymbol::GetAntialiasing()
+	{
+		return m_iAntialiasing;
+	}
+	bool   TextSymbol::SetAntialiasing(int iAntialiasing)
+	{
+		m_iAntialiasing = iAntialiasing;
+		return true;
+	}
+
+	int    TextSymbol::GetFontSize()
+	{
+		return m_iFontSize;
+	}
+	bool   TextSymbol::SetFontSize(int iFontSize)
+	{
+		m_iFontSize = iFontSize;
+		return true;
+	}
+	int   TextSymbol::GetSlant()
+	{
+		return m_iSlant;
+	}
+	bool   TextSymbol::SetSlant(int  iSlant)
+	{
+		m_iSlant = iSlant;
+		return true;
+	}
+	int   TextSymbol::GetWeight()
+	{
+		return m_iWeight;
+	}
+	bool   TextSymbol::SetWeight(int iWeight)
+	{
+		m_iWeight = iWeight;
+		return true;
+	}
+	unsigned int    TextSymbol::GetFontColor()
+	{
+		return m_iFontColor;
+	}
+	bool   TextSymbol::SetFontColor(unsigned int iColor)
+	{
+		m_iFontColor = iColor;
+		clsUtil::ToCairoColor(iColor, r_font, g_font, b_font, a_font);
+		return true;
+	}
+	unsigned int    TextSymbol::GetBGColor()
+	{
+		return m_iBGColor;
+	}
+	bool   TextSymbol::SetBGColor(unsigned int iColor)
+	{
+		m_iBGColor = iColor;
+		clsUtil::ToCairoColor(iColor, r_bg, g_bg, b_bg, a_bg);
+		return true;
+	}
+	unsigned int    TextSymbol::GetGlowingColor()
+	{
+		return m_iGlowingColor;
+	}
+	bool   TextSymbol::SetGlowingColor(unsigned int iColor)
+	{
+		m_iGlowingColor = iColor;
+		clsUtil::ToCairoColor(iColor, r_glowing, g_glowing, b_glowing, a_glowing);
+		return true;
+	}
+	unsigned int    TextSymbol::GetShadowColor()
+	{
+		return m_iShadowColor;
+	}
+	bool   TextSymbol::SetShadowColor(unsigned int iColor)
+	{
+		m_iShadowColor = iColor;
+		clsUtil::ToCairoColor(iColor, r_shadow, g_shadow, b_shadow, a_shadow);
+		return true;
+	}
+
+
+	bool TextSymbol::SetCairo(clsCrSurf* pClsCS)
+	{
+		cairo_t* cr = pClsCS->m_pCr;
+
+		clsMalloc clsM;
+		const char* utf8 = m_sFont.c_str();
+
+		/*bool flag = clsUtil::ConvertEncGB18030_UTF8(ss, clsM);
+		if (!flag)
+			return false;
+
+		char* utf8 = clsM.mem;*/
+		cairo_select_font_face(cr, utf8, (cairo_font_slant_t)m_iSlant, (cairo_font_weight_t)m_iWeight);
+		cairo_set_font_size(cr, m_iFontSize);
+
+		return true;
+	}
+
+
+	bool TextSymbol::DrawAText(clsCrSurf* pClsCS, double x, double y, char* sUTF8)
+	{
+		x += m_dXdis;
+		y += m_dYdis;
+		cairo_t* cr = pClsCS->m_pCr;
+		//cairo_font_options_set_antialias(cfo, CAIRO_ANTIALIAS_GRAY);
+		cairo_text_extents(cr, sUTF8, m_pCrExtents);
+		int iX = (int)x;                          int iY = (int)y;
+		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 xFrom = iX / gridsize;
+		int xTo = (iX + iTextW) / gridsize;
+		int yTo = iY / gridsize;
+		int yFrom = (iY - iTextH) / gridsize;
+
+		char * pFlag = pClsCS->m_pFlag;
+		int iFlagW = pClsCS->m_iFlagW;
+		int iFlagH = pClsCS->m_iFlagH;
+		/*if (xFrom < 0 || yFrom < 0 || xTo >= iFlagW || yTo >= iFlagH)
+			return false;*/
+
+		if (xTo < 0 || xFrom >= iFlagW || yFrom >= iFlagH || yTo < 0)return true;
+		if (xFrom < 0)xFrom = 0;
+		if (xTo >= iFlagW)xTo = iFlagW - 1;
+		if (yFrom < 0)yFrom = 0;
+		if (yTo >= iFlagH)yTo = iFlagH - 1;
+
+		/*if (xTo < 0)xTo = 0;
+		if (xFrom >= iFlagW)xFrom = iFlagW - 1;
+		if (yTo < 0)yTo = 0;
+		if (yFrom >= iFlagH)yFrom = iFlagH - 1;*/
+
+
+		/*
+		if (xFrom < 0)xFrom = 0;
+		if (xTo > iFlagW) xTo = iFlagW;
+		if (xFrom > xTo)
+		{
+		xFrom = xFrom;
+		}
+		if (yFrom < 0)yFrom = 0;
+		if (yTo > iFlagH) yTo = iFlagH;
+		*/
+
+		char *pFlagThis = pFlag + yFrom*iFlagW;
+		for (int i = yFrom; i <= yTo; i++, pFlagThis += iFlagW)
+		{
+			char *pFlagThisNow = pFlagThis + xFrom;
+			for (int j = xFrom; j <= xTo; j++, pFlagThisNow++)
+			{
+				if (*pFlagThisNow)return false;
+				//if (pFlag[iFlagW*i + j])	return false;
+			}
+		}
+		//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+		/*
+		如果有背景,绘制背景
+		*/
+		if (m_bBackGround)
+		{
+			cairo_new_path(cr);
+			cairo_rectangle(cr, x, y - iTextH, iTextW, iTextH);
+			cairo_set_source_rgba(cr, r_bg, g_bg, b_bg, a_bg);
+			cairo_fill(cr);
+		}
+
+		/*
+		绘制发光
+		*/
+		if (m_bGlowing)
+		{
+			int iGlowingSize = 2;
+			cairo_set_source_rgba(cr, r_glowing, g_glowing, b_glowing, a_glowing);
+			for (int i = -GlowingSize; i <= GlowingSize; i++)
+			{
+				for (int j = -GlowingSize; j <= GlowingSize; j++)
+				{
+					cairo_move_to(cr, x + i, y + j);
+					cairo_show_text(cr, sUTF8);
+				}
+			}
+		}
+
+		/*
+		绘制阴影
+		*/
+		if (m_bShadow)
+		{
+			cairo_set_source_rgba(cr, r_shadow, g_shadow, b_shadow, a_shadow);
+			if (m_bGlowing)
+				cairo_move_to(cr, x + ShadowSize + GlowingSize, y + ShadowSize + GlowingSize);
+			else
+				cairo_move_to(cr, x + ShadowSize, y + ShadowSize);
+			cairo_show_text(cr, sUTF8);
+		}
+
+
+		cairo_set_source_rgba(cr, r_font, g_font, b_font, a_font);
+		cairo_move_to(cr, x, y); cairo_show_text(cr, sUTF8);
+
+
+		/*
+		标记避让
+		*/
+		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+		pFlagThis = pFlag + yFrom*iFlagW;
+		for (int i = yFrom; i <= yTo; i++, pFlagThis += iFlagW)
+		{
+			memset(pFlagThis + xFrom, 1, (xTo - xFrom + 1));
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+		return true;
+	}
+
+
+	bool TextSymbol::DrawAText(clsCrSurf* pClsCS, double x, double y, char* sUTF8, int xp, int yp)
+	{
+		x += m_dXdis*xp;
+		y += m_dYdis*yp;
+		cairo_t* cr = pClsCS->m_pCr;
+
+		cairo_text_extents(cr, sUTF8, m_pCrExtents);
+		int iX = (int)x;                          int iY = (int)y;
+		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 xFrom = iX / gridsize;
+		int xTo = (iX + iTextW) / gridsize;
+		int yTo = iY / gridsize;
+		int yFrom = (iY - iTextH) / gridsize;
+
+		char * pFlag = pClsCS->m_pFlag;
+		int iFlagW = pClsCS->m_iFlagW;
+		int iFlagH = pClsCS->m_iFlagH;
+		/*if (xFrom < 0 || yFrom < 0 || xTo >= iFlagW || yTo >= iFlagH)
+		return false;*/
+
+		if (xTo < 0 || xFrom >= iFlagW || yFrom >= iFlagH || yTo < 0)return true;
+		if (xFrom < 0)xFrom = 0;
+		if (xTo >= iFlagW)xTo = iFlagW - 1;
+		if (yFrom < 0)yFrom = 0;
+		if (yTo >= iFlagH)yTo = iFlagH - 1;
+
+		/*if (xTo < 0)xTo = 0;
+		if (xFrom >= iFlagW)xFrom = iFlagW - 1;
+		if (yTo < 0)yTo = 0;
+		if (yFrom >= iFlagH)yFrom = iFlagH - 1;*/
+
+
+		/*
+		if (xFrom < 0)xFrom = 0;
+		if (xTo > iFlagW) xTo = iFlagW;
+		if (xFrom > xTo)
+		{
+		xFrom = xFrom;
+		}
+		if (yFrom < 0)yFrom = 0;
+		if (yTo > iFlagH) yTo = iFlagH;
+		*/
+
+		char *pFlagThis = pFlag + yFrom*iFlagW;
+		for (int i = yFrom; i <= yTo; i++, pFlagThis += iFlagW)
+		{
+			char *pFlagThisNow = pFlagThis + xFrom;
+			for (int j = xFrom; j <= xTo; j++, pFlagThisNow++)
+			{
+				if (*pFlagThisNow)return false;
+				//if (pFlag[iFlagW*i + j])	return false;
+			}
+		}
+		//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+		/*
+		如果有背景,绘制背景
+		*/
+		if (m_bBackGround)
+		{
+			cairo_new_path(cr);
+			cairo_rectangle(cr, x, y - iTextH, iTextW, iTextH);
+			cairo_set_source_rgba(cr, r_bg, g_bg, b_bg, a_bg);
+			cairo_fill(cr);
+		}
+
+		/*
+		绘制发光
+		*/
+		if (m_bGlowing)
+		{
+			int iGlowingSize = 2;
+			cairo_set_source_rgba(cr, r_glowing, g_glowing, b_glowing, a_glowing);
+			for (int i = -GlowingSize; i <= GlowingSize; i++)
+			{
+				for (int j = -GlowingSize; j <= GlowingSize; j++)
+				{
+					cairo_move_to(cr, x + i, y + j);
+					cairo_show_text(cr, sUTF8);
+				}
+			}
+		}
+
+		/*
+		绘制阴影
+		*/
+		if (m_bShadow)
+		{
+			cairo_set_source_rgba(cr, r_shadow, g_shadow, b_shadow, a_shadow);
+			if (m_bGlowing)
+				cairo_move_to(cr, x + ShadowSize + GlowingSize, y + ShadowSize + GlowingSize);
+			else
+				cairo_move_to(cr, x + ShadowSize, y + ShadowSize);
+			cairo_show_text(cr, sUTF8);
+		}
+
+
+		cairo_set_source_rgba(cr, r_font, g_font, b_font, a_font);
+		cairo_move_to(cr, x, y); cairo_show_text(cr, sUTF8);
+
+
+		/*
+		标记避让
+		*/
+		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+		pFlagThis = pFlag + yFrom*iFlagW;
+		for (int i = yFrom; i <= yTo; i++, pFlagThis += iFlagW)
+		{
+			memset(pFlagThis + xFrom, 1, (xTo - xFrom + 1));
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+		return true;
+	}
+
+	
+
+	bool TextSymbol::DrawAText(clsCrSurf* pClsCS, double x, double y, char* sUTF8, double dAngle)
+	{
+		x += m_dXdis;
+		y += m_dYdis;
+		//顺时针
+		if (dAngle == 0)
+			return this->DrawAText(pClsCS, x, y, sUTF8);
+
+		cairo_t* cr = pClsCS->m_pCr;
+	
+		cairo_text_extents(cr, sUTF8, m_pCrExtents);
+		int iX = (int)x;                          int iY = (int)y;
+		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;
+
+
+
+		/*
+		检查文字避让
+		*/
+		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+		/*
+		假设对图片上任意点(x,y)，绕一个坐标点(rx0,ry0)逆时针旋转a角度后的新的坐标设为(x0, y0)，有公式：
+		x0= (x - rx0)*cos(a) - (y - ry0)*sin(a) + rx0 ;
+		y0= (x - rx0)*sin(a) + (y - ry0)*cos(a) + ry0 ;
+		*/
+		int xFrom = iX / gridsize;
+		int xTo = (iX + iTextW) / gridsize;
+		int yTo = iY / gridsize;
+		int yFrom = (iY - iTextH) / gridsize;
+
+		char * pFlag = pClsCS->m_pFlag;
+		int iFlagW = pClsCS->m_iFlagW;
+		int iFlagH = pClsCS->m_iFlagH;
+
+		if (xFrom < 0)xFrom = 0;
+		if (xTo >= iFlagW) xTo = iFlagW - 1;
+		if (yFrom < 0)yFrom = 0;
+		if (yTo >= iFlagH) yTo = iFlagH - 1;
+
+	
+		//选择其实不对
+		for (int i = yFrom; i <= yTo; i++)
+		{
+			for (int j = xFrom; j <= xTo; j++)
+			{
+				double x_this = j*gridsize;
+				double y_this = i*gridsize;
+				double x_this_ = (x_this - x)*std::cos(dAngle) - (y_this - y)*std::sin(dAngle) + x;
+				double y_this_ = (x_this - x)*std::sin(dAngle) + (y_this - y)*std::cos(dAngle) + y;
+				if (x_this_ == x_this_ && y_this_ == y_this_)
+				{
+					int iXThis = ((int)(x_this_)) / gridsize;
+					int iYThis = ((int)(y_this_)) / gridsize;
+
+					if (iYThis*iFlagW + iXThis<0 || pFlag[iYThis*iFlagW + iXThis])
+						return false;
+				}
+				else
+				{
+					return true;
+				}
+			}
+		}
+		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+
+		{
+			/*
+			如果有背景,绘制背景
+			*/
+			if (m_bBackGround)
+			{
+				cairo_new_path(cr);
+				cairo_move_to(cr, x, y);
+				cairo_rotate(cr, dAngle);
+				//cairo_rectangle(cr, x, y - iTextH, iTextW, iTextH);
+
+				{
+					cairo_rel_line_to(cr, iTextW, 0);
+					cairo_rel_line_to(cr, 0, -iTextH);
+					cairo_rel_line_to(cr, -iTextW, 0);
+					cairo_close_path(cr);
+				}
+				cairo_rotate(cr, -dAngle);
+				cairo_set_source_rgba(cr, r_bg, g_bg, b_bg, a_bg);
+				cairo_fill(cr);
+			}
+
+			/*
+			绘制发光
+			*/
+			if (m_bGlowing)
+			{
+				int iGlowingSize = 2;
+				cairo_set_source_rgba(cr, r_glowing, g_glowing, b_glowing, a_glowing);
+				for (int i = -GlowingSize; i <= GlowingSize; i++)
+				{
+					for (int j = -GlowingSize; j <= GlowingSize; j++)
+					{
+						cairo_move_to(cr, x + i, y + j);
+						cairo_rotate(cr, dAngle);
+						cairo_show_text(cr, sUTF8);
+						cairo_rotate(cr, -dAngle);
+					}
+				}
+			}
+
+			/*
+			绘制阴影
+			*/
+			if (m_bShadow)
+			{
+				int iShadowSize = 2;
+				cairo_set_source_rgba(cr, r_shadow, g_shadow, b_shadow, a_shadow);
+				if (m_bGlowing)
+					cairo_move_to(cr, x + ShadowSize + GlowingSize, y + ShadowSize + GlowingSize);
+				else
+					cairo_move_to(cr, x + ShadowSize, y + ShadowSize);
+				cairo_rotate(cr, dAngle); cairo_show_text(cr, sUTF8); cairo_rotate(cr, -dAngle);
+			}
+
+
+			cairo_set_source_rgba(cr, r_font, g_font, b_font, a_font);
+			cairo_move_to(cr, x, y);
+			cairo_rotate(cr, dAngle);
+			cairo_show_text(cr, sUTF8);
+			cairo_rotate(cr, -dAngle);
+
+			/*cairo_set_source_rgba(cr, 1, 0.2, 0.2, 1);
+			cairo_set_line_width(cr, 1);
+			cairo_move_to(cr, x, y);
+			cairo_rotate(cr, dAngle);
+			cairo_rel_line_to(cr, iTextW,0);
+			cairo_rel_line_to(cr, 0, -iTextH);
+			cairo_rel_line_to(cr, -iTextW, 0);
+			cairo_close_path(cr);
+			cairo_stroke(cr);
+			cairo_rotate(cr, -dAngle);*/
+		}
+
+		/*
+		处理文字避让
+		*/
+		for (int i = yFrom; i <= yTo; i++)
+		{
+			for (int j = xFrom; j <= xTo; j++)
+			{
+				double x_this = j*gridsize;
+				double y_this = i*gridsize;
+				double x_this_ = (x_this - x)*cos(dAngle) - (y_this - y)*sin(dAngle) + x;
+				double y_this_ = (x_this - x)*sin(dAngle) + (y_this - y)*cos(dAngle) + y;
+				int iXThis = ((int)(x_this_)) / gridsize;
+				int iYThis = ((int)(y_this_)) / gridsize;
+
+				pFlag[iYThis*iFlagW + iXThis] = 1;
+			}
+		}
+
+		return true;
+	}
+
+	bool TextSymbol::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag)
+	{
+		
+		return false;
+	}
+
+}
+

+#pragma once
+//#include<cairo/cairo.h>
+#ifndef _TextSymbol_H_
+#define _TextSymbol_H_
+#include<string>
+#ifndef _Renderer_h_
+#define _Renderer_h_
+#include"Renderer.h"
+#endif
+using namespace std;
+#define GlowingSize 1
+#define ShadowSize 2
+namespace DmapCore_30
+{
+
+	class clsCrSurf;
+	class CORE_EXPORT TextSymbol :public Renderer
+	{
+	public:
+		TextSymbol();
+		~TextSymbol();
+		bool AddRef();
+		bool Release();
+
+		int RendererType();
+		bool DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag = NULL);
+	    bool DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag = NULL);
+		virtual bool DrawLegend(clsCrSurf* pClsCS,  shared_ptr<legendParamater> pLegendParamater, int layerType,char* pFlag = NULL);
+		bool Parse(boost::property_tree::ptree &pt, AppendBuffer *f);
+		virtual void ToJson(AppendBuffer *ab);
+		static bool RendererXmlParse(Renderer**pRen, const char* fileName);
+
+		bool TryFindHeatRenderer(){ return false; }
+	private:
+		int m_iN;
+
+	public:
+		string  m_sFont;
+		double  m_dXdis;
+		double  m_dYdis;
+		bool    m_bBackGround;
+		bool    m_bGlowing;      //发光
+		bool    m_bShadow; // 阴影
+		bool    m_iAntialiasing;  //防走样
+		int     m_iSlant;         //斜体
+		int     m_iWeight;          //加粗
+		long     m_iFontSize;       //字体大小
+		unsigned int     m_iFontColor;        //字体颜色
+		unsigned int     m_iBGColor;          //背景颜色
+		unsigned int     m_iGlowingColor;     //发光色
+		unsigned int     m_iShadowColor;      //阴影色
+
+
+		const char* GetFont();
+		bool    SetFont(const char* sFont);
+		double  GetXdis();
+		bool    SetXdis(double dXdis);
+		double  GetYdis();
+		bool    SetYdis(double dYdis);
+		bool   GetBackGround();
+		bool   SetBackGround(bool bBackGround);
+		bool   GetGlowing();
+		bool   SetGlowing(bool bGlowing);
+		bool   GetShadow();
+		bool   SetShadow(bool bShadow);
+		int    GetAntialiasing();
+		bool   SetAntialiasing(int iAntialiasing);
+
+		int    GetFontSize();
+		bool   SetFontSize(int iFontSize);
+		int    GetSlant();
+		bool   SetSlant(int  iSlant);
+		int    GetWeight();
+		bool   SetWeight(int iWeight);
+		unsigned int    GetFontColor();
+		bool   SetFontColor(unsigned int iColor);
+		unsigned int    GetBGColor();
+		bool   SetBGColor(unsigned int iColor);
+		unsigned int    GetGlowingColor();
+		bool   SetGlowingColor(unsigned int iColor);
+		unsigned int    GetShadowColor();
+		bool   SetShadowColor(unsigned int iColor);
+
+		/*
+		设置字体,文字大小等固定的一次性设置
+		*/
+		bool SetCairo(clsCrSurf* pClsCS);
+
+
+	public:
+		double r_font, g_font, b_font, a_font;
+		double r_bg, g_bg, b_bg, a_bg;
+		double r_glowing, g_glowing, b_glowing, a_glowing;
+		double r_shadow, g_shadow, b_shadow, a_shadow;
+
+		/*
+		Draw部分
+		*/
+	public:
+		bool DrawAText(clsCrSurf* pClsCS, double x, double y, char* sUTF8);
+		bool DrawAText(clsCrSurf* pClsCS, double x, double y, char* sUTF8, double dAngle);  //这个地方不认为在不需要旋转的情况下,旋转角度是0,因为旋转只在点中使用,大部分情况下不需要旋转,认为旋转0度必会影响效率
+		bool DrawAText(clsCrSurf* pClsCS, double x, double y, char* sUTF8,int xp,int yp);
+		//clsCrSurf* m_pClsCS;  //这个是需要绘制文本的surface和cairo
+		char* m_pFlag;        //这个是文字避让数组
+
+	private:
+		cairo_text_extents_t* m_pCrExtents;   //cairo定义的文本区域结构体
+		/*
+		这个变量使用new构造,在类构造函数中创建,在类析构中释放,传入的文本改变时,需要维护
+		*/
+
+
+		/*
+		标签位置
+		*/
+	public:
+
+
+	};
+
+
+}
+
+#endif

+
+#include "TrueTypeMarkerSymbol.h"
+#include"DataCollection.h"
+#include"clsStruct.h"
+#include"clsCrSurf.h"
+#include"clsUtil.h"
+#include"clsXML.h"
+#include "clsJson.h"
+#define _USE_MATH_DEFINES
+#include<math.h>
+#define ShadowSize 1
+#define GlowingSize 1
+
+namespace DmapCore_30
+{
+	TrueTypeMarkerSymbol::TrueTypeMarkerSymbol()
+	{
+		m_pbFlag = (char *)malloc(65536);
+		m_dAngle = 0;
+		m_sAngleField = "";
+		m_iAntialiasing = dmapAntialiasingDefault;
+		m_lCharacter = 33;
+		{
+			memset(m_sUTF8, 0, 5);
+			m_sUTF8[0] = 33;
+		}
+		m_dCharacterXdis = 0;
+		m_dCharacterYdis = 0;
+		m_sFont = "";     //m_sFont = "Sans";
+		m_iFontColor = 0xff000000;
+		clsUtil::ToCairoColor(m_iFontColor, r_font, g_font, b_font, a_font);
+		m_lFontSize = 20;
+		m_bHaveGlowing = false;       //
+		m_iGlowingColor = 0xffff3333;  //默认发光色 r=1,g=0.2,b=0.2
+		clsUtil::ToCairoColor(m_iGlowingColor, r_glowing, g_glowing, b_glowing, a_glowing);
+		m_bHaveOutline = false;       //
+		m_iOutline = 0xff00ff00;           //边框
+		clsUtil::ToCairoColor(m_iOutline, r_outline, g_outline, b_outline, a_outline);
+		//m_iRotateMethod = 0;      //旋转方式,角度计算方式,使用枚举,具体见esri文档
+		m_bHaveShadow = false;        //
+		m_iShadowColor = 0xff0000ff;  //默认阴影蓝色
+		clsUtil::ToCairoColor(m_iShadowColor, r_shadow, g_shadow, b_shadow, a_shadow);
+		m_iSlant = (int)CAIRO_FONT_SLANT_NORMAL;
+		m_iWeight = (int)CAIRO_FONT_WEIGHT_NORMAL;
+		m_bHaveUnderLine = false;
+		m_bHaveDeleteLine = false;
+		m_simpleRenderer = false;
+
+	}
+
+
+	TrueTypeMarkerSymbol::~TrueTypeMarkerSymbol()
+	{
+		free(m_pbFlag);
+	}
+
+	int TrueTypeMarkerSymbol::RendererType()
+	{
+		return dmapTrueTypeMarkerSymbol;
+	}
+	bool TrueTypeMarkerSymbol::DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
+	{
+		this->SetCairo(pClsCS);
+		int structType = data->m_iStructType;
+		int iPartCount = data->m_iPartCount;
+
+		switch (structType)
+		{
+		case clsStruct::Struct_Point:
+		{
+										for (int i = 0; i < iPartCount; i++)
+										{
+											clsStruct::POINT* pPoint = (clsStruct::POINT*)(data->m_pData) + i;
+											double x = pPoint->x;
+											double y = pPoint->y;
+
+
+											x += m_dCharacterXdis;
+											y += m_dCharacterYdis;
+
+											if (m_sAngleField != "")
+											{
+												int iFieldIndex = -1;
+												int sz = (int)(data->m_vFieldName.size());
+												for (int j = 0; j < sz; j++)
+												{
+													if (m_sAngleField == data->m_vFieldName[j])
+														iFieldIndex = j;
+												}
+												if (iFieldIndex == -1)
+													break;   //找不到该字段,直接跳出循环
+												string sAngle = data->m_vAllField[i][iFieldIndex];
+												double dAngle = stod(sAngle.c_str(), NULL);
+												this->DrawAText(pClsCS, x, y, dAngle);
+											}
+											else
+											{
+												if (m_dAngle == 0)
+													this->DrawAText(pClsCS, x, y);
+												else
+													this->DrawAText(pClsCS, x, y, m_dAngle);
+											}
+										}
+										break;
+		}
+		case clsStruct::Struct_MLine:
+		{
+										for (int i = 0; i < iPartCount; i++)
+										{
+											clsStruct::MLINE* pMLine = (clsStruct::MLINE*)data->m_pData;
+											double x, y;
+											clsStruct::GetCenter(x, y, pMLine + i);
+
+											x += m_dCharacterXdis;
+											y += m_dCharacterYdis;
+
+
+											////////////////////////////////////////////////////////////////////////////////////
+											if (m_sAngleField != "")
+											{
+												int iFieldIndex = -1;
+												int sz = (int)(data->m_vFieldName.size());
+												for (int j = 0; j < sz; j++)
+												{
+													if (m_sAngleField == data->m_vFieldName[j])
+														iFieldIndex = j;
+												}
+												if (iFieldIndex == -1)
+													break;   //找不到该字段,直接跳出循环
+												string sAngle = data->m_vAllField[i][iFieldIndex];
+												double dAngle = stod(sAngle.c_str(), NULL);
+												this->DrawAText(pClsCS, x, y, dAngle);
+											}
+											else
+											{
+												if (m_dAngle == 0)
+													this->DrawAText(pClsCS, x, y);
+												else
+													this->DrawAText(pClsCS, x, y, m_dAngle);
+											}
+
+											////////////////////////////////////////////////////////////////////////////////////////
+										}
+										break;
+		}
+		case clsStruct::Struct_MPolygon:
+		{
+										   for (int i = 0; i < iPartCount; i++)
+										   {
+											   clsStruct::MPOLYGON* pMPolygon = (clsStruct::MPOLYGON*)data->m_pData;
+											   double x, y;
+											   clsStruct::GetCenter(x, y, pMPolygon + i);
+
+											   x += m_dCharacterXdis;
+											   y += m_dCharacterYdis;
+											   ////////////////////////////////////////////////////////////////////////////////////
+											   if (m_sAngleField != "")
+											   {
+												   int iFieldIndex = -1;
+												   int sz = (int)(data->m_vFieldName.size());
+												   for (int j = 0; j < sz; j++)
+												   {
+													   if (m_sAngleField == data->m_vFieldName[j])
+														   iFieldIndex = j;
+												   }
+												   if (iFieldIndex == -1)
+													   break;   //找不到该字段,直接跳出循环
+												   string sAngle = data->m_vAllField[i][iFieldIndex];
+												   double dAngle = stod(sAngle.c_str(), NULL);
+												   this->DrawAText(pClsCS, x, y, dAngle);
+											   }
+											   else
+											   {
+												   if (m_dAngle == 0)
+													   this->DrawAText(pClsCS, x, y);
+												   else
+													   this->DrawAText(pClsCS, x, y, m_dAngle);
+											   }
+
+											   ////////////////////////////////////////////////////////////////////////////////////////
+										   }
+										   break;
+		}
+		default:
+			break;
+		}
+
+		return true;
+	}
+
+	bool TrueTypeMarkerSymbol::DrawData(clsCrSurf* pClsCS, DataCollection* data, int  dataIndex, char* pFlag)
+	{
+		this->SetCairo(pClsCS);
+		int structType = data->m_iStructType;
+		int iPartCount = data->m_iPartCount;
+		if (iPartCount <= dataIndex)return false;
+		switch (structType)
+		{
+		case clsStruct::Struct_Point:
+		{
+									//	for (int i = 0; i < iPartCount; i++)
+										{
+											clsStruct::POINT* pPoint = (clsStruct::POINT*)(data->m_pData) + dataIndex;
+											double x = pPoint->x;
+											double y = pPoint->y;
+
+
+											x += m_dCharacterXdis;
+											y += m_dCharacterYdis;
+
+											if (m_sAngleField != "")
+											{
+												int iFieldIndex = -1;
+												int sz = (int)(data->m_vFieldName.size());
+												for (int j = 0; j < sz; j++)
+												{
+													if (m_sAngleField == data->m_vFieldName[j])
+														iFieldIndex = j;
+												}
+												if (iFieldIndex == -1)
+													break;   //找不到该字段,直接跳出循环
+												string sAngle = data->m_vAllField[dataIndex][iFieldIndex];
+												double dAngle = stod(sAngle.c_str(), NULL);
+												this->DrawAText(pClsCS, x, y, dAngle);
+											}
+											else
+											{
+												if (m_dAngle == 0)
+													this->DrawAText(pClsCS, x, y);
+												else
+													this->DrawAText(pClsCS, x, y, m_dAngle);
+											}
+										}
+										break;
+		}
+		case clsStruct::Struct_MLine:
+		{
+										//for (int i = 0; i < iPartCount; i++)
+										{
+											clsStruct::MLINE* pMLine = (clsStruct::MLINE*)data->m_pData;
+											double x, y;
+											clsStruct::GetCenter(x, y, pMLine + dataIndex);
+
+											x += m_dCharacterXdis;
+											y += m_dCharacterYdis;
+
+
+											////////////////////////////////////////////////////////////////////////////////////
+											if (m_sAngleField != "")
+											{
+												int iFieldIndex = -1;
+												int sz = (int)(data->m_vFieldName.size());
+												for (int j = 0; j < sz; j++)
+												{
+													if (m_sAngleField == data->m_vFieldName[j])
+														iFieldIndex = j;
+												}
+												if (iFieldIndex == -1)
+													break;   //找不到该字段,直接跳出循环
+												string sAngle = data->m_vAllField[dataIndex][iFieldIndex];
+												double dAngle = stod(sAngle.c_str(), NULL);
+												this->DrawAText(pClsCS, x, y, dAngle);
+											}
+											else
+											{
+												if (m_dAngle == 0)
+													this->DrawAText(pClsCS, x, y);
+												else
+													this->DrawAText(pClsCS, x, y, m_dAngle);
+											}
+
+											////////////////////////////////////////////////////////////////////////////////////////
+										}
+										break;
+		}
+		case clsStruct::Struct_MPolygon:
+		{
+										  // for (int i = 0; i < iPartCount; i++)
+										   {
+											   clsStruct::MPOLYGON* pMPolygon = (clsStruct::MPOLYGON*)data->m_pData;
+											   double x, y;
+											   clsStruct::GetCenter(x, y, pMPolygon + dataIndex);
+
+											   x += m_dCharacterXdis;
+											   y += m_dCharacterYdis;
+											   ////////////////////////////////////////////////////////////////////////////////////
+											   if (m_sAngleField != "")
+											   {
+												   int iFieldIndex = -1;
+												   int sz = (int)(data->m_vFieldName.size());
+												   for (int j = 0; j < sz; j++)
+												   {
+													   if (m_sAngleField == data->m_vFieldName[j])
+														   iFieldIndex = j;
+												   }
+												   if (iFieldIndex == -1)
+													   break;   //找不到该字段,直接跳出循环
+												   string sAngle = data->m_vAllField[dataIndex][iFieldIndex];
+												   double dAngle = stod(sAngle.c_str(), NULL);
+												   this->DrawAText(pClsCS, x, y, dAngle);
+											   }
+											   else
+											   {
+												   if (m_dAngle == 0)
+													   this->DrawAText(pClsCS, x, y);
+												   else
+													   this->DrawAText(pClsCS, x, y, m_dAngle);
+											   }
+
+											   ////////////////////////////////////////////////////////////////////////////////////////
+										   }
+										   break;
+		}
+		default:
+			break;
+		}
+
+		return true;
+	}
+
+	bool TrueTypeMarkerSymbol::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater, 
+		int layerType,	char* pFlag)
+	{
+		if(layerType != 0)
+			 return false;
+		pLegendParamater->next(pFlag);
+		 cairo_t *cr = pClsCS->m_pCr;
+		if(pFlag)
+		 {
+ 			cairo_set_source_rgb(cr, 0, 0, 0); //设置画笔颜色，也就是红，绿，蓝，这里设置成绿色。
+        	cairo_select_font_face(cr, pLegendParamater->font.c_str(), 
+				CAIRO_FONT_SLANT_NORMAL, 
+				pLegendParamater->isbold? CAIRO_FONT_WEIGHT_BOLD:CAIRO_FONT_WEIGHT_NORMAL);
+        	cairo_set_font_size(cr, pLegendParamater->fontSize);
+        	cairo_move_to(cr, pLegendParamater->pixXIndex + pLegendParamater->size_x + 10,
+			      pLegendParamater->pixYIndex + pLegendParamater->size_y -3);
+        	cairo_show_text(cr, pFlag);
+		 }
+		double x = pLegendParamater->pixXIndex + pLegendParamater->size_x/2;
+		double y = pLegendParamater->pixYIndex + pLegendParamater->size_y/2;
+
+		x += m_dCharacterXdis;
+		y += m_dCharacterYdis;
+
+		this->SetCairo(pClsCS);
+		this->DrawAText(pClsCS, x, y);
+	
+		return false;
+	}
+
+
+	bool TrueTypeMarkerSymbol::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
+	{
+		clsXML clsX(f, "TRUETYPEMARKERSYMBOL");
+		clsXML::XMLAttrParse(pt, f, &m_dAngle, "angle");
+		clsXML::XMLAttrParse(pt, f, &m_sAngleField, "anglefield");
+		clsXML::ParseEnum("antialiasing", pt, f, &m_iAntialiasing, "default", "none", "gray", "subpixel", "fast", "good", "best", "true", "false");
+
+
+		clsXML::XMLAttrParse(pt, f, &m_lCharacter, "character");
+		//if (pt)
+		{
+			this->SetCharacter(m_lCharacter);
+		}
+		clsXML::XMLAttrParse(pt, f, &m_dCharacterXdis, "characterxdis");
+		clsXML::XMLAttrParse(pt, f, &m_dCharacterYdis, "characterydis");
+		clsXML::XMLAttrParse(pt, f, &m_sFont, "font");
+		clsXML::XMLAttrParseColor(pt, f, &m_iFontColor, "fontcolor");
+		clsXML::XMLAttrParse(pt, f, &m_lFontSize, "fontsize");
+		clsXML::XMLAttrParse(pt, f, &m_bHaveGlowing, "haveglowing");
+		clsXML::XMLAttrParse(pt, f, &m_fontname, "fontname");
+		
+		if (m_bHaveGlowing)clsXML::XMLAttrParseColor(pt, f, &m_iGlowingColor, "glowingcolor");
+		clsXML::XMLAttrParse(pt, f, &m_bHaveOutline, "haveoutline");
+		if (m_bHaveOutline) clsXML::XMLAttrParseColor(pt, f, &m_iOutline, "outline");
+		//clsXML::ParseEnum("rotatemethod", pt, f, &m_iRotateMethod, "geographic","arithmetic","mod_arithmetic");
+		clsXML::XMLAttrParse(pt, f, &m_bHaveShadow, "haveshashow");
+		if (m_bHaveShadow)clsXML::XMLAttrParseColor(pt, f, &m_iShadowColor, "shashowcolor");
+		clsXML::ParseEnum("slant", pt, f, &m_iSlant, "normal", "italic", "oblique");
+		clsXML::ParseEnum("weight", pt, f, &m_iWeight, "normal", "bold");
+		clsXML::XMLAttrParse(pt, f, &m_bHaveUnderLine, "haveunderline");
+		clsXML::XMLAttrParse(pt, f, &m_bHaveDeleteLine, "havedeleteline");
+
+		return true;
+	}
+
+	void  TrueTypeMarkerSymbol::ToJson(AppendBuffer *ab)
+   {
+	   char buff[300] = {0};
+	   char resultbuff[5000] = {0};
+		strcat(resultbuff, R"("TRUETYPEMARKERSYMBOL":{"antialiasing":"antialias_default",)");
+		clsJson::JsonAttrParse("angle", resultbuff, buff, m_dAngle);
+		clsJson::JsonAttrParse("anglefield", resultbuff, buff, m_sAngleField);
+		clsJson::ParseEnum("antialiasing", resultbuff, buff, m_iAntialiasing,"default", "none", "gray", "subpixel", "fast", "good", "best", "true", "false");
+		clsJson::JsonAttrParse("character", resultbuff, buff, m_lCharacter);
+		clsJson::JsonAttrParseColor("fontcolor", "fonttransparency", resultbuff, buff, m_iFontColor);
+
+		clsJson::JsonAttrParse("fontname",resultbuff,buff,m_fontname);
+		clsJson::JsonAttrParse("characterxdis", resultbuff, buff, m_dCharacterXdis);
+		clsJson::JsonAttrParse("characterydis", resultbuff, buff, m_dCharacterYdis);
+		clsJson::JsonAttrParse("font", resultbuff, buff, m_sFont);
+		clsJson::JsonAttrParseColor("glowingcolor", "glowingtransparency", resultbuff, buff, m_iFontColor);
+		clsJson::JsonAttrParse("fontsize", resultbuff, buff, m_lFontSize);
+		
+		clsJson::JsonAttrParse("haveglowing", resultbuff, buff, m_bHaveGlowing);
+		if (m_bHaveGlowing)
+		{
+			clsJson::JsonAttrParseColor("haveglowing", "fonttransparency", resultbuff, buff, m_iGlowingColor);
+		}	
+		clsJson::JsonAttrParse("haveglowing", resultbuff, buff, m_bHaveGlowing);
+		//if (m_iOutline)
+		//{
+ 		//	clsJson::JsonAttrParse("outline", resultbuff, buff, (long)m_iOutline);
+		//}
+		   
+		//clsXML::ParseEnum("rotatemethod", node, f, &m_iRotateMethod, "geographic","arithmetic","mod_arithmetic");
+		//clsXML::XMLAttrParse(node, f, &m_bHaveShadow, "haveshashow");
+		//if (m_bHaveShadow)clsXML::XMLAttrParseColor(node, f, &m_iShadowColor, "shashowcolor");
+
+		clsJson::ParseEnum("linetype", resultbuff, buff, m_iSlant,"normal", "italic", "oblique");
+		clsJson::ParseEnum("linetype", resultbuff, buff, m_iWeight,"normal", "bold");
+        clsJson::JsonAttrParse("haveunderline", resultbuff, buff, m_bHaveUnderLine);
+		clsJson::JsonAttrParse("havedeleteline", resultbuff, buff, m_bHaveDeleteLine);
+
+		
+		clsJson::JsonAttrEnd(resultbuff);
+		ab->AppendString(resultbuff);
+   }
+
+	double       TrueTypeMarkerSymbol::GetAngle()
+	{
+		return m_dAngle / M_PI * 180;
+	}
+	bool         TrueTypeMarkerSymbol::SetAngle(double dAngle)
+	{
+		m_dAngle = dAngle / 180 * M_PI;
+		return true;
+	}
+	const char*  TrueTypeMarkerSymbol::GetAngleField()
+	{
+		return m_sAngleField.c_str();
+	}
+	bool         TrueTypeMarkerSymbol::SetAngleField(const char* sAngleField)
+	{
+		m_sAngleField = sAngleField;
+		return true;
+	}
+	int          TrueTypeMarkerSymbol::GetAntialiasing()
+	{
+		return m_iAntialiasing;
+	}
+	bool         TrueTypeMarkerSymbol::SetAntialiasing(int iAntialiasing)
+	{
+		m_iAntialiasing = iAntialiasing;
+		return true;
+	}
+	long         TrueTypeMarkerSymbol::GetCharacter()
+	{
+		return m_lCharacter;
+	}
+	bool         TrueTypeMarkerSymbol::SetCharacter(long lCharacter)
+	{
+		m_lCharacter = lCharacter;
+		memset(m_sUTF8, 0, 5);
+		if (lCharacter < 256)
+		{
+			m_sUTF8[0] = ((char*)(&lCharacter))[0];
+		}
+		else
+		{
+			m_sUTF8[0] = ((char*)(&m_lCharacter))[1];
+			m_sUTF8[1] = ((char*)(&m_lCharacter))[0];
+		}
+		return true;
+	}
+	bool         TrueTypeMarkerSymbol::GetCharacterDis(double* pdXdis, double* pdYdis)
+	{
+		*pdXdis = m_dCharacterXdis;
+		*pdYdis = m_dCharacterYdis;
+		return true;
+	}
+	bool         TrueTypeMarkerSymbol::SetCharacterDis(double dXDis, double dYDis)
+	{
+		m_dCharacterXdis = dXDis;
+		m_dCharacterYdis = dYDis;
+		return true;
+	}
+	const char*  TrueTypeMarkerSymbol::GetFont()
+	{
+		return m_sFont.c_str();
+	}
+	bool         TrueTypeMarkerSymbol::SetFont(const char* sFont)
+	{
+		m_sFont = sFont;
+		return true;
+	}
+	unsigned int TrueTypeMarkerSymbol::GetFontColor()
+	{
+		return m_iFontColor;
+	}
+	bool         TrueTypeMarkerSymbol::SetFontColor(unsigned int iFontColor)
+	{
+		m_iFontColor = iFontColor;
+		clsUtil::ToCairoColor(m_iFontColor, r_font, g_font, b_font, a_font);
+		return true;
+	}
+	long         TrueTypeMarkerSymbol::GetFontSize()
+	{
+		return m_lFontSize;
+	}
+	bool         TrueTypeMarkerSymbol::SetFontSize(long lFontSize)
+	{
+		m_lFontSize = lFontSize;
+		return true;
+	}
+	bool         TrueTypeMarkerSymbol::GetGlowing(bool* pbHaveGlowing, unsigned int * piGlowingColor)
+	{
+		*pbHaveGlowing = m_bHaveGlowing;
+		*piGlowingColor = m_iGlowingColor;
+		return true;
+	}
+	bool         TrueTypeMarkerSymbol::SetGlowingColor(bool bHaveGlowing, unsigned int iGlowingColor)
+	{
+		m_bHaveGlowing = bHaveGlowing;
+		m_iGlowingColor = iGlowingColor;
+		if (m_bHaveGlowing)
+			clsUtil::ToCairoColor(m_iGlowingColor, r_glowing, g_glowing, b_glowing, a_glowing);
+		return true;
+	}
+	//int          TrueTypeMarkerSymbol::GetRotateMethod()
+	//{
+	//	return m_iRotateMethod;
+	//}
+	//bool         TrueTypeMarkerSymbol::SetRotateMethod(int iRotateMethod)
+	//{
+	//	m_iRotateMethod = iRotateMethod;
+	//	return true;
+	//}
+	bool         TrueTypeMarkerSymbol::GetShadow(bool* pbHaveShadow, unsigned int* piShadowColor)
+	{
+		*pbHaveShadow = m_bHaveShadow;
+		*piShadowColor = m_iShadowColor;
+		return true;
+	}
+	bool         TrueTypeMarkerSymbol::SetShadow(bool bHaveShadow, unsigned int iShadhowColor)
+	{
+		m_bHaveShadow = bHaveShadow;
+		m_iShadowColor = iShadhowColor;
+		if (m_bHaveShadow)
+			clsUtil::ToCairoColor(m_iShadowColor, r_shadow, g_shadow, b_shadow, a_shadow);
+		return true;
+	}
+	int          TrueTypeMarkerSymbol::GetSlant()
+	{
+		return m_iSlant;
+	}
+	bool         TrueTypeMarkerSymbol::SetSlant(int iSlant)
+	{
+		m_iSlant = iSlant;
+		return true;
+	}
+	int          TrueTypeMarkerSymbol::GetWeight()
+	{
+		return m_iWeight;
+	}
+	bool         TrueTypeMarkerSymbol::SetWeight(int iWeight)
+	{
+		m_iWeight = iWeight;
+		return true;
+	}
+	bool         TrueTypeMarkerSymbol::GetHaveUnderLine()
+	{
+		return m_bHaveUnderLine;
+		return true;
+	}
+	bool         TrueTypeMarkerSymbol::SetHaveUnderLine(bool bHaveUnderLine)
+	{
+		m_bHaveUnderLine = bHaveUnderLine;
+		return true;
+	}
+	bool         TrueTypeMarkerSymbol::GetHaveDeleteLine()
+	{
+		return m_bHaveDeleteLine;
+	}
+	bool         TrueTypeMarkerSymbol::SetHaveDeleteLine(bool bHaveDeleteLine)
+	{
+		m_bHaveDeleteLine = bHaveDeleteLine;
+		return true;
+	}
+
+
+	void TrueTypeMarkerSymbol::TryAddField(vector<string>&pvField)
+	{
+		TryAddField2(pvField, m_sAngleField);
+	}
+
+	int TrueTypeMarkerSymbol::CalculateFontCount()
+	{
+		m_viFontCharacter.clear();
+
+		cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 10, 10);
+		cairo_t* cr = cairo_create(surface);
+
+		cairo_set_source_rgba(cr, 0, 0, 0, 1);
+		cairo_select_font_face(cr, m_sFont.c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+		cairo_set_font_size(cr, 8);
+
+		unsigned char* buffer = cairo_image_surface_get_data(surface);
+		int ls = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, 10);
+
+
+		for (int iWord = 0; iWord < 65536; iWord++)
+		{
+			char s_[5];
+			memset(s_, 0, 5);
+			if (iWord < 256)
+				s_[0] = iWord;
+			else
+			{
+				s_[0] = ((char*)(&iWord))[1];
+				s_[1] = iWord;
+			}
+
+			cairo_move_to(cr, 0, 10);
+			cairo_show_text(cr, s_);
+
+			bool bIsValid = false;
+			for (int i = 0; i < 10; i++)
+			{
+				for (int j = 0; j < 10; j++)
+				{
+					int color = ((int*)(buffer + (4 * 10 * i + 4 * j)))[0];
+					if (color)
+					{
+						bIsValid = true;
+						break;
+					}
+				}
+				if (bIsValid)
+					break;
+			}
+
+			if (bIsValid)
+			{
+				m_viFontCharacter.push_back(iWord);
+				m_pbFlag[iWord] = true;
+				memset(buffer, 0, 400);
+			}
+			else
+				m_pbFlag[iWord] = false;
+		}
+
+		cairo_destroy(cr);
+		cairo_surface_destroy(surface);
+
+		int iCount = (int)(m_viFontCharacter.size());
+		return iCount;
+	}
+/*
+	bool TrueTypeMarkerSymbol::DrawFont(Map* map, int iPerSize)
+	{
+		clsCrSurf* pClsCS = map->m_pClsSurfBuff;
+
+		cairo_t* cr = pClsCS->m_pCr;
+		int iW = pClsCS->m_iW;
+		int iColumnCount = iW / iPerSize;
+		int sz = (int)m_viFontCharacter.size();
+		int iLineCount = sz / iColumnCount;
+		if (sz != iLineCount*iColumnCount)
+			iLineCount++;
+		int iH = iLineCount* iPerSize;
+		cairo_set_source_rgba(cr, 1, 1, 1, 1);
+		cairo_rectangle(cr, 0, 0, iW, iH);
+		cairo_fill(cr);
+
+		cairo_select_font_face(cr, m_sFont.c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+		//m_sFont 是否要转字符集
+		cairo_set_font_size(cr, iPerSize);
+		cairo_set_source_rgba(cr, 0, 0, 0, 1);
+
+
+		unsigned char* buffer = cairo_image_surface_get_data(pClsCS->m_pSurf);
+
+		int iColumnIndex = 0, iLineIndex = 0;
+
+		for (int iWord = 0; iWord < 65536; iWord++)
+		{
+			if (m_pbFlag[iWord])
+			{
+				char s_[5];
+				memset(s_, 0, 5);
+				if (iWord < 256)
+					s_[0] = iWord;
+				else
+				{
+					s_[0] = ((char*)(&iWord))[1];
+					s_[1] = iWord;
+				}
+				cairo_text_extents_t extents;
+				cairo_text_extents(cr, s_, &extents);
+				double dw = extents.width;
+				double dh = extents.height;
+
+				double x_center = iColumnIndex * iPerSize + iPerSize / 2.0;
+				double y_center = iLineIndex* iPerSize + iPerSize / 2.0;
+				double x_show = 0, y_show = 0;
+				this->GetToBeCenter(x_show, y_show, &extents, x_center, y_center);
+
+				cairo_move_to(cr, x_show, y_show);
+				//cairo_move_to(cr, iColumnIndex*iPerSize + (iPerSize-dw)/2,(iLineIndex+1)*iPerSize - (iPerSize- dh)/2);
+				cairo_show_text(cr, s_);
+				iColumnIndex++;
+			}
+
+			if (iColumnIndex >= iColumnCount)
+			{
+				iColumnIndex = 0;
+				iLineIndex++;
+			}
+		}
+
+
+		cairo_set_line_width(cr, 1);
+		cairo_set_source_rgba(cr, 0, 0, 0, 1);
+		for (int i = 0; i <= iColumnCount; i++)
+		{
+			cairo_move_to(cr, iPerSize*i, 0);
+			cairo_line_to(cr, iPerSize*i, iH);
+		}
+		for (int i = 0; i <= iLineCount; i++)
+		{
+			cairo_move_to(cr, 0, iPerSize*i);
+			cairo_line_to(cr, iW, iPerSize*i);
+		}
+		cairo_stroke(cr);
+
+		map->BufferCopy();
+
+		return true;
+	}
+
+	bool TrueTypeMarkerSymbol::DrawFont(Map* map, int iPerSize, int iCharacter, double* x, double * y)
+	{
+		clsCrSurf* pClsCS = map->m_pClsSurfBuff;
+
+		cairo_t* cr = pClsCS->m_pCr;
+		int iW = pClsCS->m_iW;
+		int iColumnCount = iW / iPerSize;
+		int sz = (int)m_viFontCharacter.size();
+		int iLineCount = sz / iColumnCount;
+		if (sz != iLineCount*iColumnCount)
+			iLineCount++;
+		int iH = iLineCount* iPerSize;
+		cairo_set_source_rgba(cr, 1, 1, 1, 1);
+		cairo_rectangle(cr, 0, 0, iW, iH);
+		cairo_fill(cr);
+
+		cairo_select_font_face(cr, m_sFont.c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+		//需要转字符集?
+		cairo_set_font_size(cr, iPerSize);
+		cairo_set_source_rgba(cr, 0, 0, 0, 1);
+
+
+		unsigned char* buffer = cairo_image_surface_get_data(pClsCS->m_pSurf);
+
+		int iColumnIndex = 0, iLineIndex = 0;
+
+		for (int iWord = 0; iWord < 65536; iWord++)
+		{
+			if (m_pbFlag[iWord])
+			{
+				char s_[5];
+				memset(s_, 0, 5);
+				if (iWord < 256)
+					s_[0] = iWord;
+				else
+				{
+					s_[0] = ((char*)(&iWord))[1];
+					s_[1] = iWord;
+				}
+				cairo_text_extents_t extents;
+				cairo_text_extents(cr, s_, &extents);
+				double dw = extents.width;
+				double dh = extents.height;
+				double x_center = iColumnIndex * iPerSize + iPerSize / 2.0;
+				double y_center = iLineIndex* iPerSize + iPerSize / 2.0;
+				double x_show = 0, y_show = 0;
+				this->GetToBeCenter(x_show, y_show, &extents, x_center, y_center);
+
+				if (iWord == iCharacter)
+				{
+					cairo_set_source_rgba(cr, 17.0 / 255, 150.0 / 255, 238.0 / 255, 1);
+					cairo_rectangle(cr, iColumnIndex*iPerSize, iLineIndex*iPerSize, iPerSize, iPerSize);
+					cairo_fill(cr);
+					cairo_set_source_rgba(cr, 1, 1, 1, 1);
+					*x = iColumnIndex*iPerSize;
+					*y = (iLineIndex + 1)* iPerSize;
+
+
+					cairo_move_to(cr, x_show, y_show);
+					//cairo_move_to(cr, iColumnIndex*iPerSize + (iPerSize - dw) / 2, (iLineIndex + 1)*iPerSize - (iPerSize - dh) / 2);
+					cairo_show_text(cr, s_);
+					iColumnIndex++;
+				}
+				else
+				{
+					cairo_set_source_rgba(cr, 0, 0, 0, 1);
+					cairo_move_to(cr, x_show, y_show);
+					//cairo_move_to(cr, iColumnIndex*iPerSize + (iPerSize - dw) / 2, (iLineIndex + 1)*iPerSize - (iPerSize - dh) / 2);
+					cairo_show_text(cr, s_);
+					iColumnIndex++;
+				}
+			}
+
+			if (iColumnIndex >= iColumnCount)
+			{
+				iColumnIndex = 0;
+				iLineIndex++;
+			}
+		}
+
+
+		cairo_set_line_width(cr, 1);
+		cairo_set_source_rgba(cr, 0, 0, 0, 1);
+		for (int i = 0; i <= iColumnCount; i++)
+		{
+			cairo_move_to(cr, iPerSize*i, 0);
+			cairo_line_to(cr, iPerSize*i, iH);
+		}
+		for (int i = 0; i <= iLineCount; i++)
+		{
+			cairo_move_to(cr, 0, iPerSize*i);
+			cairo_line_to(cr, iW, iPerSize*i);
+		}
+		cairo_stroke(cr);
+
+		map->BufferCopy();
+		return true;
+	}
+
+	int TrueTypeMarkerSymbol::DrawAFont(double x, double y, Map* map_temp, Map* map, int iPerSize)
+	{
+		clsCrSurf* pClsCS = map->m_pClsSurfBuff;
+		int iW = pClsCS->m_iW;
+		int iColumnCount = iW / iPerSize;
+		int iLineIndex = (int)(y / iPerSize);
+		int iColumnIndex = (int)(x / iPerSize);
+		int iCharacterIndex = iColumnCount*iLineIndex + iColumnIndex; int iCharacterSize = (int)m_viFontCharacter.size();
+		if (iCharacterIndex >= iCharacterSize)
+			return -1;
+
+		int iWord = m_viFontCharacter[iColumnCount* iLineIndex + iColumnIndex];
+
+		char s_[5];
+		memset(s_, 0, 5);
+		if (iWord < 256)
+			s_[0] = iWord;
+		else
+		{
+			s_[0] = ((char*)(&iWord))[1];
+			s_[1] = iWord;
+		}
+
+		int maptemp_w = (int)(map_temp->m_dWidth);  // 视为正方形
+		int maptemp_h = maptemp_w;
+
+		clsCrSurf* pClsCS_temp = map_temp->m_pClsSurfBuff;
+		cairo_t* cr = pClsCS_temp->m_pCr;
+		cairo_rectangle(cr, 0, 0, maptemp_w, maptemp_h);
+		cairo_set_source_rgba(cr, 17.0 / 255, 150.0 / 255, 238.0 / 255, 1);
+		cairo_fill(cr);
+		cairo_select_font_face(cr, m_sFont.c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+		cairo_set_source_rgba(cr, 1, 1, 1, 1);
+		cairo_set_font_size(cr, maptemp_w);
+		cairo_text_extents_t extents;
+
+		cairo_text_extents(cr, s_, &extents);
+		double text_w = extents.width;
+		double text_h = extents.height;
+
+
+		double x_center = maptemp_w / 2.0;
+		double y_center = maptemp_h / 2.0;
+		double x_show = 0, y_show = 0;
+		this->GetToBeCenter(x_show, y_show, &extents, x_center, y_center);
+
+		cairo_move_to(cr, x_show, y_show);
+		//cairo_move_to(cr, (maptemp_w - text_w)/2,maptemp_h - (maptemp_h - text_h)/2);
+		cairo_show_text(cr, s_);
+
+		map_temp->BufferCopy();
+		return iWord;
+	}
+*/
+
+
+	bool TrueTypeMarkerSymbol::DrawAText(clsCrSurf* clsCS, double x, double y)
+	{
+		//this->SetCairo(clsCS);  //除非要精准控制,不然没必要在这里设置
+		cairo_t* cr = clsCS->m_pCr;
+		cairo_text_extents_t extents;
+		cairo_text_extents(cr, m_sUTF8, &extents);
+		/*x = x - extents.width / 2;
+		y = y + extents.height / 2;*/
+		x = x - (extents.x_advance) / 2;
+		y = y + (extents.height) / 2;
+
+		/*
+		阴影效果
+		*/
+		if (m_bHaveShadow)
+		{
+			cairo_set_source_rgba(cr, r_shadow, g_shadow, b_shadow, a_shadow);
+			cairo_move_to(cr, x + ShadowSize + GlowingSize, y + ShadowSize + GlowingSize);
+			cairo_show_text(cr, m_sUTF8);
+		}
+
+		/*
+		发光效果
+		*/
+		if (m_bHaveGlowing)
+		{
+			cairo_set_source_rgba(cr, r_glowing, g_glowing, b_glowing, a_glowing);
+			for (int i = -(GlowingSize); i <= GlowingSize; i++)
+			{
+				for (int j = -(GlowingSize); j <= GlowingSize; j++)
+				{
+					cairo_move_to(cr, x + i, y + j);
+					cairo_show_text(cr, m_sUTF8);
+				}
+			}
+		}
+
+		this->SetFontColor(m_iFontColor);
+		cairo_set_source_rgba(cr, r_font, g_font, b_font, a_font);
+		cairo_set_line_width(cr, 10);
+		cairo_move_to(cr, x, y);
+		/*cairo_rel_line_to(cr, 10, 0);
+		cairo_stroke(cr)*/;
+		cairo_show_text(cr, m_sUTF8);
+		int iTextW = (int)extents.x_advance; int iTextH = (int)extents.height;
+		if (m_bHaveDeleteLine)
+		{
+			cairo_set_line_width(cr, 1);
+			cairo_move_to(cr, x + extents.x_bearing, y - iTextH / 2.0 + extents.y_bearing + extents.height);
+			cairo_rel_line_to(cr, iTextW, 0);
+			cairo_stroke(cr);
+		}
+		if (m_bHaveUnderLine)
+		{
+			cairo_set_line_width(cr, 1);
+			cairo_move_to(cr, x + extents.x_bearing, y + extents.y_bearing + extents.height);
+			cairo_rel_line_to(cr, iTextW, 0);
+			cairo_stroke(cr);
+		}
+		return true;
+	}
+
+	bool TrueTypeMarkerSymbol::DrawAText(clsCrSurf* pClsCS, double x, double  y, double dAngle)
+	{
+
+		cairo_t* cr = pClsCS->m_pCr;
+		cairo_text_extents_t extents;
+		cairo_text_extents(cr, m_sUTF8, &extents);
+		int iX = (int)x;                          int iY = (int)y;
+		int iTextW = (int)(extents.x_advance);  int iTextH = (int)(extents.height);
+		int surf_w = pClsCS->m_iW;                int surf_h = pClsCS->m_iH;
+
+
+
+		{
+			//检查文字避让
+			//不避让,因为这个不认为是文字,而是看做是一个点的样式
+		}
+
+
+		{
+
+			/*
+			绘制发光
+			*/
+			if (m_bHaveGlowing)
+			{
+				int iGlowingSize = 2;
+				cairo_set_source_rgba(cr, r_glowing, g_glowing, b_glowing, a_glowing);
+				for (int i = -GlowingSize; i <= GlowingSize; i++)
+				{
+					for (int j = -GlowingSize; j <= GlowingSize; j++)
+					{
+						cairo_move_to(cr, x + i, y + j);
+						cairo_rotate(cr, dAngle);
+						cairo_show_text(cr, m_sUTF8);
+						cairo_rotate(cr, -dAngle);
+					}
+				}
+			}
+
+			/*
+			绘制阴影
+			*/
+			if (m_bHaveShadow)
+			{
+				int iShadowSize = 2;
+				cairo_set_source_rgba(cr, r_shadow, g_shadow, b_shadow, a_shadow);
+				if (m_bHaveGlowing)
+					cairo_move_to(cr, x + ShadowSize + GlowingSize, y + ShadowSize + GlowingSize);
+				else
+					cairo_move_to(cr, x + ShadowSize, y + ShadowSize);
+				cairo_rotate(cr, dAngle); cairo_show_text(cr, m_sUTF8); cairo_rotate(cr, -dAngle);
+			}
+
+
+			cairo_set_source_rgba(cr, r_font, g_font, b_font, a_font);
+			cairo_move_to(cr, x, y);
+			cairo_rotate(cr, dAngle);
+			cairo_show_text(cr, m_sUTF8);
+			cairo_rotate(cr, -dAngle);
+			if (m_bHaveDeleteLine)
+			{
+				cairo_set_source_rgba(cr, r_font, g_font, b_font, a_font);
+				cairo_set_line_width(cr, 1);
+				cairo_move_to(cr, x + extents.x_bearing, y - iTextH / 2.0 + extents.y_bearing + extents.height);
+				cairo_rotate(cr, dAngle);
+				cairo_rel_line_to(cr, iTextW, 0);
+				cairo_stroke(cr);
+				cairo_rotate(cr, -dAngle);
+			}
+			if (m_bHaveUnderLine)
+			{
+				cairo_set_line_width(cr, 1);
+				cairo_move_to(cr, x + extents.x_bearing, y + extents.y_bearing + extents.height);
+				cairo_rotate(cr, dAngle);
+				cairo_rel_line_to(cr, iTextW, 0);
+				cairo_stroke(cr);
+				cairo_rotate(cr, -dAngle);
+			}
+		}
+		return false;
+	}
+
+	bool TrueTypeMarkerSymbol::SetCairo(clsCrSurf* pClsCS)
+	{
+		cairo_t* cr = pClsCS->m_pCr;
+		cairo_select_font_face(cr, m_sFont.c_str(), (cairo_font_slant_t)m_iSlant, (cairo_font_weight_t)m_iWeight);
+		cairo_set_font_size(cr, (double)m_lFontSize);
+		clsUtil::DoSetAntialias(m_iAntialiasing, cr);
+		return true;
+	}
+	bool TrueTypeMarkerSymbol::GetToBeCenter(double & x, double & y, cairo_text_extents_t* pExtents, double x_center, double y_center)
+	{
+		x = x_center - pExtents->width / 2 - pExtents->x_bearing;
+		y = y_center - pExtents->height / 2 - pExtents->y_bearing;
+		return true;
+	}
+}
\ No newline at end of file

+#pragma once
+#ifndef _TrueTypeMarkerSymbol_H_
+#define _TrueTypeMarkerSymbol_H_
+#include"Renderer.h"
+#include<string>
+#include"clsStruct.h"
+using namespace std;
+
+
+namespace DmapCore_30
+{
+	class Map;
+	class clsCrSurf;
+	class DataCollection;
+	class CORE_EXPORT TrueTypeMarkerSymbol :public Renderer
+	{
+	public:
+
+		TrueTypeMarkerSymbol();
+		~TrueTypeMarkerSymbol();
+
+		virtual int RendererType();
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag = NULL);
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag = NULL);
+		virtual bool DrawLegend(clsCrSurf* pClsCS,  shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag = NULL);
+		virtual bool Parse(boost::property_tree::ptree &pt, AppendBuffer *f);
+		virtual void ToJson(AppendBuffer *ab);
+
+		double m_dAngle;      //旋转角度固定值
+		string m_sAngleField; //旋转角度以某个字段的数据为依据,改数据获取后会转化成 0~2π
+		/*
+		使用规定: 2016-02-18
+		优先使用 m_sAngleField,设置 m_dAngle 的时候, m_sAngleField 同时设置为 ""
+		*/
+
+
+		int          m_iAntialiasing;      //
+		long          m_lCharacter;         //文字所对应的数字 32-65535
+		double       m_dCharacterXdis;     //文字显示时的X偏移
+		double       m_dCharacterYdis;     //Y偏移
+		string       m_sFont;              //
+		unsigned int m_iFontColor;         //
+		long         m_lFontSize;          //
+		//int          m_iFontStyle;         //字体风格
+
+
+		string   m_fontname;
+		bool         m_bHaveGlowing;       //
+		unsigned int m_iGlowingColor;      //发光
+		bool         m_bHaveOutline;       //
+		unsigned int m_iOutline;           //边框
+		//int          m_iRotateMethod;      //旋转方式,角度计算方式,使用枚举,具体见esri文档
+		bool         m_bHaveShadow;        //
+		unsigned int m_iShadowColor;       //阴影
+		/*
+		文字四属性
+		*/
+		int          m_iSlant; //斜体
+		int          m_iWeight;  //加粗
+		bool         m_bHaveUnderLine; // 下划线
+		bool         m_bHaveDeleteLine; // 删除线
+
+
+		double       GetAngle();
+		bool         SetAngle(double dAngle);
+		const char*  GetAngleField();
+		bool         SetAngleField(const char* sAngleField);
+		int          GetAntialiasing();
+		bool         SetAntialiasing(int iAntialiasing);
+		long         GetCharacter();
+		bool         SetCharacter(long lCharacter);
+		bool         GetCharacterDis(double* pdXdis, double* pdYdis);
+		bool         SetCharacterDis(double xDis, double yDis);
+		const char*  GetFont();
+		bool         SetFont(const char* sFont);
+		unsigned int GetFontColor();
+		bool         SetFontColor(unsigned int iFontColor);
+		long         GetFontSize();
+		bool         SetFontSize(long lFontSize);
+		bool         GetGlowing(bool* pbHaveGlowing, unsigned int * piGlowingColor);
+		bool         SetGlowingColor(bool bHaveGlowing, unsigned int iGlowingColor);
+		/*int          GetRotateMethod();
+		bool         SetRotateMethod(int iRotateMethod);*/
+		bool         GetShadow(bool* pbHaveShadow, unsigned int* piShadowColor);
+		bool         SetShadow(bool bHaveShadow, unsigned int iShadhowColor);
+		int          GetSlant();
+		bool         SetSlant(int iSlant);
+		int          GetWeight();
+		bool         SetWeight(int iBold);
+		bool         GetHaveUnderLine();
+		bool         SetHaveUnderLine(bool bHaveUnderLine);
+		bool         GetHaveDeleteLine();
+		bool         SetHaveDeleteLine(bool bHaveDeleteLine);
+
+
+		void TryAddField(vector<string>&pvField);
+		bool TryFindHeatRenderer(){ return false; }
+
+		/*
+		DrawFont部分
+		*/
+		vector<int> m_viFontCharacter;
+		char *m_pbFlag;
+		int CalculateFontCount();
+		//bool DrawFont(Map* map, int iPerSize);
+		//bool DrawFont(Map* map, int iPerSize, int iCharater, double* x, double * y);
+		int DrawAFont(double x, double y, Map* map_temp, Map* map, int iPerSize);
+
+
+	private:
+		bool DrawAText(clsCrSurf* clsCS, double x, double y);
+		bool DrawAText(clsCrSurf* pClsCS, double x, double y, double dAngle);
+		bool SetCairo(clsCrSurf* clsCS);
+		bool GetToBeCenter(double & x, double & y, cairo_text_extents_t* pExtents, double x_center, double y_center);   //要以  x_center,y_center书写文字, 求x,y
+		char m_sUTF8[5];
+
+		double r_font, g_font, b_font, a_font;
+		double r_glowing, g_glowing, b_glowing, a_glowing;
+		double r_outline, g_outline, b_outline, a_outline;
+		double r_shadow, g_shadow, b_shadow, a_shadow;
+
+	};
+
+}
+
+#endif
\ No newline at end of file

+
+#include "ValueMapRenderer.h"
+#include"clsXML.h"
+#include "clsJson.h"
+#include"ValueMapRendererComponent.h"
+#include<map>
+using namespace std;
+#include"clsCrSurf.h"
+#include"DataCollection.h"
+#include"clsUtil.h"
+#include <boost/dll/alias.hpp> // for BOOST_DLL_ALIAS
+#include <boost/filesystem.hpp>
+#include <boost/function.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/algorithm/string.hpp>
+namespace DmapCore_30
+{
+
+	ValueMapRenderer::ValueMapRenderer()
+	{
+		m_sTag = "";
+		m_pDefaultSymbol = NULL;
+		m_sField = "";
+		m_vComponents = {};
+		m_simpleRenderer = true;
+	}
+	ValueMapRenderer::~ValueMapRenderer()
+	{
+		if (m_pDefaultSymbol)
+			m_pDefaultSymbol->Release();
+		int length = (int)m_vComponents.size();
+		if (length)
+		{
+			for (int i = 0; i < length; i++)
+				m_vComponents[i]->Release();
+			m_vComponents.clear();
+		}
+	}
+	ValueMapRenderer* ValueMapRenderer::CreateNew()
+	{
+		ValueMapRenderer * dest = new ValueMapRenderer();
+		return dest;
+	}
+	bool ValueMapRenderer::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
+	{
+	//	if (!node && !f)return false;
+
+		//clsXML clsX(f, "VALUEMAPRENDERER");
+		clsXML::XMLAttrParse(pt, f, &m_sField, "lookupfield");
+		//clsX.closeProperties();
+
+		for (auto ptchild = pt.begin(); ptchild != pt.end(); ++ptchild)
+			{
+				string sz = ptchild->first;
+				if (boost::iequals(sz, "OTHER"))
+				{
+					//rapidxml::xml_node<char>* node2 = node1->first_node();
+					clsXML::XMLParse(ptchild->first,ptchild->second,  &m_pDefaultSymbol);
+				}
+				else if (boost::iequals(sz, "EXACT")) 
+				{
+					string sValue = clsXML::XMLGetPropByString(ptchild->second, "value");
+
+					//rapidxml::xml_node<char>* node2 = node1->first_node();//exact 只有一个子节点 ,存着简单样
+					Renderer* pSymbol = NULL;
+					clsXML::XMLParse(ptchild->first, ptchild->second,  &pSymbol);
+
+					ValueMapRendererComponent* vmrc = new ValueMapRendererComponent(pSymbol, sValue);
+
+					m_vComponents.push_back(vmrc);//引用只需要一份, 无需AddRef
+				}
+				else{ ; }
+			}
+		return true;
+	}
+
+   void  ValueMapRenderer::ToJson(AppendBuffer *ab)
+   {
+	    char buff[300] = {0};
+		//char resultbuff[5000] = {0};
+		sprintf(buff, R"("VALUEMAPRENDERER":{"lookupfield":"%s","EXACT":[)",m_sField.c_str());
+		//strcat(resultbuff,buff);
+		ab->AppendString(buff);
+		int length = (int)m_vComponents.size();
+		for (int i = 0; i < length; i++)
+		{
+			if(i>0) 
+			{
+				ab->AppendString(",");
+			}
+
+			ValueMapRendererComponent* vmrc = m_vComponents[i];
+			ab->AppendString("{");
+			sprintf(buff, R"("value":"%s",)",vmrc->m_sValue.c_str());
+			ab->AppendString(buff);
+			if(vmrc->m_pSymbol)
+			{
+				vmrc->m_pSymbol->ToJson(ab);
+			}
+			ab->AppendString("}");
+		}
+		ab->AppendString("]");
+		//strcat(resultbuff, "]");
+
+		if (m_pDefaultSymbol)
+		{
+			ab->AppendString(",\"OTHER\":{");
+			this->m_pDefaultSymbol->ToJson(ab);
+			ab->AppendString("}");
+		}
+		ab->AppendString("}");
+   }
+
+
+	int ValueMapRenderer::RendererType()
+	{
+		return dmapValueMapRenderer;
+	}
+	const char* ValueMapRenderer::GetTag()
+	{
+		return m_sTag.c_str();
+	}
+	bool ValueMapRenderer::SetTag(const char* sTag)
+	{
+		if (!sTag)
+			return false;
+		m_sTag = sTag;
+		return true;
+	}
+	Renderer* ValueMapRenderer::GetDefaultSymbol()
+	{
+		if (m_pDefaultSymbol)m_pDefaultSymbol->AddRef();
+		return m_pDefaultSymbol;
+	}
+	bool ValueMapRenderer::SetDefaultSymbol(Renderer* defaultSymbol)
+	{
+		if (!defaultSymbol)
+		{
+			m_pDefaultSymbol = defaultSymbol;
+			return true;
+		}
+
+		//int renType = defaultSymbol->RendererType();
+		//AddRef 必须先执行, 有可能传入的样式和原来的样式是同一个指针, 先 Release 会内存错误
+		defaultSymbol->AddRef();
+		if (m_pDefaultSymbol)
+			m_pDefaultSymbol->Release();
+		m_pDefaultSymbol = defaultSymbol;
+		return true;
+	}
+	const char* ValueMapRenderer::GetField()
+	{
+		return m_sField.c_str();
+	}
+	bool ValueMapRenderer::SetField(const char* sField)
+	{
+		if (!sField)
+			return false;
+		m_sField = sField;
+		return true;
+	}
+	int ValueMapRenderer::GetComponentCount()
+	{
+		int length = (int)m_vComponents.size();
+		return length;
+	}
+	ValueMapRendererComponent* ValueMapRenderer::GetComponent(int index)
+	{
+		//GetIndexP(index,m_vComponents);
+		int length = (int)(m_vComponents.size());
+
+		if (index < 0 || index >= length)
+			return NULL;
+		m_vComponents[index]->AddRef();
+		return m_vComponents[index];
+
+	}
+	bool ValueMapRenderer::SetComponent(int index, ValueMapRendererComponent* component)
+	{
+		//SetIndexP(index, component, m_vComponents);
+		if (!component)return false;
+		int length = (int)(m_vComponents.size());
+		if (index >= length)
+			return false;
+		component->AddRef();
+		if (index < 0)
+			m_vComponents.push_back(component);
+		else
+		{
+			m_vComponents[index]->Release();
+			m_vComponents[index] = component;
+		}
+		return true;
+	}
+	bool ValueMapRenderer::AddComponent(ValueMapRendererComponent* component)
+	{
+		return this->SetComponent(-1, component);
+	}
+	bool ValueMapRenderer::RemoveComponent(int index)
+	{
+		int length = (int)(m_vComponents.size());
+		if (index < 0 || index >= length)
+			return false;
+
+		m_vComponents[index]->Release();
+		m_vComponents.erase(m_vComponents.begin() + index);
+		return true;
+	}
+	bool ValueMapRenderer::ClearComponents()
+	{
+		int length = (int)(m_vComponents.size());
+
+		for (int i = 0; i < length; i++)
+			m_vComponents[i]->Release();
+		m_vComponents.clear();
+		return true;
+	}
+	bool ValueMapRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
+	{
+		//找出 field 在 data 中字符串数组中的索引,这个对应的是列号
+		int index = -1;
+		int dataFieldCount = (int)(data->m_vFieldName.size());
+		for (int i = 0; i < dataFieldCount; i++)
+		{
+			if (m_sField == data->m_vFieldName[i])
+			{
+				index = i;
+				break;
+			}
+		}
+		if (index == -1)
+			return false;
+
+		/*
+		开始绘制每个结构体,调用 DrawStruct
+		*/
+		int iPartCount = data->m_iPartCount;
+		//int structType = data->m_iStructType;
+		for (int i = 0; i < iPartCount; i++)
+		{
+			string sFieldValue = data->m_vAllField[i][index];
+			Renderer* renderer = NULL;
+			bool bHaveFind = false;
+
+			int sz = m_vComponents.size();
+			for (int j = 0; j < sz; j++)
+			{
+				if (sFieldValue == m_vComponents[j]->m_sValue)
+				{
+					bHaveFind = true;
+					renderer = m_vComponents[j]->m_pSymbol;
+					break;
+				}
+			}
+			if (!bHaveFind)
+				renderer = m_pDefaultSymbol;
+
+			if (!renderer)
+				continue;
+			renderer->DrawData(pClsCS, data, i, pFlag);
+			//clsUtil::DrawStruct(pClsCS, data, i, renderer);
+		}
+		return true;
+	}
+
+	bool ValueMapRenderer::DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag)
+	{
+		//找出 field 在 data 中字符串数组中的索引,这个对应的是列号
+		int index = -1;
+		int dataFieldCount = (int)(data->m_vFieldName.size());
+		for (int i = 0; i < dataFieldCount; i++)
+		{
+			if (m_sField == data->m_vFieldName[i])
+			{
+				index = i;
+				break;
+			}
+		}
+		if (index == -1)
+			return false;
+
+		/*
+		开始绘制每个结构体,调用 DrawStruct
+		*/
+		//int iPartCount = data->m_iPartCount;
+		//int structType = data->m_iStructType;
+		//for (int i = 0; i < iPartCount; i++)
+		{
+			string sFieldValue = data->m_vAllField[dataIndex][index];
+			Renderer* renderer = NULL;
+			bool bHaveFind = false;
+
+			int sz = m_vComponents.size();
+			for (int j = 0; j < sz; j++)
+			{
+				if (sFieldValue == m_vComponents[j]->m_sValue)
+				{
+					bHaveFind = true;
+					renderer = m_vComponents[j]->m_pSymbol;
+					break;
+				}
+			}
+			if (!bHaveFind)
+				renderer = m_pDefaultSymbol;
+
+			if (!renderer)
+				return false;
+			renderer->DrawData(pClsCS, data, dataIndex, pFlag);
+		//	clsUtil::DrawStruct(pClsCS, data, i, renderer);
+		}
+		return true;
+	}
+	bool ValueMapRenderer::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag)
+	{
+		int index = -1;
+
+		if(!pLegendParamater->showclassification)
+		{
+			return false;
+		}
+		/*
+		开始绘制每个结构体,调用 DrawStruct
+		*/
+	
+		int sz = m_vComponents.size();
+		for (int j = 0; j < sz; j++)
+		{
+			Renderer* renderer = m_vComponents[j]->m_pSymbol; 
+			renderer->DrawLegend(pClsCS, pLegendParamater,layerType, (char *)m_vComponents[j]->m_sValue.c_str());
+		}
+		if(m_pDefaultSymbol)
+		{
+			m_pDefaultSymbol->DrawLegend(pClsCS, pLegendParamater,layerType, (char *)"其他");
+		}
+		return true;
+	}
+
+	void ValueMapRenderer::TryAddField(vector<string>&pvField)
+	{
+		TryAddField2(pvField, m_sField);
+	}
+}
+

+#pragma once
+#ifndef _ValueMapRenderer_H_
+#define _ValueMapRenderer_H_
+#include<map>
+using namespace std;
+#include"Renderer.h"
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/foreach.hpp>
+namespace DmapCore_30
+{
+	class ValueMapRendererComponent;
+	class DataCollection;
+	class clsCrSurf;
+	class CORE_EXPORT ValueMapRenderer :public Renderer
+	{
+	public:
+		ValueMapRenderer();
+		~ValueMapRenderer();
+		static ValueMapRenderer* CreateNew();
+		virtual int RendererType();
+		virtual bool Parse(boost::property_tree::ptree &pt, AppendBuffer *f);
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag = NULL);
+		virtual bool DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag = NULL);
+		virtual bool DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag = NULL);
+		virtual void ToJson(AppendBuffer *ab);
+
+		const char* GetTag();
+		bool SetTag(const char* sTag);
+		Renderer* GetDefaultSymbol();
+		bool SetDefaultSymbol(Renderer* defaultSymbol);
+		const char* GetField();
+		bool SetField(const char* sField);
+		int GetComponentCount();
+		ValueMapRendererComponent* GetComponent(int index);
+		bool SetComponent(int index, ValueMapRendererComponent* component);
+		bool AddComponent(ValueMapRendererComponent* component);
+		bool RemoveComponent(int index);
+		bool ClearComponents();
+
+
+		void TryAddField(vector<string>&pvField);
+		bool TryFindHeatRenderer(){ return false; }
+
+
+		string m_sTag;
+		Renderer* m_pDefaultSymbol;
+		string m_sField;
+		vector<ValueMapRendererComponent*> m_vComponents;
+	};
+
+}
+
+#endif
\ No newline at end of file

+
+#include "ValueMapRendererComponent.h"
+
+namespace DmapCore_30
+{
+	int ValueMapRendererComponent::GetN()
+	{
+		return m_iN;
+	}
+	ValueMapRendererComponent::ValueMapRendererComponent()
+	{
+		m_iN = 1;
+		m_pSymbol = NULL;
+		m_sValue = "";
+	}
+	ValueMapRendererComponent::ValueMapRendererComponent(Renderer* pSymbol, string sValue)
+	{
+		m_iN = 1;
+		m_pSymbol = pSymbol;
+		m_sValue = sValue;
+	}
+	ValueMapRendererComponent::~ValueMapRendererComponent()
+	{
+		if (m_pSymbol)
+			m_pSymbol->Release();
+	}
+	ValueMapRendererComponent* ValueMapRendererComponent::CreateNew()
+	{
+		ValueMapRendererComponent * dest = new ValueMapRendererComponent();
+		return dest;
+	}
+	bool ValueMapRendererComponent::AddRef()
+	{
+		m_iN++;
+		return true;
+	}
+	bool ValueMapRendererComponent::Release()
+	{
+		m_iN--;
+		if (m_iN < 0)
+			return false;
+		if (!m_iN)
+			delete this;
+		return true;
+	}
+
+	Renderer* ValueMapRendererComponent::GetSymbol()
+	{
+		m_pSymbol->AddRef();
+		return m_pSymbol;
+	}
+	bool ValueMapRendererComponent::SetSymbol(Renderer* pSymbol)
+	{
+		if (!pSymbol)
+			return false;
+		pSymbol->AddRef();
+		if (m_pSymbol)
+			m_pSymbol->Release();
+		m_pSymbol = pSymbol;
+		return true;
+	}
+	const char* ValueMapRendererComponent::GetValue()
+	{
+		return m_sValue.c_str();
+	}
+	bool ValueMapRendererComponent::SetValue(const char * sValue)
+	{
+		m_sValue = sValue;
+		return true;
+	}
+}
\ No newline at end of file

+#pragma once
+#ifndef _ValueMapRendererComponent_H_
+#define _ValueMapRendererComponent_H_
+#include<string>
+#ifndef _Renderer_h_
+#define _Renderer_h_
+#include "Renderer.h"
+#endif
+using namespace std;
+namespace  DmapCore_30
+{
+	class Renderer;
+	class CORE_EXPORT  ValueMapRendererComponent
+	{
+	public:
+		int GetN();
+		ValueMapRendererComponent();
+		ValueMapRendererComponent(Renderer* pSymbol, string sValue = "");
+		~ValueMapRendererComponent();
+		static ValueMapRendererComponent* CreateNew();
+		bool AddRef();
+		bool Release();
+		Renderer* GetSymbol();
+		bool SetSymbol(Renderer* pSymbol);
+		const char* GetValue();
+		bool SetValue(const char * sValue);
+
+		Renderer * m_pSymbol;
+		string m_sValue;
+	private:
+		int m_iN;
+	};
+
+}
+#endif
\ No newline at end of file

+
+#include "clsCrSurf.h"
+#include <malloc.h>
+#include <string.h>
+namespace DmapCore_30
+{
+	clsCrSurf::clsCrSurf(cairo_surface_t* surface)
+	{
+		m_pSurf = surface;
+		m_pCr = cairo_create(m_pSurf);
+		//cairo_set_antialias(m_pCr,cairo_antialias_t::CAIRO_ANTIALIAS_BEST);
+		m_iN = 1;
+		m_iW = cairo_image_surface_get_width(surface);
+		m_iH = cairo_image_surface_get_height(surface);
+		m_iBGColor = 0Xffffffff;
+		m_pFlag = 0;
+		m_isImage = true;
+	}
+
+	clsCrSurf::clsCrSurf(cairo_surface_t* surface,int w,int h,bool isImage)
+	{
+		m_pSurf = surface;
+		m_pCr = cairo_create(m_pSurf);
+		cairo_set_antialias(m_pCr,cairo_antialias_t::CAIRO_ANTIALIAS_BEST);
+		m_iN = 1;
+		m_iW = w;
+		m_iH = h;
+		m_iBGColor = 0Xffffffff;
+		m_pFlag = 0;
+		m_isImage = isImage;
+	}
+
+
+
+
+	clsCrSurf::~clsCrSurf()
+	{
+		this->DestroyCr();
+		this->DestroySurf();
+		if (m_pFlag)
+		{
+			free(m_pFlag);
+			m_pFlag = 0;
+		}
+	}
+
+	bool clsCrSurf::Release()
+	{
+		m_iN--;
+		if (m_iN < 0)
+			return false;
+		if (!m_iN)
+			delete this;
+		return true;
+	}
+
+	bool clsCrSurf::SetSurf(cairo_surface_t* surface)
+	{
+		if (surface == m_pSurf)
+			return true;
+		this->~clsCrSurf();
+
+		m_pSurf = surface;
+		m_pCr = cairo_create(m_pSurf);
+		m_iW = cairo_image_surface_get_width(m_pSurf);
+		m_iH = cairo_image_surface_get_height(m_pSurf);
+
+		return true;
+	}
+
+
+	void clsCrSurf::DestroyCr()
+	{
+		if (m_pCr)
+		{
+			cairo_destroy(m_pCr);
+			//free(m_pCr);
+			m_pCr = NULL;
+		}
+	}
+	//0x68E06B52 (libcairo - 2.dll) (DMap.exe 中)处有未经处理的异常:  0xC0000005 : 读取位置 0xFEEEFEFE 时发生访问冲突。
+	//0x68E06B52 (libcairo - 2.dll) (DMap.exe 中)处有未经处理的异常:  0xC0000005 : 读取位置 0xCDCDCDDD 时发生访问冲突。
+	void clsCrSurf::DestroySurf()
+	{
+		if (m_pSurf)
+		{
+			cairo_surface_destroy(m_pSurf);
+			//free(m_pSurf);
+			m_pSurf = NULL;
+		}
+	}
+
+	bool  clsCrSurf::InitFlag()
+	{
+		if (m_pFlag)
+		{
+			memset(m_pFlag, 0, m_iFlagW*m_iFlagH);
+			return true;
+		}
+		m_iFlagW = m_iW / gridsize;
+		m_iFlagH = m_iH / gridsize;
+		if (m_iW != (m_iFlagW*gridsize))
+			m_iFlagW++;
+		if (m_iH != (m_iFlagH*gridsize))
+			m_iFlagH++;
+
+		m_pFlag = (char*)malloc(m_iFlagW*m_iFlagH);
+
+		if (m_pFlag == 0)
+			return false;
+		memset(m_pFlag, 0, m_iFlagW*m_iFlagH);
+		return true;
+	}
+}
\ No newline at end of file

+/**************************************************************************
+* file:              clsCrSurf.h
+
+* Author:            qingxiongf
+* Date:              2021-12-12 22:58:23
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __clsCrSurf_h__
+#define __clsCrSurf_h__
+
+#include "dmap_core.h"
+#include<cairo/cairo.h>
+
+#define gridsize  2 //网格大小
+namespace DmapCore_30
+{
+	/*
+	这个类是为了处理有些地方绘图需要传cairo_t,有些地方需要传 surface_t(比如agg绘线) 而出现的
+	绘图过程中一律传递这类对象即可
+	*/
+
+
+	/*
+	是否改为这种包装??? 之前的包装不要了???
+	*/
+	class CORE_EXPORT clsCrSurf
+	{
+	public:
+		clsCrSurf(cairo_surface_t* surface);
+		clsCrSurf(cairo_surface_t* surface,int w,int h,bool isImage);
+
+		~clsCrSurf();
+		bool Release();
+		bool SetSurf(cairo_surface_t* surface);
+		bool IsImage(bool b);
+
+		cairo_t* m_pCr;
+		cairo_surface_t* m_pSurf;
+		int m_iW;
+		int m_iH;
+
+		int m_iN;    //引用计数
+
+		/*
+		文字避让部分
+		*/
+		char* m_pFlag;
+		int m_iFlagW;
+		int m_iFlagH;
+		bool  InitFlag();  // 文字避让数组初始化
+		unsigned int m_iBGColor;
+
+		bool m_isImage = true;
+
+
+	private:
+		void DestroyCr();
+		void DestroySurf();
+	};
+
+}
+
+#endif // __clsCrSurf_h__
\ No newline at end of file

+
+
+#include "clsJson.h"
+#include <stdarg.h>
+#include <string.h>
+
+namespace DmapCore_30
+{
+    void clsJson::ParseEnum(const char *name, char *resultbuff, char* buff, int v, string a1, string a2 , string a3, string a4, string a5, string a6, string a7, string a8, string a9, string a10, string a11, string a12, string a13, string a14, string a15, string a16)
+    {
+
+        string vstring = a1;
+        switch (v)
+        {
+        case 0: vstring = a1; break;
+        case 1: vstring = a2; break;
+        case 2: vstring = a3; break;
+        case 3: vstring = a4; break;
+        case 4: vstring = a5; break;
+        case 5: vstring = a6; break;
+        case 6: vstring = a7; break;
+        case 7: vstring = a8; break;
+        case 8: vstring = a9; break;
+        case 9: vstring = a10; break;
+        case 10: vstring = a11; break;
+        case 11: vstring = a12; break;
+        case 12: vstring = a13; break;
+        case 13: vstring = a14; break;
+        case 14: vstring = a15; break;
+        case 15: vstring = a16; break;
+        }
+        sprintf(buff, "\"%s\":\"%s\",", name, vstring.c_str());
+        strcat(resultbuff, buff);
+    }
+
+     void  clsJson::JsonAttrParse(const char* name,char* resultbuff,char* buff, string &v)
+     {
+         sprintf(buff, "\"%s\":\"%s\",", name, v.c_str());
+         strcat(resultbuff, buff);
+     }
+
+      void  clsJson::JsonAttrParse(const char* name,char* resultbuff,char* buff, bool &v)
+     {
+         sprintf(buff, "\"%s\":\"%s\",", name, v?"true":"false");
+         strcat(resultbuff, buff);
+     }
+
+ void  clsJson::JsonAttrParse(const char* name,char* resultbuff,char* buff, double &v)
+     {
+         sprintf(buff, "\"%s\":\"%0.2f\",", name,v);
+         strcat(resultbuff, buff);
+     }
+
+      void  clsJson::JsonAttrParse(const char* name,char* resultbuff,char* buff, int &v)
+     {
+         sprintf(buff, "\"%s\":\"%d\",", name, v);
+         strcat(resultbuff, buff);
+     }
+
+      void  clsJson::JsonAttrParse(const char* name,char* resultbuff,char* buff, long &v)
+     {
+         sprintf(buff, "\"%s\":\"%ld\",", name, v);
+         strcat(resultbuff, buff);
+     }
+
+     void clsJson::JsonAttrEnd(char* resultbuff)
+     {
+         int len = strlen(resultbuff);
+         if(len>0 && resultbuff[len-1] == ',')
+         {
+             resultbuff[len-1] = '}';
+         }
+         else
+         {
+            resultbuff[len] = '}';
+            resultbuff[len+1] = 0;
+         }
+     }
+
+
+     void clsJson::JsonAttrParseColor(const char* name,const char*name2,char* resultbuff,char* buff,unsigned int& value)
+	{
+		string sColor = "", sTransparency = "";
+		//StringHelp::ColorToString(value, sColor, sTransparency);
+		
+        sprintf(buff, "\"%s\":\"%s\",\"%s\":\"%s\",", name, sColor.c_str(),name2,sTransparency.c_str());
+        strcat(resultbuff, buff);
+	}
+
+} // namespace DmapDll
\ No newline at end of file

+#ifndef _clsJson_H_
+#define _clsJson_H_
+#include"string"
+#include "AppendBuffer.h"
+using namespace std;
+namespace DmapCore_30
+{
+	class Renderer;
+    class clsJson
+	{
+	    public:
+        static void ParseEnum(const char* name,char* resultbuff,char * buff,int, string a1 = "", string a2 = "", string a3 = "", string a4 = "", string a5 = "", string a6 = "", string a7 = "", string a8 = "", string a9 = "", string a10 = "", string a11 = "", string a12 = "", string a13 = "", string a14 = "", string a15 = "", string a16 = "");
+        static void JsonAttrParse(const char* name,char* resultbuff,char* buff, string &v);
+        static void JsonAttrParse(const char* name,char* resultbuff,char* buff, bool &v);
+        static void JsonAttrParse(const char* name,char* resultbuff,char* buff, double &v);
+        static void JsonAttrParse(const char* name,char* resultbuff,char* buff, int &v);
+        static void JsonAttrParse(const char* name,char* resultbuff,char* buff, long &v);
+        static void JsonAttrEnd(char* resultbuff);
+
+        static void JsonAttrParseColor(const char* name,const char*name2,char* resultbuff,char* buff, unsigned int&value);
+    };
+}
+
+#endif
\ No newline at end of file

+
+#include<malloc.h>
+#include "clsMalloc.h"
+#include<cstring>
+
+namespace DmapCore_30
+{
+	clsMalloc::clsMalloc()
+	{
+		m_iN = 1;
+		mem = NULL;
+	}
+	clsMalloc::clsMalloc(size_t size)
+	{
+		m_iN = 1;
+		mem = (char *)malloc(size);
+		std::memset(mem, 0, size);
+	}
+
+	clsMalloc::clsMalloc(char *c)
+	{
+		m_iN = 1;
+		mem = c;
+	}
+
+	clsMalloc::~clsMalloc(void)
+	{
+		if (mem)
+		{
+			free(mem);
+			mem = 0;
+		}
+	}
+	bool clsMalloc::AddRef()
+	{
+		m_iN++;
+		return true;
+	}
+	bool clsMalloc::Release()
+	{
+		m_iN--;
+		if (m_iN < 0)
+			return false;
+		if (!m_iN)
+			delete this;
+		return true;
+	}
+	bool clsMalloc::Destroy()
+	{
+		delete this;
+		return true;
+	}
+	bool clsMalloc::MemSet(int value, size_t size)
+	{
+		memset(mem, value, size);
+		return true;
+	}
+
+	void clsMalloc::ReMalloc(size_t size)
+	{
+		free(mem);
+		mem = (char*)malloc(size);
+		memset(mem, 0, size);
+	}
+
+	void clsMalloc::SetSize(size_t size)
+	{
+		this->size = size;
+	} 
+
+	size_t clsMalloc::GetSize()
+	{
+		return size;
+	}
+}
\ No newline at end of file

+#ifndef _clsMalloc_H_
+#define _clsMalloc_H_
+namespace DmapCore_30
+{
+	class clsMalloc
+	{
+	public:
+		clsMalloc();
+		clsMalloc(char *c);
+		clsMalloc(size_t size);
+		~clsMalloc(void);
+		bool AddRef();
+		bool Release();
+		bool Destroy();
+
+		bool MemSet(int value, size_t size);
+		void ReMalloc(size_t size);
+
+		void SetSize(size_t size);
+		size_t GetSize();
+
+		char  *mem;
+
+		size_t size;
+
+	private:
+		int m_iN;
+	};
+
+}
+
+#endif
\ No newline at end of file

+#include "clsPng.h"
+#include"clsCrSurf.h"
+namespace DmapCore_30
+{
+	clsPng::clsPng(void)
+	{
+		b = 0;
+		//b3=0;
+		//p1=0;	 
+		patta = 0;
+	}
+
+	clsPng::~clsPng(void)
+	{
+		//	if(p1){delete p1;p1=0;}
+		if (patta){ delete patta; patta = 0; };
+
+		if (b){ free(b); b = 0; }
+		//	if(b3){free(b3);b3=0;}
+	}
+
+	int clsPng::ReadPng(const char * fileName, unsigned int colorThis_)
+	{
+		try
+		{
+			//	b = (unsigned char *)malloc(1024);
+			unsigned int colorThis = colorThis_; ((char *)&colorThis)[3] = 0;
+			cairo_surface_t* image = cairo_image_surface_create_from_png(fileName);
+			clsCrSurf clsCS(image);
+			int width_image = cairo_image_surface_get_width(image); int height_image = cairo_image_surface_get_height(image);
+
+			if (width_image == 0 || height_image == 0)return 1;
+			{
+				unsigned char* b3 = cairo_image_surface_get_data(image);
+				b = (unsigned char *)malloc(4 * width_image*height_image);
+				memcpy(b, b3, 4 * width_image*height_image);
+			}
+			for (int j = 0; j < height_image; j++)
+			{
+				int *c = ((int *)(b + 4 * (width_image * j)));
+				for (int i = 0; i < width_image; i++, c++)
+				{
+					if (((unsigned char *)c)[3] == 0)
+					{
+						c[0] = colorThis;
+					}
+				}
+			}
+			int beforCount = 0, endCount = 0;
+			for (int j = 0; j < height_image; j++)
+			{
+				bool found = false;
+				int *c = ((int *)(b + 4 * (width_image * j)));
+				for (int i = 0; i < width_image; i++, c++)
+				{
+					if (((unsigned char *)c)[3] == 0)continue;
+					found = true; break;
+				}
+				if (found)break;
+				beforCount++;
+			}
+			for (int j = height_image - 1; j >= 0; j--)
+			{
+				bool found = false;
+				int *c = ((int *)(b + 4 * (width_image * j)));
+				for (int i = 0; i < width_image; i++, c++)
+				{
+					if (((unsigned char *)c)[3] == 0)continue;
+					found = true; break;
+				}
+				if (found)break;
+				endCount++;
+			}
+			if (beforCount + endCount >= height_image){ return 1; }
+			if (beforCount>0)
+			{
+				int hTemp = height_image - (beforCount + endCount);
+				memmove(b, b + beforCount*width_image * 4, hTemp*width_image * 4);
+				height_image = hTemp;
+			}
+
+			agg::rendering_buffer rbuf_img_aa;
+
+			rbuf_img_aa.attach(b, width_image, height_image, (width_image)* 4);
+			pattern_src_brightness_to_alpha_rgba8 p1(rbuf_img_aa);
+			patta = new agg::line_image_pattern<agg::pattern_filter_bilinear_rgba8>(fltr, p1);
+		}
+		catch (...)
+		{
+			return (1);
+		}
+		return 0;
+
+		/*
+	//	globeLock.Log1Message("1","aa");
+	char sz[2000];
+	int len=strlen(fileName);
+	for(int i=0;i<=len;i++)
+	{
+	if(fileName[i]=='/')
+	{
+	sz[i]='\\';
+	}
+	else
+	{
+	sz[i]=fileName[i];
+	}
+	}
+	clsPngRead read;
+	ZeroFile zeroFile;
+	zeroFile.fp=fopen(sz,"rb");
+	FILE *fp = zeroFile.fp;
+	if (!fp)
+	{
+	return (1);
+	}
+	//globeLock.Log1Message("2","aa");
+	try
+	{
+	int k=read.readpng_init(fp,&width,&height);
+	png_uint_16 rr=0,gg=0,bb=0;
+	k=read.readpng_get_bgcolor(&rr,&gg,&bb);
+	//png_uint_32 rowbytes;
+	b=read.readpng_get_image(0,&channels,&rowbytes);
+	if(channels==3&&b)
+	{
+	int rowbytes1=4*rowbytes/3;
+	png_byte *b1=(png_byte *)malloc(width*height*4);
+	for(unsigned long j=0;j<height;j++)
+	{
+	for(unsigned long i=0;i<width;i++)
+	{
+	(b1+rowbytes1*j+i*4)[0]=(b+rowbytes*j+i*3)[0];
+	(b1+rowbytes1*j+i*4)[1]=(b+rowbytes*j+i*3)[1];
+	(b1+rowbytes1*j+i*4)[2]=(b+rowbytes*j+i*3)[2];
+	(b1+rowbytes1*j+i*4)[3]=255;
+	}
+	}
+	free(b);
+	b=b1;
+	rowbytes=4*rowbytes/3;
+	}
+
+	read.readpng_cleanup(0);
+	//globeLock.Log1Message("3","aa");
+
+	unsigned long j;
+	for(j=0;j<height;j++)
+	{
+	for(unsigned long i=0;i<width;i++)
+	{
+	png_byte rrr=(b+rowbytes*j+i*4)[0];
+	//png_byte ggg=(icon+rowbytes*j+i*4)[1];
+	png_byte ggg=(b+rowbytes*j+i*4)[1];
+	png_byte bbb=(b+rowbytes*j+i*4)[2];
+	//unsigned char  aa[100];
+	//memcpy(aa,b,sizeof(aa));
+
+	if(rrr==0&&ggg==0&&bbb==0)
+	{
+	rrr=1;
+	}
+	else if(rrr==255&&ggg==255&&bbb==255)
+	{
+	//rrr=254;
+	}
+
+	(b+rowbytes*j+i*4)[0]=bbb;
+	//ggg(icon+rowbytes*j+i*4)[1];
+	(b+rowbytes*j+i*4)[2]=rrr;
+
+	if(read.color_type==6)
+	{
+	if((b+rowbytes*j+i*4)[3]==0)
+	{
+	(b+rowbytes*j+i*4)[0]=255;
+	(b+rowbytes*j+i*4)[1]=255;
+	(b+rowbytes*j+i*4)[2]=255;
+	}
+	}
+	}
+	}
+	//globeLock.Log1Message("4","aa");
+	png_byte *b3=(png_byte *)malloc(width*height*3);
+	png_byte *t=b3;
+	for(j=0;j<height;j++)
+	{
+	for(unsigned long i=0;i<width;i++)
+	{
+	png_byte rrr=(b+rowbytes*j+i*4)[0];
+	png_byte ggg=(b+rowbytes*j+i*4)[1];
+	png_byte bbb=(b+rowbytes*j+i*4)[2];
+
+	if((b+rowbytes*j+i*4)[3]==0)
+	{
+	rrr=ggg=bbb=255;
+	}
+
+	t[0]=rrr;t++;
+	t[0]=ggg;t++;
+	t[0]=bbb;t++;
+	}
+	}
+	agg::rendering_buffer rbuf_img_aa;
+	rbuf_img_aa.attach(b3,width,height,width * 3);pattern_src_brightness_to_alpha_rgba8 p1(rbuf_img_aa);
+	//;p1=new pattern_src_brightness_to_alpha_rgba8(rbuf_img_aa);
+	patta=new agg::line_image_pattern<agg::pattern_filter_bilinear_rgba8>(fltr,p1);
+
+	free(b);b=b3;
+	//free(p1);p1=0;
+	//globeLock.Log1Message("5","aa");
+	return 0;
+	}
+	catch(...)
+	{
+	return (1);
+	}
+	*/
+		//return 0;
+	}
+
+
+
+	/*
+		{
+		clsPngRead read;
+		FILE *fp = fopen("D:\\beijing\\temp\\2.png", "r+b");
+		if (!fp)
+		{
+		return (ERROR);
+		}
+		unsigned long width,height;
+		int k=read.readpng_init(fp,&width,&height);
+		png_uint_16 rr=0,gg=0,bb=0;
+		k=read.readpng_get_bgcolor(&rr,&gg,&bb);
+		int channels;png_uint_32 rowbytes;
+		png_byte *b=read.readpng_get_image(0,&channels,&rowbytes);
+
+		HDC hdc=::GetDC(0);
+		int cc=RGB(255,255,255);
+		for(int j=0;j<height;j++);
+		{
+		png_byte *brow=b+j*rowbytes;
+		for(int i=0;i<width;i++,brow+=channels)
+		{
+		int c=RGB(brow[0],brow[1],brow[2]);
+		if(c!=cc){
+		//	::SetPixel(hdc,i,j,c);
+		}
+		}
+		}
+		width=width;
+		}
+		*/
+
+}
\ No newline at end of file

+#pragma once
+
+
+namespace DmapCore_30
+{
+	class pattern_src_brightness_to_alpha_rgba8
+	{
+	private:
+		agg::rendering_buffer* m_rb;
+		pixfmt m_pf;
+	public:
+		pattern_src_brightness_to_alpha_rgba8(agg::rendering_buffer& rb) :
+			m_rb(&rb), m_pf(*m_rb) {}
+
+		unsigned width()  const { return m_pf.width(); }
+		unsigned height() const { return m_pf.height(); }
+		agg::rgba8 pixel(int x, int y) const
+		{
+			agg::rgba8 c = m_pf.pixel(x, y);
+			// c.a = brightness_to_alpha[c.r + c.g + c.b]; //stbstb
+			// c.r=255;
+			// c.g=255;
+			// c.b=255;
+			c.a = 255; //brightness_to_alpha[c.r + c.g + c.b];
+			return c;
+		}
+	};
+
+	class clsPng
+	{
+	public:
+		clsPng(void);
+	public:
+		~clsPng(void);
+		//unsigned long width,height;
+		//int channels;
+		unsigned char *b;
+	public:
+		int ReadPng(const char * fileName, unsigned int colorThis);
+
+	private:
+		agg::pattern_filter_bilinear_rgba8 fltr;
+	public:
+		agg::line_image_pattern<agg::pattern_filter_bilinear_rgba8> *patta;
+	};
+}
\ No newline at end of file

+
+#include "clsRect.h"
+#include <math.h>
+
+using namespace std;
+namespace DmapCore_30
+{
+	Rect::Rect()
+	{
+		m_dTop = 0;
+		m_dRight = 0;
+		m_dBottom = 0;
+		m_dLeft = 0;
+	}
+	Rect::Rect(double top, double right, double bottom, double left)
+	{
+		m_dTop = top;
+		m_dRight = right;
+		m_dBottom = bottom;
+		m_dLeft = left;
+	}
+
+	Rect::~Rect()
+	{
+	}
+	
+
+
+	Rect * Rect::CreateNew()
+	{
+		Rect * dest = new Rect();
+		return dest;
+	}
+
+	Rect * Rect::CreateNew(double top, double right, double bottom, double left)
+	{
+		Rect* dest = new Rect(top, right, bottom, left);
+		return dest;
+	}
+
+	bool Rect::Normal()
+	{
+		double temp;
+		if (m_dLeft > m_dRight)
+		{
+			temp = m_dLeft;
+			m_dLeft = m_dRight;
+			m_dRight = temp;
+		}
+		if (m_dBottom > m_dTop)
+		{
+			temp = m_dTop;
+			m_dTop = m_dBottom;
+			m_dBottom = temp;
+		}
+		return true;
+	}
+	bool Rect::Scale(double num)
+	{
+		//中心点为标准?
+		this->Normal();
+
+		double w = m_dRight - m_dLeft;
+		double h = m_dTop - m_dBottom;
+
+		double x = (m_dRight + m_dLeft) / 2;
+		double y = (m_dTop + m_dBottom) / 2;
+
+		double w_ = w * num;
+		double h_ = h * num;
+
+		m_dTop = y + h_ / 2;
+		m_dRight = x + w_ / 2;
+		m_dBottom = y - h_ / 2;
+		m_dLeft = x - w_ / 2;
+
+		return true;
+	}
+	double Rect::GetArea()
+	{
+		this->Normal();
+		double area = (m_dRight - m_dLeft)* (m_dTop - m_dBottom);
+		return area;
+	}
+
+	bool Rect::GetExtent(double &boxX1, double& boxX2, double &boxY1, double &boxY2)
+	{
+		if (std::fmin(boxX1, boxX2) > this->m_dRight || std::fmax(boxX1, boxX2) < this->m_dLeft ||
+				std::fmin(boxY1, boxY2) > this->m_dTop || std::fmax(boxY1, boxY2) < this->m_dBottom)
+			{
+				if (!(std::fmin(boxY1, boxY2) > this->m_dRight || std::fmax(boxY1, boxY2) < this->m_dLeft ||
+					  std::fmin(boxX1, boxX2) > this->m_dTop || std::fmax(boxX1, boxX2) < this->m_dBottom))
+				{
+					double x1 = boxX1;
+					boxX1 = boxY1;
+					boxY1 = x1;
+					double x2 = boxX2;
+					boxX2 = boxY2;
+					boxY2 = x2;
+					return true;
+				}
+			}
+
+		return false;
+	}
+
+}
\ No newline at end of file

+/**************************************************************************
+* file:              clsRect.h
+
+* Author:            qingxiongf
+* Date:              2021-12-12 23:02:19
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __clsRect_h__
+#define __clsRect_h__
+
+#include "dmap_core.h"
+
+namespace DmapCore_30
+{
+	class CORE_EXPORT Rect
+	{
+	public:
+		Rect();
+		~Rect();
+		Rect(double top, double right, double bottom, double left);
+		bool AddRef();
+		bool Release();
+		static Rect * CreateNew();
+		static Rect * CreateNew(double top, double right, double bottom, double left);
+
+		bool GetExtent(double &x1, double& x2, double &y1, double &y2);
+
+		bool Normal();
+		bool Scale(double num); // 放大 2倍 num=2 缩小两倍 num = 0.5
+		double GetArea();
+
+		double m_dLeft;
+		double m_dRight;
+		double m_dTop;
+		double m_dBottom;
+	};
+}
+
+
+#endif // __clsRect_h__

+
+#include "clsStruct.h"
+#define _USE_MATH_DEFINES
+#include<math.h>
+namespace DmapCore_30
+{
+
+	clsStruct::clsStruct()
+	{
+	}
+
+
+	clsStruct::~clsStruct()
+	{
+	}
+
+
+	bool clsStruct::GetCenter(double& x, double& y, LINE* pLine)
+	{
+		int nPoint = pLine->nPoint;
+		POINT* pPoint = pLine->p;
+		double x_max, x_min, y_max, y_min;
+		double x_, y_;
+		for (int i = 0; i < nPoint; i++)
+		{
+			x_ = pPoint[i].x;
+			y_ = pPoint[i].y;
+			if (i == 0)
+			{
+				x_max = x_min = x_;
+				y_max = y_min = y_;
+			}
+			else
+			{
+				if (x_ > x_max)x_max = x_;
+				if (x_ < x_min) x_min = x_;
+				if (y_ > y_max)y_max = y_;
+				if (y_ < y_min) y_min = y_;
+			}
+		}
+		x = (x_min + x_max) / 2;
+		y = (y_min + y_max) / 2;
+		return true;
+	}
+	bool clsStruct::GetCenter(double & x, double & y, MLINE* pMLine)
+	{
+		int nLine = pMLine->nLine;
+		clsStruct::LINE* pLine = pMLine->p;
+		double x_max, x_min, y_max, y_min;
+		double x_, y_;
+		for (int i = 0; i < nLine; i++)
+		{
+			int nPoint = (pLine + i)->nPoint;
+			clsStruct::POINT* pPoint = (pLine + i)->p;
+			for (int j = 0; j < nPoint; j++)
+			{
+				x_ = pPoint[j].x;
+				y_ = pPoint[j].y;
+				if (i == 0 && j == 0)
+				{
+					x_max = x_min = x_;
+					y_max = y_min = y_;
+				}
+				else
+				{
+					if (x_ > x_max)x_max = x_;
+					if (x_ < x_min) x_min = x_;
+					if (y_ > y_max)y_max = y_;
+					if (y_ < y_min) y_min = y_;
+				}
+			}
+		}
+		x = (x_min + x_max) / 2;
+		y = (y_min + y_max) / 2;
+		return true;
+	}
+	bool clsStruct::GetCenter(double& x, double& y, POLYGON* pPolygon)
+	{
+		return true;
+	}
+	bool clsStruct::GetCenter(double& x, double &y, MPOLYGON* pMPolygon)
+	{
+		double x_max = 0, x_min = 0, y_max = 0, y_min = 0;
+		double x_ = 0, y_ = 0;
+		int nPolygon = pMPolygon->nPolygon;
+		for (int i = 0; i < nPolygon; i++)
+		{
+			POLYGON* pPolygon = pMPolygon->p + i;
+			int nRing = pPolygon->nRing;
+			for (int j = 0; j < nRing; j++)
+			{
+				LINE* pRing = pPolygon->p + j;
+				int nPoint = pRing->nPoint;
+				for (int k = 0; k < nPoint; k++)
+				{
+					POINT* pPoint = pRing->p + k;
+					x_ = pPoint->x;
+					y_ = pPoint->y;
+					if (i == 0 && j == 0 && k == 0)
+					{
+						x_min = x_max = x_;
+						y_min = y_max = y_;
+					}
+					else
+					{
+						if (x_ > x_max)x_max = x_;
+						if (x_ < x_min) x_min = x_;
+						if (y_ > y_max)y_max = y_;
+						if (y_ < y_min) y_min = y_;
+					}
+				}
+			}
+		}
+		x = (x_max + x_min) / 2;
+		y = (y_max + y_min) / 2;
+		return true;
+	}
+	bool clsStruct::GetGravity(double& x, double&y, LINE* pLine)
+	{
+		double dLength = clsStruct::GetLength(pLine);
+
+		double dHalf = dLength / 2;
+
+		int nPoint = pLine->nPoint;
+		POINT* pPoint = pLine->p;
+		POINT* pp = pPoint;
+
+		double x1, x2, y1, y2;
+		x2 = pp->x;
+		y2 = pp->y;
+		pp++;
+
+		double len_now = 0;
+		int i = 1;
+		for (; i < nPoint; i++, pp++)
+		{
+			x1 = x2; y1 = y2;
+			x2 = pp->x;
+			y2 = pp->y;
+
+			double dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+			len_now += dL;
+			if (len_now > dHalf)
+				break;
+		}
+
+		double dDelta_ = (len_now - dHalf) / (sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1)));
+		x = x2 - (x2 - x1)*dDelta_;
+		y = y2 - (y2 - y1)*dDelta_;
+		return true;
+	}
+	bool clsStruct::GetGravity(double&x, double&y, int& iIndex, LINE*pLine)
+	{
+		double dLength = clsStruct::GetLength(pLine);
+
+		double dHalf = dLength / 2;
+
+		int nPoint = pLine->nPoint;
+		POINT* pPoint = pLine->p;
+		POINT* pp = pPoint;
+
+		double x1, x2, y1, y2;
+		x2 = pp->x;
+		y2 = pp->y;
+		pp++;
+
+		double len_now = 0;
+		int i = 1;
+		for (; i < nPoint; i++, pp++)
+		{
+			x1 = x2; y1 = y2;
+			x2 = pp->x;
+			y2 = pp->y;
+
+			double dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+			len_now += dL;
+			if (len_now > dHalf)
+				break;
+		}
+
+		double dDelta_ = (len_now - dHalf) / (sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1)));
+		x = x2 - (x2 - x1)*dDelta_;
+		y = y2 - (y2 - y1)*dDelta_;
+		iIndex = i - 1;
+		return true;
+	}
+	bool clsStruct::GetGravity(double& x, double&y, MLINE* pMLine)
+	{
+		return clsStruct::GetGravity(x, y, pMLine->p);
+	}
+	bool clsStruct::GetGravity(double& x, double&y, int& iIndex, MLINE* pMLine)
+	{
+		return clsStruct::GetGravity(x, y, iIndex, pMLine->p);
+	}
+
+
+	bool clsStruct::GetGravity(double& x, double&y, POLYGON* pPolygon)
+	{
+		return true;
+	}
+
+
+	bool clsStruct::GetGravity(double& x, double&y, MPOLYGON* pMPolygon)
+	{
+		//不能认为是第一个环的重心,需要找出面积最大的环
+
+		int iPolygonIndex, iRingIndex;
+		int iMaxPolygonIndex, iMaxRingIndex;
+		double area, dMaxArea;
+
+		int nPolygon = pMPolygon->nPolygon;
+		POLYGON* pPolygon = pMPolygon->p;
+
+		for (iPolygonIndex = 0; iPolygonIndex < nPolygon; iPolygonIndex++)
+		{
+
+			int nRing = (pPolygon + iPolygonIndex)->nRing;
+			LINE* pRing = (pPolygon + iPolygonIndex)->p;
+
+			for (iRingIndex = 0; iRingIndex < nRing; iRingIndex++)
+			{
+				area = 0;
+				int nPoint = (pRing + iRingIndex)->nPoint;
+				POINT* pPoint = (pRing + iRingIndex)->p;
+
+				double x1, y1, x2, y2;
+				for (int i = 0; i < nPoint - 1; i++)
+				{
+					x1 = (pPoint + i)->x; y1 = (pPoint + i)->y;
+					x2 = (pPoint + i + 1)->x; y2 = (pPoint + i + 1)->y;
+
+					area += (x1 * y2 - x2 * y1) / 2;
+				}
+
+				x1 = (pPoint + nPoint - 1)->x;
+				y1 = (pPoint + nPoint - 1)->y;
+				x2 = pPoint->x;
+				y2 = pPoint->y;
+				area += (x1 * y2 - x2 * y1) / 2;
+				area = fabs(area);
+
+				if (iPolygonIndex == 0 && iRingIndex == 0)
+				{
+					dMaxArea = area;
+					iMaxPolygonIndex = iPolygonIndex;
+					iMaxRingIndex = iRingIndex;
+				}
+				else
+				{
+					if (dMaxArea < area)
+					{
+						dMaxArea = area;
+						iMaxPolygonIndex = iPolygonIndex;
+						iMaxRingIndex = iRingIndex;
+					}
+				}
+			}
+		}
+
+		LINE* pRing = (pMPolygon->p + iMaxPolygonIndex)->p + iMaxRingIndex;
+
+		int nPoint = pRing->nPoint;
+		POINT* p = pRing->p;
+
+		double x1, y1, x2, y2;
+		x = 0; y = 0;
+		for (int i = 0; i < nPoint - 1; i++)
+		{
+			x1 = (p + i)->x;
+			x2 = (p + i + 1)->x;
+			y1 = (p + i)->y;
+			y2 = (p + i + 1)->y;
+
+			x += (x1*y2 - x2*y1)*(x1 + x2);
+			y += (x1 * y2 - x2*y1)* (y1 + y2);
+		}
+
+		x1 = (p + nPoint - 1)->x; y1 = (p + nPoint - 1)->y;
+		x2 = p->x; y2 = p->y;
+
+		x += (x1*y2 - x2*y1)*(x1 + x2);
+		y += (x1 * y2 - x2*y1)* (y1 + y2);
+
+		x /= 6 * dMaxArea;
+		y /= 6 * dMaxArea;
+		return true;
+	}
+
+	bool clsStruct::GetRingGravity(double& x, double & y, LINE* pRing)
+	{
+		double area = 0;
+		x = 0; y = 0;
+
+		int nPoint = pRing->nPoint;
+		POINT* p = pRing->p;
+		double x1, y1, x2, y2;
+
+		for (int i = 0; i < nPoint; i++)
+		{
+			x1 = (p + i)->x; y1 = (p + i)->y;
+			if (i == nPoint - 1)
+			{
+				x2 = p->x; y2 = p->y;
+			}
+			else
+			{
+				x2 = (p + i + 1)->x;
+				y2 = (p + i + 1)->y;
+			}
+
+			area += (x1*y2 - x2*y1) / 2;
+			x += (x1*y2 - x2*y1)*(x1 + x2);
+			y += (x1 * y2 - x2*y1)* (y1 + y2);
+		}
+
+		x /= 6 * area;
+		y /= 6 * area;
+		return true;
+	}
+
+	bool clsStruct::GetStart(MLINE*pMLine, double& x1, double&y1, double&x2, double&y2)
+	{
+		LINE* pLine = pMLine->p;
+		POINT* pPoint1 = pLine->p;
+		POINT* pPoint2 = pLine->p + 1;
+		x1 = pPoint1->x;
+		y1 = pPoint1->y;
+		x2 = pPoint2->x;
+		y2 = pPoint2->y;
+		return true;
+	}
+	bool clsStruct::GetEnd(MLINE* pMLine, double&x1, double&y1, double&x2, double&y2)
+	{
+		LINE* pLine = pMLine->p;
+		int nPoint = pLine->nPoint;
+		POINT* pPoint1 = pLine->p + nPoint - 1;
+		POINT* pPoint2 = pLine->p + nPoint - 2;
+		x1 = pPoint1->x;
+		y1 = pPoint1->y;
+		x2 = pPoint2->x;
+		y2 = pPoint2->y;
+		return true;
+	}
+	bool clsStruct::GetCenter(MLINE* pMLine, double &x1__, double&y1__, double&x2__, double&y2__)
+	{
+
+		LINE* pLine = pMLine->p;
+		int nPoint = pLine->nPoint;
+		double dLength = 0;
+		//计算总长
+
+		double x1, x2, y1, y2;
+		x2 = pLine->p->x;
+		y2 = pLine->p->y;
+
+		POINT* pp = pLine->p;
+		pp++;
+		int i;
+		for (i = 1; i < nPoint; i++, pp++)
+		{
+			x1 = x2; y1 = y2;
+			x2 = pp->x;
+			y2 = pp->y;
+			double dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+			dLength += dL;
+		}
+
+
+
+		//找出中心点所在线段索引
+		x2 = pLine->p->x;
+		y2 = pLine->p->y;
+		pp = pLine->p; pp++;
+		double dHalf = dLength / 2;
+		double dNow = 0;
+		for (i = 1; i < nPoint; i++, pp++)
+		{
+			x1 = x2; y1 = y2;
+			x2 = pp->x;
+			y2 = pp->y;
+			double dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+			dNow += dL;
+			if (dNow >= dHalf)
+				break;
+		}
+		//中心点所在线段的第二个顶点索引为当前 i
+
+		//赋值
+		x2__ = pp->x;
+		y2__ = pp->y;
+		pp--;
+		x1__ = pp->x;
+		y1__ = pp->y;
+
+
+		return true;
+	}
+
+	double clsStruct::GetLength(LINE* pLine)
+	{
+		POINT* pPoint = pLine->p;
+		int nPoint = pLine->nPoint;
+
+		double dLength = 0;
+
+		double x1, x2, y1, y2;
+
+		POINT* pp = pPoint;
+		x2 = pp->x;
+		y2 = pp->y;
+		pp++;
+
+		for (int i = 1; i < nPoint; i++, pp++)
+		{
+			x1 = x2; y1 = y2;
+			x2 = pp->x;
+			y2 = pp->y;
+			double dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+			dLength += dL;
+		}
+
+		return dLength;
+	}
+
+	double clsStruct::GetLength5(LINE* pLine, int & iPointIndex, double &beginX, double &beginY, double& dRadia,  int w, int h, double dw)
+	{
+		POINT* pPoint = pLine->p;
+		int nPoint = pLine->nPoint;
+
+		double dLength = 0;
+
+		double x1=0, x2=0, y1=0, y2=0;
+
+		POINT* pp = pPoint;
+		int i = 0;
+		
+		for (; i < nPoint; i += 1, pp += 1)
+		{
+			if (pp->x >0 && pp->x<w && pp->y>0 && pp->y<h)
+			{
+				x2 = pp->x;
+				y2 = pp->y;
+				break;
+			}
+		}
+
+		while (i < nPoint)
+		{
+			beginX = pp->x;
+			beginY = pp->y;
+			iPointIndex = i;
+			x1 = 0;
+			y1 = 0;
+			double px = 0;
+			double py = 0;
+
+			double dr = 0;
+			dLength = 0;
+
+
+			for (i += 1, pp += 1; i < nPoint; i += 1, pp += 1)
+			{
+				if (pp->x >0 && pp->x<w && pp->y>0 && pp->y<h && pp->x != beginX)
+				{
+					x1 = x2; y1 = y2;
+					x2 = pp->x;
+					y2 = pp->y;
+				
+
+					if (px == 0 && py == 0)
+					{
+						px = x2 - x1;
+						py = y2 - x1;
+						dr = atan((y2 - beginY)/(x2 - beginX));
+
+					}
+					else
+					{
+						double d0 = atan((y2 - beginY)/(x2 - beginX));
+
+						if (fabs(d0-dr)> 0.05)
+						{
+							if (dLength > dw*2)
+							{
+								dRadia = atan((y1 - beginY) / (x1 - beginX));
+								if (beginX > x1)
+								{
+									beginX = x1;
+									beginY = y1 + 3;
+								}
+								else
+								{
+									beginY += 3;
+								}
+
+							}
+							break;
+						}
+					}
+					double dL = sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+					dLength += dL;
+				}
+				else
+				{
+					break;
+				}
+			}
+
+			if ((dLength > 2 * dw || i == nPoint) && x2 - beginX>1)
+			{
+				double d0 = atan((y2 - beginY) / (x2 - beginX));
+				dRadia = atan((y1 - beginY) / (x1 - beginX));
+				if (beginX > x1)
+				{
+					beginX = x1;
+					beginY = y1 + 3;
+				}
+				else
+				{
+					beginY += 3;
+				}
+				return dLength;
+			}
+		}
+		
+		//if (i == nPoint && dLength > dw)
+		//{
+		//	double d0 = atan((y2 - beginY) / (x2 - beginX));
+		//	dRadia = atan((y1 - beginY) / (x1 - beginX));
+		//	if (abs(d0) < 0.62)
+		//	{
+		//		//dRadia
+
+		//		if (x1 < beginX)
+		//		{
+		//			beginX = x1;
+		//			beginY = y1;
+		//		}
+
+		//	/*	beginX = (x1 ) / 2;
+		//		beginY = (y1 + beginY) / 2 + 3;*/
+		//		return dLength;
+		//	}
+		//}
+
+		return 0;
+	}
+
+	double clsStruct::GetMaxRing(MPOLYGON* pMPolygon, int& iPolygonIndex, int& iRingIndex)
+	{
+		int nPolygon = pMPolygon->nPolygon;
+		POLYGON* pPolygon = pMPolygon->p;
+		nPolygon = nPolygon;
+		double dMaxArea;
+
+		for (int i = 0; i < nPolygon; i++)
+		{
+			int nRing = (pPolygon + i)->nRing;
+			LINE* pRing = (pPolygon + i)->p;
+
+			for (int j = 0; j < nRing; j++)
+			{
+				LINE* pp = pRing + j;
+				int nPoint = (pRing + j)->nPoint;
+				POINT* pPoint = (pRing + j)->p;
+
+				double x1, y1, x2, y2, area = 0;
+				for (int k = 0; k < nPoint - 1; k++)
+				{
+					x1 = (pPoint + k)->x; y1 = (pPoint + k)->y;
+					x2 = (pPoint + k + 1)->x; y2 = (pPoint + k + 1)->y;
+
+					area += (x1*y2 - x2*y1) / 2;
+					area = area;
+				}
+				x1 = (pPoint + nPoint - 1)->x;
+				y1 = (pPoint + nPoint - 1)->y;
+				x2 = pPoint->x;
+				y2 = pPoint->y;
+				area += (x1 * y2 - x2 * y1) / 2;
+				area = fabs(area);
+
+
+				if (i == 0 && j == 0)
+				{
+					dMaxArea = area;
+					iPolygonIndex = i;
+					iRingIndex = j;
+				}
+				else
+				{
+					if (dMaxArea < area)
+					{
+						dMaxArea = area;
+						iPolygonIndex = i;
+						iRingIndex = j;
+					}
+				}
+			}
+		}
+
+		return dMaxArea;
+	}
+
+	bool clsStruct::GetConvexRing(clsStruct::LINE* pRing, std::vector<double>&vX, std::vector<double>& vY)
+	{
+		//使用卷包裹法
+
+		vX.clear(); vY.clear();
+
+		int nPoint = pRing->nPoint; clsStruct::POINT* pPoint = pRing->p;
+
+		double y_min = pPoint->y; int iYMinIndex = 0;
+
+		//找出最低点
+
+		for (int i = 1; i < nPoint; i++)
+		{
+			double y = (pPoint + i)->y;
+			if (y < y_min)
+			{
+				y_min = y;
+				iYMinIndex = i;
+			}
+			else if (y == y_min && ((pPoint + i)->x < (pPoint + iYMinIndex)->x))
+				iYMinIndex = i;
+		}
+
+
+		double x, y;
+
+		int iIndexNow, iIndexLast;
+
+		iIndexNow = iYMinIndex;
+		/*x = (pPoint + iIndexNow)->x; y = (pPoint + iIndexNow)->y;
+		vX.push_back(x);  vY.push_back(y);*/
+
+		iIndexNow = clsStruct::GetNextConvexPointMin(pRing, iIndexNow);
+		iIndexLast = iYMinIndex;
+		x = (pPoint + iIndexNow)->x; y = (pPoint + iIndexNow)->y;
+		vX.push_back(x);  vY.push_back(y);
+
+		while (iIndexNow != iYMinIndex)
+		{
+			int iIndexTemp = clsStruct::GetNextConvexPointRotate(pRing, iIndexNow, iIndexLast);
+			iIndexLast = iIndexNow; iIndexNow = iIndexTemp;
+			x = (pPoint + iIndexNow)->x; y = (pPoint + iIndexNow)->y;
+			vX.push_back(x);  vY.push_back(y);
+		}
+
+		return true;
+	}
+
+	int clsStruct::GetNextConvexPointMin(LINE* pRing, int iPointIndexNow)
+	{
+		//返回下一个凸点的索引
+
+		int nPoint = pRing->nPoint;
+		clsStruct::POINT* pPoint = pRing->p;
+
+		double x1, y1, x2, y2;
+		x1 = (pPoint + iPointIndexNow)->x;
+		y1 = (pPoint + iPointIndexNow)->y;
+
+		double dAngleMin = 2 * M_PI, dAngle;
+		int iAngleMinIndex;
+
+		for (int i = 0; i < nPoint; i++)
+		{
+			x2 = (pPoint + i)->x;
+			y2 = (pPoint + i)->y;
+
+			if ((x1 == x2) && (y1 == y2))
+				continue;   //重合的点不考虑
+			if (y1 == y2)
+			{
+				if (x1 < x2)
+					dAngle = M_PI / 2;
+				else
+					dAngle = 3 * M_PI / 2;
+			}
+			else
+			{
+				dAngle = atan((y2 - y1) / (x2 - x1));
+
+				if (x1>x2)
+					dAngle += M_PI;
+				if (dAngle < 0)
+					dAngle += 2 * M_PI;
+			}
+
+			if (dAngle < dAngleMin)
+			{
+				dAngleMin = dAngle;
+				iAngleMinIndex = i;
+			}
+		}
+
+
+		return iAngleMinIndex;
+	}
+
+	int clsStruct::GetNextConvexPointRotate(LINE* pRing, int iPointIndexNow, int iPointIndexLast)
+	{
+		//返回下一个凸点的索引
+
+		int nPoint = pRing->nPoint;
+		clsStruct::POINT* pPoint = pRing->p;
+
+		double x1, y1, x2, y2;
+		x1 = (pPoint + iPointIndexNow)->x;
+		y1 = (pPoint + iPointIndexNow)->y;
+		x2 = (pPoint + iPointIndexLast)->x;
+		y2 = (pPoint + iPointIndexLast)->y;
+
+		double dAngleRotate;
+		if (x1 == x2)
+		{
+			if (y1 > y2)
+				dAngleRotate = 3 * M_PI / 2;
+			else
+				dAngleRotate = M_PI / 2;
+		}
+		else
+		{
+			dAngleRotate = atan((y1 - y2) / (x1 - x2));
+			if (x1 < x2)
+				dAngleRotate += M_PI;
+		}
+
+
+
+		double dAngleMin = 2 * M_PI, dAngle, x, y, x2_, y2_;
+		int iAngleMinIndex;
+
+		for (int i = 0; i < nPoint; i++)
+		{
+			x = (pPoint + i)->x;
+			y = (pPoint + i)->y;
+			/*
+			x0= (x - rx0)*cos(a) - (y - ry0)*sin(a) + rx0 ;
+			y0= (x - rx0)*sin(a) + (y - ry0)*cos(a) + ry0 ;
+			*/
+			x2_ = (x - x1)*cos(-dAngleRotate) - (y - y1)*sin(-dAngleRotate) + x1;
+			y2_ = (x - x1)*sin(-dAngleRotate) + (y - y1)*cos(-dAngleRotate) + y1;
+
+			if ((x1 == x2) && (y1 == y2))
+				dAngle = 2 * M_PI;    //重合的点不考虑
+			else if (y1 == y2_)
+			{
+				if (x1 < x2_)
+					dAngle = M_PI / 2;
+				else
+					dAngle = 3 * M_PI / 2;
+			}
+			else
+			{
+				dAngle = atan((y2_ - y1) / (x2_ - x1));
+
+				if (x1>x2_)
+					dAngle += M_PI;
+				if (dAngle < 0)
+					dAngle += 2 * M_PI;
+			}
+
+			if (dAngle < dAngleMin)
+			{
+				dAngleMin = dAngle;
+				iAngleMinIndex = i;
+			}
+		}
+
+
+
+		return iAngleMinIndex;
+	}
+
+
+	bool clsStruct::GetIsInRing(LINE* pRing, double x, double y)
+	{
+		int iCount = 0, nPoint = pRing->nPoint;
+		POINT* pPoint = pRing->p;
+		double  x1, y1, x2, y2;
+
+		for (int i = 0; i < nPoint; i++)
+		{
+			x1 = (pPoint + i)->x;
+			y1 = (pPoint + i)->y;
+			if (i == nPoint - 1)
+			{
+				x2 = pPoint->x;
+				y2 = pPoint->y;
+			}
+			else
+			{
+				x2 = (pPoint + i + 1)->x;
+				y2 = (pPoint + i + 1)->y;
+			}
+
+			if (((x1 > x) && (x2 > x)) && ((y1 > y) && (y2 < y) || ((y1 < y) && (y2 > y))))
+				iCount++;
+		}
+
+
+		return (iCount & 1);
+	}
+
+}
\ No newline at end of file

+#ifndef _clsStruct_H_
+#define _clsStruct_H_
+#include<vector>
+namespace DmapCore_30
+{
+	class clsMalloc;
+	class Rect;
+	class clsStruct
+	{
+	public:
+		clsStruct();
+		~clsStruct();
+		 enum StructType
+		{
+			Struct_Point = 0,
+			Struct_Line = 1,
+			Struct_MLine = 2,
+			Struct_Polygon = 3,
+			Struct_MPolygon = 4,
+			Struct_Heat = 4
+		};
+		struct POINT
+		{
+			double x;
+			double y;
+		};
+		struct POLY_STRUCT
+		{
+			int nPoint;
+			POINT* pPoint;
+			int nPartCount;
+			clsMalloc* pPartStart;
+			clsMalloc* pAllFieldName;
+			clsMalloc* pAllFields;  //除shape之外的所有字段
+		};
+		
+		struct LINE
+		{
+			int nPoint;
+			POINT* p;
+		};
+		struct MLINE
+		{
+			int nLine;
+			LINE* p;
+		};
+		struct POLYGON
+		{
+			int nRing;
+			LINE* p;
+		};
+		struct MPOLYGON
+		{
+			int nPolygon;
+			POLYGON* p;
+		};
+
+		static bool GetCenter(double& x, double& y, LINE* pLine);
+		static bool GetCenter(double & x, double & y, MLINE* pMLine);
+		static bool GetCenter(double& x, double& y, POLYGON* pPolygon);
+		static bool GetCenter(double& x, double &y, MPOLYGON* pMPolygon);
+		static bool GetGravity(double& x, double&y, LINE* pLine);
+		static bool GetGravity(double&x, double&y, int& iIndex, LINE*pLine);
+		static bool GetGravity(double& x, double&y, MLINE* pMLine);
+		static bool GetGravity(double& x, double&y, int& iIndex, MLINE* pMLine);
+		static bool GetGravity(double& x, double&y, POLYGON* pPolygon);
+		static bool GetGravity(double& x, double&y, MPOLYGON* pMPolygon);
+		static bool GetRingGravity(double& x, double & y, LINE* pRing);
+
+		//获取起点线段,终点线段,中心点线段
+		//不考虑一个multilinestring 有多条line
+		static bool GetStart(MLINE*pMLine, double& x1, double&y1, double&x2, double&y2);
+		static bool GetEnd(MLINE* pMLine, double&x1, double&y1, double&x2, double&y2);
+		static bool GetCenter(MLINE* pMLine, double &x1, double&y1, double&x2, double&y2);
+		static double GetLength(LINE* pLine);  //计算长度
+		static double GetLength5(LINE* pLine, int & iPointIndex, double& beginX, double &beginY, double& dRadia,  int w, int h, double dw); //简单计算长度
+
+		static double GetMaxRing(MPOLYGON* pMPolygon, int& iPolygonIndex, int& iRingIndex);
+		static bool GetConvexRing(LINE* pRing, std::vector<double>&vX, std::vector<double>& vY);  //计算多边形凸壳
+		static int GetNextConvexPointMin(LINE* pRing, int iPointIndexNow);
+		static int GetNextConvexPointRotate(LINE* pRing, int iPointIndexNow, int iPointIndexLast);
+
+
+		static bool GetIsInRing(LINE* pRing, double x, double y);
+	};
+
+}
+
+#endif
\ No newline at end of file

+#include "clsUtil.h"
+#include<stdlib.h>
+#include"DataCollection.h"
+#include"clsCrSurf.h"
+#include"Renderer.h"
+#include"clsStruct.h"
+#include"SimpleMarkerSymbol.h"
+#include"SimpleLabelRenderer.h"
+#include"SimpleLineSymbol.h"
+#include"SimplePolygonSymbol.h"
+#include"iconv.h"
+#include"clsMalloc.h"
+#include"clsRect.h"
+#define _USE_MATH_DEFINES
+#include<math.h>
+//#include <io.h>
+#include <iostream>
+
+#include <vector>
+#include <stdarg.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+namespace DmapCore_30
+{
+
+	clsUtil::clsUtil()
+	{
+	}
+
+
+	clsUtil::~clsUtil()
+	{
+	}
+
+
+	unsigned int clsUtil::RandomColor()
+	{
+		int r = 10 + rand() % 200;
+		int g = 10 + rand() % 200;
+		int b = 10 + rand() % 200;
+		int a = 255;
+		//int a = 110 + rand() % 100;
+		//unsigned int color = (((int)(r * 255)) << 16) + (((int)(g * 255)) << 8) + (int)(b * 255) + 0xff000000;
+		//unsigned int color = (((int)(r * 255)) << 16) + (((int)(g * 255)) << 8) + (int)(b * 255) + (((int)(a*255)) << 24);
+		unsigned int color = (r << 16) + (g << 8) + b + (a << 24);
+		return color;
+	}
+
+	bool clsUtil::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 clsUtil::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;
+	}
+
+	bool clsUtil::ToCairoColor(unsigned int Color, double& r, double& g, double& b)
+	{
+		r = ((double)(((unsigned char *)(&Color))[2])) / 255.0;
+		g = ((double)(((unsigned char *)(&Color))[1])) / 255.0;
+		b = ((double)(((unsigned char *)(&Color))[0])) / 255.0;
+		r += 0.001;
+		g += 0.001;
+		b += 0.001;
+		return true;
+	}
+	bool clsUtil::ToCairoColor(unsigned int Color, double &r, double & g, double& b, double&a)
+	{
+		a = ((double)(((unsigned char *)(&Color))[3])) / 255.0;
+		r = ((double)(((unsigned char *)(&Color))[2])) / 255.0;
+		g = ((double)(((unsigned char *)(&Color))[1])) / 255.0;
+		b = ((double)(((unsigned char *)(&Color))[0])) / 255.0;
+		a += 0.001; r += 0.001; g += 0.001; b += 0.001;                 //这个做法保证令小数转回整数再取整时能不因为double的误差而小1
+		return true;
+	}
+
+	int clsUtil::Hex2int(char c)
+	{
+		if ((c >= 'A') && (c <= 'Z'))
+		{
+			return c - 'A' + 10;
+		}
+		else if ((c >= 'a') && (c <= 'z'))
+		{
+			return c - 'a' + 10;
+		}
+		else if ((c >= '0') && (c <= '9'))
+		{
+			return c - '0';
+		}
+	}
+
+	bool clsUtil::ToCairoColor(string color, double &r, double & g, double& b, double&a)
+	{
+		if(color.at(0) == '#' && ( color.size()== 7 || color.size()== 9 ))
+		{
+			int index = 1;
+			if(color.size()== 9)
+			{a = Hex2int(color.at(index)* 16 + Hex2int(color.at(index+1))) / 255.0; index += 2;}
+		
+			r = Hex2int(color.at(index)* 16 + Hex2int(color.at(index+1))) / 255.0; index += 2;
+			g = Hex2int(color.at(index)* 16 + Hex2int(color.at(index+1))) / 255.0; index += 2;
+			b = Hex2int(color.at(index)* 16 + Hex2int(color.at(index+1))) / 255.0; index += 2;
+		}
+	}
+
+	bool clsUtil::ReadHead(unsigned char* & here, int& not_big1, int & shapetype)
+	{
+		not_big1 = here[0];
+		here++;                                                    //取not_big 
+		if (!not_big1)
+			clsUtil::Exchange4(here);
+		shapetype = ((int*)here)[0];
+		here += 4;                                                  //取shapetype    
+		if (shapetype > 1000)
+		{
+			shapetype %= 16 * 16;
+			here += 4;
+		}
+		return true;
+	}
+
+	int clsUtil::ReadInt(unsigned char*& here, int  not_big1)
+	{
+		clsMalloc clsM(4);
+		unsigned char* mem = (unsigned char*)clsM.mem;
+		memcpy(mem, here, 4);
+		if (!not_big1)
+			clsUtil::Exchange4(mem);
+		int num = ((int*)mem)[0];
+		here += 4;
+		return num;
+	}
+
+
+
+	int clsUtil::ReadByte(unsigned char*& here)
+	{
+		if(strcmp((char *)here, "") ==0){
+			return 0;
+		}
+		int num = ((char*)here)[0];
+		here++;
+		return num;
+	}
+
+	
+
+	double clsUtil::ReadDouble(unsigned char*& here, int not_big)
+	{
+		clsMalloc clsM(8);
+		unsigned char* mem = (unsigned char*)clsM.mem;
+		memcpy(mem, here, 8);
+		if (!not_big)
+			clsUtil::Exchange8(mem);
+		double num = ((double*)mem)[0];
+		here += 8;
+		return num;
+	}
+
+	char * clsUtil::ConvertEnc(char *encFrom, char *encTo, const char * in, char *bufout, size_t lenout)
+	{
+		char  *sin, *sout;
+		int  lenin, ret;
+		iconv_t c_pt;
+
+		if ((c_pt = iconv_open(encTo, encFrom)) == (iconv_t)-1)     { return NULL; }
+		iconv(c_pt, NULL, NULL, NULL, NULL);
+		lenin = strlen(in) + 1;
+		sin = (char *)in;
+		sout = bufout;
+		ret = iconv(c_pt, (char **)&sin, (size_t *)&lenin, &sout, (size_t *)&lenout);
+		if (ret == -1)
+		{
+			return NULL;
+		}
+		iconv_close(c_pt);
+		return bufout;
+	}
+
+	bool  clsUtil::ConvertEncUTF8_GB18030(const char *from, clsMalloc &m)
+	{
+		int len = strlen(from);
+		char* sz = (char*)malloc(len + 1);
+		m.mem = sz;
+		//strcpy(sz, from); return true;
+		clsUtil::ConvertEnc("UTF-8", "GB18030", from, m.mem, len + 1);
+
+		return true;
+	}
+
+	bool  clsUtil::ConvertEncGB18030_UTF8(const char* from, clsMalloc &m)
+	{
+		int len = strlen(from);
+		char* sz = (char*)malloc(6 * len + 100);
+		m.mem = sz;
+
+		clsUtil::ConvertEnc("GB18030", "UTF-8", from, m.mem, 6 * len + 100);
+
+		return true;
+
+	}
+
+	bool clsUtil::DoSetLineType(int LineType, cairo_t* cr)
+	{
+		switch (LineType)
+		{
+		case dmapLineTypeSolid:
+		{
+								  double dashes1[] = { 10, 0 };
+								  int ndash1 = sizeof (dashes1) / sizeof(dashes1[0]);
+								  double offset1 = 0;
+								  cairo_set_dash(cr, dashes1, ndash1, offset1);
+								  break;
+		}
+		case (dmapLineTypeDash) :
+		{
+									double dashes1[] = { 50, 10 };
+									int ndash1 = sizeof (dashes1) / sizeof(dashes1[0]);
+									double offset1 = 0;
+									cairo_set_dash(cr, dashes1, ndash1, offset1);
+									break;
+		}
+		case (dmapLineTypeDot) :
+		{
+								   double dashes2[] = { 10, 10 };
+								   int ndash2 = sizeof (dashes2) / sizeof(dashes2[0]);
+								   double offset2 = 0;
+								   cairo_set_dash(cr, dashes2, ndash2, offset2);
+								   break;
+		}
+		case (dmapLineTypeDashDot) :
+		{
+									   double dashes3[] = { 50, 10, 10, 10 };
+									   int ndash3 = sizeof (dashes3) / sizeof(dashes3[0]);
+									   double offset3 = 0;
+									   cairo_set_dash(cr, dashes3, ndash3, offset3);
+									   break;
+		}
+
+		case (dmapLineTypeDashDotDot) :
+		{
+										  double dashes4[] = { 50, 10, 10, 10, 10, 10 };
+										  int ndash4 = sizeof (dashes4) / sizeof(dashes4[0]);
+										  double offset4 = 0;
+										  cairo_set_dash(cr, dashes4, ndash4, offset4);
+										  break;
+		}
+
+		default: //什么也不做, 直接画直线
+			break;
+		}
+		return true;
+	}
+
+	bool clsUtil::DoSetAntialias(int iAntialias, cairo_t* cr)
+	{
+		//CAIRO_ANTIALIAS_DEFAULT,
+
+    /* method */
+   // CAIRO_ANTIALIAS_NONE,
+   // CAIRO_ANTIALIAS_GRAY,
+   // CAIRO_ANTIALIAS_SUBPIXEL,
+
+    /* hints */
+    //CAIRO_ANTIALIAS_FAST,
+   // CAIRO_ANTIALIAS_GOOD,
+  //  CAIRO_ANTIALIAS_BEST
+	    cairo_set_antialias(cr,CAIRO_ANTIALIAS_FAST);
+		return true;
+		switch (iAntialias)
+		{
+		case dmapAntialiasingDefault:cairo_set_antialias(cr, CAIRO_ANTIALIAS_DEFAULT); break;
+		case dmapAntialiasingNone:cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE); break;
+		case dmapAntialiasingGray:cairo_set_antialias(cr, CAIRO_ANTIALIAS_GRAY); break;
+		case dmapAntialiasingSubpixel:cairo_set_antialias(cr, CAIRO_ANTIALIAS_SUBPIXEL); break;
+		case dmapAntialiasingTrue:cairo_set_antialias(cr, CAIRO_ANTIALIAS_DEFAULT); break;
+		case dmapAntialiasingFalse:cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE); break;
+		case dmapAntialiasingBest:cairo_set_antialias(cr, CAIRO_ANTIALIAS_BEST); break;
+		default:
+			/*
+			还有一些枚举没用上
+			*/
+			break;
+		}
+		return true;
+	}
+
+
+	bool clsUtil::DrawStruct(clsCrSurf* pClsCS, DataCollection* data, int index, Renderer* pSimpleRenderer)
+	{
+		int renType = pSimpleRenderer->RendererType();
+		int structType = data->m_iStructType;
+		void * pStruct = data->m_pData;
+		vector<vector<string>>* p_VVAllF = &(data->m_vAllField);
+		vector<string>* p_V = &(data->m_vFieldName);
+
+		switch (structType)
+		{
+		case clsStruct::Struct_Point:
+		{
+										clsStruct::POINT* pPoint = ((clsStruct::POINT*)(pStruct)) + index;
+										if (renType == dmapSimpleMarkerSymbol)
+										{
+											SimpleMarkerSymbol* sms = (SimpleMarkerSymbol*)pSimpleRenderer;
+											sms->DrawPOINT(pClsCS, pPoint);
+										}
+										else if (renType == dmapSimpleLabelRenderer)
+										{
+											SimpleLabelRenderer* slr = (SimpleLabelRenderer*)pSimpleRenderer;
+										}
+										else
+											return false;//安全中断
+										break;
+		}
+		case clsStruct::Struct_Line:
+		{
+									   clsStruct::LINE* pLine = ((clsStruct::LINE*)(pStruct)) + index;
+									   if (renType == dmapSimpleMarkerSymbol)
+									   {
+										   SimpleMarkerSymbol* sms = (SimpleMarkerSymbol*)pSimpleRenderer;
+										   sms->DrawMPOINT(pClsCS, pLine);
+									   }
+									   else if (renType == dmapSimpleLineSymbol)
+									   {
+										   SimpleLineSymbol* sls = (SimpleLineSymbol*)pSimpleRenderer;
+										   sls->DrawLINESimple(pClsCS, pLine); //这里要传 dc 的宽和高
+									   }
+									   else if (renType == dmapSimplePolygonSymbol)
+									   {
+										   SimplePolygonSymbol* sps = (SimplePolygonSymbol*)pSimpleRenderer;
+										   sps->DrawRING(pClsCS, pLine);
+									   }
+									   break;
+		}
+		case clsStruct::Struct_MLine:
+		{
+										clsStruct::MLINE* pMLine = ((clsStruct::MLINE*)(pStruct)) + index;
+										if (renType == dmapSimpleLineSymbol)
+										{
+											SimpleLineSymbol * sls = (SimpleLineSymbol*)pSimpleRenderer;
+											sls->DrawMLINESimple(pClsCS, pMLine);
+										}
+										else if (renType == dmapSimpleLabelRenderer)
+										{
+											;
+										}
+										else
+											return false;//安全中断
+										break;
+		}
+		case clsStruct::Struct_Polygon:
+		{
+										  clsStruct::POLYGON* pMPolygon = ((clsStruct::POLYGON*)(pStruct)) + index;
+										  if (renType == dmapSimplePolygonSymbol)
+										  {
+
+										  }
+										  else return false; // 安全中断
+										  break;
+		}
+		case clsStruct::Struct_MPolygon:
+		{
+										   clsStruct::MPOLYGON* pMPolygon = ((clsStruct::MPOLYGON*)(pStruct)) + index;
+										   if (renType == dmapSimplePolygonSymbol)
+										   {
+											   SimplePolygonSymbol* sps = (SimplePolygonSymbol*)pSimpleRenderer;
+											   sps->DrawMPOLYGON(pClsCS, pMPolygon);
+										   }
+										   else if (renType == dmapSimpleLabelRenderer)
+										   {
+											   ;
+										   }
+										   else
+											   return false;//安全中断
+										   break;
+		}
+		default:
+			break;
+		}
+		return true;
+	}
+
+	bool clsUtil::ZoomFunction(Rect* extent_from, Rect* extent_to, double& r, double & x_dis, double& y_dis)
+	{
+		extent_from->Normal(); extent_to->Normal();
+		double w_from = extent_from->m_dRight - extent_from->m_dLeft;
+		double w_to = extent_to->m_dRight - extent_to->m_dLeft;
+		double h_from = extent_from->m_dTop - extent_from->m_dBottom;
+		double h_to = extent_to->m_dTop - extent_to->m_dBottom;
+
+		double r1 = w_to / w_from;
+		double r2 = h_to / h_from;
+		r = r1 < r2 ? r1 : r2;
+
+		x_dis = (extent_to->m_dLeft + extent_to->m_dRight) / 2 - r*(extent_from->m_dLeft + extent_from->m_dRight) / 2;
+		y_dis = (extent_to->m_dTop + extent_to->m_dBottom) / 2 - r*(extent_from->m_dTop + extent_from->m_dBottom) / 2;
+
+		return true;
+	}
+
+	bool clsUtil::PointInRect(double x, double y, double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
+	{
+		//（x1,y1）和(x2,y2)组成一条直线,另外两点组成一条直线
+		double k1, b1, k2, b2;
+		k1 = (y2 - y1) / (x2 - x1);
+		b1 = y1 - k1*x1;
+		k2 = (y4 - y3) / (x4 - x3);
+		b2 = y3 - k2*x3;
+
+		//判断该点是否在两条直线之间
+		bool bInLines = clsUtil::PointInLines(x, y, k1, b1, k2, b2);
+		if (!bInLines)
+			return false;
+
+		//(x1,y1)和(x4,y4) 组成一条直线,另外亮点组成一条直线
+		k1 = (y1 - y4) / (x1 - x4);
+		b1 = y1 - k1*x1;
+		k2 = (y3 - y2) / (x3 - x2);
+		b2 = y2 - k2*x2;
+		//判断该店是否在两条直线之间
+		bInLines = clsUtil::PointInLines(x, y, k1, b1, k2, b2);
+		if (!bInLines)
+			return false;
+		return true;
+	}
+	bool clsUtil::PointInLines(double x, double y, double k1, double b1, double k2, double b2)
+	{
+		double y1 = k1*x + b1;
+		double y2 = k2* x + b2;
+		if ((y >= y1) && (y <= y2))
+			return true;
+		if ((y <= y1) && (y >= y2))
+			return true;
+
+		return false;
+
+	}
+
+	double clsUtil::StandardizationAngle(double dAngle)
+	{
+		while (dAngle > 2 * M_PI)
+			dAngle -= 2 * M_PI;
+		while (dAngle < 0)
+			dAngle += 2 * M_PI;
+		return dAngle;
+	}
+
+	/*
+	此两个函数只处理 被双引号完全包含的字符串
+	*/
+	string clsUtil::TryAddDoubleQuotation(string s)
+	{
+		//双引号开头的不加
+		if ((s.c_str()[0] == '"'))
+			return s;
+		string ss = "\"" + s + "\"";
+		return ss;
+	}
+	string clsUtil::TryDeleteDoubleQuotation(string s)
+	{
+		//不是双引号开头不去双引号
+		if ((s.c_str()[0]) != '"')
+			return s;
+		char ss[500]; memset(ss, 0, 500);
+		const char* s_ = s.c_str();
+		int len = strlen(s_);
+
+		memcpy(ss, s_ + 1, len - 2);
+
+		return ss;
+	}
+
+	void clsUtil::GetFiles(string path, string exd, vector<string> & files)
+	{
+		/************************************************************************/
+		/*  获取文件夹下所有文件名
+		输入：
+		path	:	文件夹路径
+		exd		:   所要获取的文件名后缀，如jpg、png等；如果希望获取所有
+		文件名, exd = ""
+		输出：
+		files	:	获取的文件名列表
+		*/
+		/************************************************************************/
+
+
+/*
+		//文件句柄
+		long   hFile = 0;
+		//文件信息
+		struct _finddata_t fileinfo;
+		string pathName, exdName;
+
+		if (0 != strcmp(exd.c_str(), ""))
+		{
+			exdName = "\\*." + exd;
+		}
+		else
+		{
+			exdName = "\\*";
+		}
+
+		if ((hFile = _findfirst(pathName.assign(path).append(exdName).c_str(), &fileinfo)) != -1)
+		{
+			do
+			{
+				//如果是文件夹中仍有文件夹,迭代之
+				//如果不是,加入列表
+				if ((fileinfo.attrib &  _A_SUBDIR))
+				{
+					if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
+						clsUtil::GetFiles(pathName.assign(path).append("\\").append(fileinfo.name), exd, files);
+				}
+				else
+				{
+					if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
+						files.push_back(pathName.assign(path).append("\\").append(fileinfo.name));
+				}
+			} while (_findnext(hFile, &fileinfo) == 0);
+			_findclose(hFile);
+		}*/
+	}
+
+	int clsUtil::ParseStringTok(char * sz, char  toK, char ** szPtr, int maxPtr)
+	{
+		if (sz == 0)
+		{
+			return 0;
+		}
+		int nowCount = 0;
+		int i = 0;
+		szPtr[nowCount] = sz;
+		nowCount++;
+		if (nowCount >= maxPtr)return nowCount;
+
+		for (;; i++)
+		{
+			char c = sz[i];
+			if (c == 0)return nowCount;
+			if (c == toK)
+			{
+				sz[i] = 0;
+				if (sz[i + 1] == 0)return nowCount;
+				szPtr[nowCount] = sz + i + 1;
+				nowCount++;
+				if (nowCount >= maxPtr)return nowCount;
+			}
+		}
+		return nowCount;
+	}
+
+	void clsUtil::ValueString(string* s, bool* bValue)
+	{
+		if (*s == "")
+		{
+			if (*bValue)
+				*s = "true";
+			return;
+		}
+
+		string s____ = clsUtil::TryDeleteDoubleQuotation(*s);
+		if (s____ == "true")
+			*bValue = true;
+		else
+			*bValue = false;
+	}
+
+	std::string  clsUtil::fmt(char* fmt, ...)
+	{
+		va_list argptr;
+		int cnt;
+		char buffer[2000];
+		va_start(argptr, fmt);
+
+		cnt = vsnprintf(buffer, 1000, fmt, argptr);
+
+		va_end(argptr);
+
+		return buffer;
+	}
+
+	std::string  clsUtil::fmt(const char* fmt, ...)
+	{
+		va_list argptr;
+		int cnt;
+		char buffer[2000];
+		va_start(argptr, fmt);
+
+		cnt = vsnprintf(buffer, 1000, fmt, argptr);
+
+		va_end(argptr);
+
+		return buffer;
+	}
+
+
+
+	void clsUtil::ValueString(string* s, double* dValue)
+	{
+		if (*s == "")
+		{
+			//char buf[500];
+			string str = clsUtil::fmt("%lf", *dValue);
+			*s = str.c_str();
+			return;
+		}
+
+		string s____ = clsUtil::TryDeleteDoubleQuotation(*s);
+		*dValue = stod(s____.c_str());
+	}
+
+
+
+	void clsUtil::ValueString(string* s, long* lValue)
+	{
+		if (*s == "")
+		{
+			//char s_[500];
+			string str = clsUtil::fmt("%ld", lValue);
+			*s = str.c_str();
+			return;
+		}
+		string s____ = clsUtil::TryDeleteDoubleQuotation(*s);
+		*lValue = stol(s____.c_str());
+	}
+
+	void clsUtil::ValueString(string* s, string* sValue)
+	{
+		if (*s == "")
+		{
+			string s_ = "";
+			s_ += "\"";
+			s_ += *sValue;
+			s_ += "\"";
+			*s = s_;
+			return;
+		}
+		string s____ = clsUtil::TryDeleteDoubleQuotation(*s);
+		const char* s_ = s____.c_str();
+		int len = strlen(s_);
+		clsMalloc clsM(len - 1);
+		char* ss = clsM.mem;
+		memcpy(ss, s_ + 1, len - 2);
+		ss[len - 2] = 0;
+		*sValue = ss;
+	}
+
+	void clsUtil::EnumString(string* s, int* iEnum, string s1, string s2, string s3, string s4, string s5, string s6, string s7, string s8, string s9, string s10, string s11, string s12)
+	{
+		if (*s == "")
+		{
+			switch (*iEnum)
+			{
+			case 0: *s = s1; break;
+			case 1: *s = s2; break;
+			case 2: *s = s3; break;
+			case 3: *s = s4; break;
+			case 4: *s = s5; break;
+			case 5: *s = s6; break;
+			case 6: *s = s7; break;
+			case 7: *s = s8; break;
+			case 8: *s = s9; break;
+			case 9:*s = s10; break;
+			case 10:*s = s11; break;
+			case 11:*s = s12; break;
+			default:
+				*s = "";
+				break;
+			}
+			return;
+		}
+
+		string s_ = clsUtil::TryDeleteDoubleQuotation(*s);
+		if (s_ == s1) { *iEnum = 0; return; }
+		if (s_ == s2) { *iEnum = 1; return; }
+		if (s_ == s3) { *iEnum = 2; return; }
+		if (s_ == s4) { *iEnum = 3; return; }
+		if (s_ == s5) { *iEnum = 4; return; }
+		if (s_ == s6) { *iEnum = 5; return; }
+		if (s_ == s7) { *iEnum = 6; return; }
+		if (s_ == s8) { *iEnum = 7; return; }
+		if (s_ == s9) { *iEnum = 8; return; }
+		if (s_ == s10) { *iEnum = 9; return; }
+		if (s_ == s11) { *iEnum = 10; return; }
+		if (s_ == s12) { *iEnum = 11; return; }
+		iEnum = 0; return;
+
+	}
+
+	void clsUtil::ColorString(string* s, unsigned  int* iColor)
+	{
+		if (*s == "")
+		{
+			unsigned char r, g, b, a;
+			a = ((char*)iColor)[3];
+			r = ((char*)iColor)[2];
+			g = ((char*)iColor)[1];
+			b = ((char*)iColor)[0];
+			//char s_[1000];
+			string str = clsUtil::fmt("%d,%d,%d,%d", r, g, b, a);
+			*s = str.c_str();
+			return;
+		}
+
+		string s____ = clsUtil::TryDeleteDoubleQuotation(*s);
+		const char* s_ = s____.c_str();
+		int len = strlen(s_);
+		char ss[1000];
+		memcpy(ss, s_, len + 1);
+		char* sRGBA[4];
+		clsUtil::ParseStringTok(ss, ',', sRGBA, 4);
+		char* sr, *sg, *sb, *sa;
+		sr = sRGBA[0]; sg = sRGBA[1]; sb = sRGBA[2]; sa = sRGBA[3];
+		int r, g, b, a;
+		r = stoi(sr);
+		g = stoi(sg);
+		b = stoi(sb);
+		a = stoi(sa);
+		*iColor = (unsigned int)((r << 16) + (g << 8) + b + (a << 24));
+	}
+}
\ No newline at end of file

+#pragma once
+#include <cairo/cairo.h>
+#include<string>
+#include<vector>
+#include "dmap_core.h"
+using namespace std;
+namespace DmapCore_30
+{
+	class clsCrSurf;
+	class DataCollection;
+	class Renderer;
+	class Rect;
+	class clsMalloc;
+
+#define GetIndexP(index,to)  \
+	int length = (int)to.size(); \
+	if (index<0 || index >= length)return NULL; \
+	to[index]->AddRef(); \
+	return to[index];
+	//Set一个指针时, 必须先AddRef, 由于传入的指针与被替换的指针有可能是同一个, 先Release 内存出错
+#define SetIndexP(index,from,to)   \
+	if (!from)return false; \
+	int length = (int)to.size(); \
+	if (index>length)return false; \
+	from->AddRef(); \
+	if (index < 0 || index == length)to.push_back(from); \
+else { to[index]->Release(); to[index] = from; }\
+	return true;
+#define RemoveIndexP(index,to)  \
+	int length = (int)to.size(); \
+	if (index < 0 || index >= length)return false; \
+	to[index]->Release(); \
+	to.erase(to.begin() + index); \
+	return true;
+#define ClearP(to)  \
+	int length = (int)to.size(); \
+	for (int i = 0; i < length; i++)\
+	{to[i]->Release(); }to.clear(); return true;
+
+
+	class CORE_EXPORT  clsUtil
+	{
+	public:
+		clsUtil();
+		~clsUtil();
+		static unsigned int RandomColor();
+		static bool Exchange4(unsigned char * here);
+		static bool Exchange8(unsigned char * here);
+		static bool ToCairoColor(unsigned int Color, double& r, double & g, double& b);
+		static bool ToCairoColor(unsigned int Color, double &r, double & g, double& b, double&a);
+		static bool ToCairoColor(string color, double &r, double & g, double& b, double&a);
+		static bool ReadHead(unsigned char* & here, int& not_big1, int & shapetype);
+		static int ReadInt(unsigned char*& here, int  not_big1);
+		static int Hex2int(char c);
+		static int ReadByte(unsigned char*& here);
+		static double ReadDouble(unsigned char*& here, int not_big);
+		static bool DoSetLineType(int LineType, cairo_t* cr);
+		static bool DoSetAntialias(int iAntialias, cairo_t* cr);
+		static char * ConvertEnc(char *encFrom, char *encTo, const char * in, char *bufout, size_t lenout);
+		static bool  ConvertEncUTF8_GB18030(const char *from, clsMalloc &m);
+		static bool  ConvertEncGB18030_UTF8(const char* from, clsMalloc &m);
+
+		static bool DrawStruct(clsCrSurf* pClsCS, DataCollection* data, int index, Renderer* pSimpleRenderer);
+
+		static bool ZoomFunction(Rect* extent_from, Rect* extent_to, double& r, double & x_dis, double& y_dis);
+		static bool PointInRect(double x, double y, double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4); // 判断一个点是否在矩形内(该矩形可旋转)
+		static bool PointInLines(double x, double y, double k1, double b1, double k2, double b2);  //采用 y = k * x + b; k1,b1等是直线系数
+		static double StandardizationAngle(double dAngle);
+
+		static string TryAddDoubleQuotation(string s);
+		static string TryDeleteDoubleQuotation(string s);
+
+
+		static void GetFiles(string path, string exd, vector<string> & files);
+		static int  ParseStringTok(char * sz, char  toK, char ** szPtr, int maxPtr);
+		
+		static std::string fmt(char *, ...);
+		static std::string fmt(const char*, ...);
+		static void ValueString(string * s, bool* bValue);
+		static void ValueString(string* s, double* dValue);
+		static void ValueString(string* s, long* lValue);
+		static void ValueString(string* s, string* sValue);
+		static void EnumString(string* s, int* iEnum, string s1 = "", string s2 = "", string s3 = "", string s4 = "", string s5 = "", string s6 = "", string s7 = "", string s8 = "", string s9 = "", string s10 = "", string s11 = "", string s12 = "");
+		static void ColorString(string* s, unsigned int* iColor);
+	};
+
+}
\ No newline at end of file

+
+#include "clsXML.h"
+#include"clsUtil.h"
+//#include"StringHelp.h"
+#include"SimpleMarkerSymbol.h"
+#include"SimpleLineSymbol.h"
+#include"SimplePolygonSymbol.h"
+#include"SimpleLabelRenderer.h"
+#include"ValueMapRenderer.h"
+//#include"RangeMapRenderer.h"
+#include"GroupRenderer.h"
+//#include"ScaleDependentRenderer.h"
+//#include"HeatMapRenderer.h"
+#include"SimpleRenderer.h"
+#include"TextSymbol.h"
+#include"clsMalloc.h"
+#include"Renderer.h"
+#include"TrueTypeMarkerSymbol.h"
+
+namespace DmapCore_30
+{
+
+	clsXML::clsXML(AppendBuffer * f, string name)
+	{
+		m_pF = NULL;
+		if (f)
+		{
+			m_sName = name;
+			m_pF = f;
+			f->AppendString("<", 1); f->AppendString(name.c_str(), name.size()); //fprintf(f, "<%s", name.c_str());
+			m_bHaveCloseProperties = false;
+		}
+	}
+
+
+	clsXML::~clsXML()
+	{
+		if (m_pF == 0)return;
+		closeProperties();
+		m_pF->AppendString("</", 2); m_pF->AppendString(m_sName.c_str(), m_sName.size()); m_pF->AppendString(">", 1);//fprintf(m_pF, "</%s>", m_sName.c_str());
+	}
+
+	void clsXML::closeProperties()
+	{
+		if (m_pF == 0)return;
+		if (m_bHaveCloseProperties)return;
+		m_pF->AppendString(">", 1); //fprintf(m_pF, ">");
+		m_bHaveCloseProperties = true;
+		return;
+	}
+	void clsXML::writeText(string s)
+	{
+		if (m_pF == 0)return;
+		if (!m_bHaveCloseProperties)
+			this->closeProperties();
+		m_pF->AppendString(s.c_str(), s.size());// fprintf(m_pF, "%s", s.c_str());
+		return;
+	}
+
+	bool clsXML::XMLHead(AppendBuffer * f)
+	{
+		f->AppendString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");// fprintf(f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+		return true;
+	}
+	string clsXML::XMLGetPropByString(boost::property_tree::ptree &pt, const string& find)
+	{
+		//xml_attribute<char> *attr = node->first_attribute(find.c_str());
+		//if (attr == 0)return "";
+		//char * s = attr->value();
+		string value = pt.get<std::string>("<xmlattr>."+ find,""); 
+		return value;
+	}
+	void clsXML::StringReplace(string &strBase, string strSrc, string strDes)
+	{
+		string::size_type pos = 0;
+		string::size_type srcLen = strSrc.size();
+		string::size_type desLen = strDes.size();
+		pos = strBase.find(strSrc, pos);
+		while ((pos != string::npos))
+		{
+			strBase.replace(pos, srcLen, strDes);
+			pos = strBase.find(strSrc, (pos + desLen));
+		}
+	}
+
+	void clsXML::_Append2(AppendBuffer *f,  string &a,  string &b)
+	{
+		f->AppendString(" ", 1);
+		f->AppendString(a.c_str(), a.size());
+		f->AppendString("=\"", 2);
+		f->AppendString(b.c_str(), b.size());
+		f->AppendString("\"", 1);
+	}
+	bool clsXML::XMLAttrParse(boost::property_tree::ptree &pt, AppendBuffer * f, string *value, string find)
+	{
+		//if (node)// 如果有节点,解析节点
+		{
+			const static std::string s = "";
+			*value = s;
+			*value = clsXML::XMLGetPropByString(pt, find);
+			return true;
+		}
+		//写到xml
+
+
+		return true;
+	}
+	bool clsXML::XMLAttrParse(boost::property_tree::ptree &pt, AppendBuffer * f, double *value, string find)
+	{
+		string sz1__ = clsXML::XMLGetPropByString(pt, find);
+		if (sz1__ == "error")return false;
+		const char* sz1 = sz1__.c_str();
+		*value = atof(sz1);
+		return true;
+	
+		return true;
+	}
+	bool clsXML::XMLAttrParse(boost::property_tree::ptree &pt, AppendBuffer * f, long *value, string find)
+	{
+
+			*value = 0;
+			string sz1__ = clsXML::XMLGetPropByString(pt, find);
+			if (sz1__ == "error")return false;
+			const char* sz1 = sz1__.c_str();
+			*value = atoi(sz1);
+			return true;
+		
+	
+	}
+	bool clsXML::XMLAttrParse(boost::property_tree::ptree &pt, AppendBuffer * f, float *value, string find)
+	{
+		    *value = 0;
+			string sz1__ = clsXML::XMLGetPropByString(pt, find);
+			if (sz1__ == "error")return false;
+			const char* sz1 = sz1__.c_str();
+			*value = (float)atof(sz1);
+			return true;
+	}
+	bool clsXML::XMLAttrParse(boost::property_tree::ptree &pt, AppendBuffer * f, bool *value, string find, bool defaultValue)
+	{
+			*value = defaultValue;
+			string sz1__ = clsXML::XMLGetPropByString(pt, find);
+			if (sz1__ == "error")return false;
+			const char* sz1 = sz1__.c_str();
+			if (strcmp(sz1, "true") == 0){ *value = true; return true; }
+			if (strcmp(sz1, "false") == 0){ *value = false; return true; }
+			return defaultValue;
+	}
+	bool clsXML::XMLAttrParseColor(boost::property_tree::ptree &pt, AppendBuffer * f, unsigned int * value, string find1, string find2)
+	{	*value = 0xff000000;
+			string sz1__ = clsXML::XMLGetPropByString(pt, find1);
+			if (sz1__ == "error" || sz1__ == "")return false;
+			const char* sz1 = sz1__.c_str();
+			string sz2 = "1";
+			if (find2 != "")
+			{
+				sz2 = clsXML::XMLGetPropByString(pt, find2);
+			}
+			int r = 0, g = 0, b = 0; double a = 1;
+			sscanf(sz1, "%d,%d,%d", &r, &g, &b);
+			const char* sz2__ = sz2.c_str();
+			a = atof(sz2__);
+			//sscanf(sz2, "%lf", &a);
+			a += 0.001;
+			*value = (((int)(a * 255)) << 24) + (r << 16) + (g << 8) + b;
+			return true;
+
+	}
+
+
+	
+	string clsXML::ParseEnum(int v, string a1, string a2, string a3, string a4, string a5, string a6, string a7, string a8, string a9, string a10, string a11, string a12, string a13, string a14, string a15, string a16)
+	{
+		switch (v)
+		{
+		case 0: return a1;
+		case 1: return a2;
+		case 2: return a3;
+		case 3: return a4;
+		case 4: return a5;
+		case 5: return a6;
+		case 6: return a7;
+		case 7: return a8;
+		case 8: return a9;
+		case 9: return a10;
+		case 10: return a11;
+		case 11: return a12;
+		case 12: return a13;
+		case 13: return a14;
+		case 14: return a15;
+		case 15: return a16;
+		
+		default:
+			return a1;
+		}
+	}
+
+	bool clsXML::ParseEnum(string find, boost::property_tree::ptree &pt, AppendBuffer * f, bool *v, string a1, string a2, string a3, string a4, string a5, string a6, string a7, string a8, string a9, string a10, string a11, string a12, string a13, string a14, string a15, string a16)
+	{
+		    string s;
+			clsXML::XMLAttrParse(pt, f, &s, find);
+			if (clsXML::XMLAttrParse(pt, f, &s, find) == false)return false;	//sgq:返回的是GBK的编码
+
+			int nowAt = 0;
+			if (s == "")return true;
+
+			//SGQ:得到Marker的类型
+			if (s == a1){ *v = false; return true; }; 
+			if (s == a2){ *v = true; return true; }; 
+			
+			return true;
+	}
+
+	bool clsXML::ParseEnum(string find, boost::property_tree::ptree &pt, AppendBuffer * f, int *v, string a1, string a2, string a3, string a4, string a5, string a6, string a7, string a8, string a9, string a10, string a11, string a12, string a13, string a14, string a15, string a16)
+	{
+		//if (node)
+		{
+			string s;
+			clsXML::XMLAttrParse(pt, f, &s, find);
+			if (clsXML::XMLAttrParse(pt, f, &s, find) == false)return false;	//sgq:返回的是GBK的编码
+
+			int nowAt = 0;
+			if (s == "")return true;
+
+			//SGQ:得到Marker的类型
+			if (s == a1){ *v = nowAt; return true; }; nowAt++;
+			if (s == a2){ *v = nowAt; return true; }; nowAt++;
+			if (s == a3){ *v = nowAt; return true; }; nowAt++;
+			if (s == a4){ *v = nowAt; return true; }; nowAt++;
+			if (s == a5){ *v = nowAt; return true; }; nowAt++;
+			if (s == a6){ *v = nowAt; return true; }; nowAt++;
+			if (s == a7){ *v = nowAt; return true; }; nowAt++;
+			if (s == a8){ *v = nowAt; return true; }; nowAt++;
+			if (s == a9){ *v = nowAt; return true; }; nowAt++;
+			if (s == a10){ *v = nowAt; return true; }; nowAt++;
+			if (s == a11){ *v = nowAt; return true; }; nowAt++;
+			if (s == a12){ *v = nowAt; return true; }; nowAt++;
+			if (s == a13){ *v = nowAt; return true; }; nowAt++;
+			if (s == a14){ *v = nowAt; return true; }; nowAt++;
+			if (s == a15){ *v = nowAt; return true; }; nowAt++;
+			if (s == a16){ *v = nowAt; return true; }; nowAt++;
+			return true;
+		}
+
+	}
+
+
+	bool clsXML::XMLParseString( char* xml, AppendBuffer *f, Renderer** renderer)
+	{
+		/*xml_document<> doc;    // character type defaults to char
+		doc.parse<0>(xml);
+		xml_node<char> *n = doc.first_node();
+		if (n == NULL)
+		{
+			return false;
+		}
+		return XMLParse(n, f, renderer);*/
+		return false;
+	}
+
+	bool clsXML::XMLParse(string rendererName, boost::property_tree::ptree &pt,  Renderer** renderer)
+	{
+		
+		
+		
+		//const char *sz = node->name();
+		//string ss ;
+		bool flag = false;
+		//所有的AddRef 在这里加? 调用函数出不再考虑
+		if (rendererName == "SIMPLEMARKERSYMBOL")
+		{
+			SimpleMarkerSymbol *sms = new SimpleMarkerSymbol();
+			flag = sms->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = sms; /*sms->AddRef(); */
+		}
+		else if (rendererName == "SIMPLELINESYMBOL")
+		{
+			SimpleLineSymbol *sls = new SimpleLineSymbol();
+			flag = sls->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = sls; /*sls->AddRef();*/
+		}
+		else if (rendererName == "SIMPLEPOLYGONSYMBOL")
+		{
+			SimplePolygonSymbol *sps = new SimplePolygonSymbol();
+			flag = sps->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = sps; /*sps->AddRef();*/
+		}
+		else if (rendererName == "VALUEMAPRENDERER")
+		{
+			ValueMapRenderer *vmr = new ValueMapRenderer();
+			flag = vmr->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = vmr; /*vmr->AddRef();*/
+		}
+		/*else if (rendererName == "RANGEMAPRENDERER")
+		{
+			RangeMapRenderer *rmr = new RangeMapRenderer();
+			flag = rmr->Parse(node, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = rmr; 
+		}*/
+		else if (rendererName == "GROUPRENDERER")
+		{
+			GroupRenderer *gr = new GroupRenderer();
+			flag = gr->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = gr; /*gr->AddRef();*/
+		}
+	/*	else if (rendererName == "SCALEDEPENDENTRENDERER")
+		{
+			ScaleDependentRenderer *gr = new ScaleDependentRenderer();
+			flag = gr->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = gr; 
+		}*/
+		else if (rendererName == "SIMPLELABELRENDERER")
+		{
+			SimpleLabelRenderer *gr = new SimpleLabelRenderer();
+			flag = gr->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = gr; /*gr->AddRef();*/
+		}
+		else if (rendererName == "SIMPLERENDERER")
+		{
+			SimpleRenderer *sr = new SimpleRenderer();
+			flag = sr->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = sr;
+		}
+		else if (rendererName == "TEXTSYMBOL")
+		{
+			TextSymbol *gr = new TextSymbol();
+			flag = gr->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = gr; /*gr->AddRef();*/
+		}
+		else if (rendererName == "TRUETYPEMARKERSYMBOL")
+		{
+			TrueTypeMarkerSymbol *gr = new TrueTypeMarkerSymbol();
+			flag = gr->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = gr; /*gr->AddRef();*/
+		}
+		/*else if( rendererName == "HEATSYMBOL")
+		{
+			HeatMapRenderer *gr = new HeatMapRenderer();
+			flag = gr->Parse(pt, nullptr);
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = gr; 
+
+		}*/
+
+		if (flag == false)
+		{
+			if ((*renderer) != NULL)
+				(*renderer)->Release();
+			*renderer = NULL;
+		}
+
+		return flag;
+	}
+
+}
\ No newline at end of file

+
+#ifndef _clsXML_H_
+#define _clsXML_H_
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/foreach.hpp>
+#include <string>
+#include "AppendBuffer.h"
+using namespace std;
+namespace DmapCore_30
+{
+	class Renderer;
+	class clsXML
+	{
+	public:
+		clsXML(AppendBuffer* f, string name);
+		~clsXML();
+
+		string m_sName;
+		AppendBuffer* m_pF;
+		bool m_bHaveCloseProperties;
+
+
+		void closeProperties();//关闭属性
+		void writeText(string s);  //写入文本
+		static void _Append2(AppendBuffer *f,  string &a,  string &b);
+		static void StringReplace(string &strBase, string strSrc, string strDes);
+		static bool XMLHead(AppendBuffer * f);
+		static string XMLGetPropByString(boost::property_tree::ptree &pt,const string& find);
+		static bool XMLAttrParse(boost::property_tree::ptree &pt, AppendBuffer * f, string *value, string find);
+		static bool XMLAttrParse(boost::property_tree::ptree &pt, AppendBuffer * f, double *value, string find);
+		static bool XMLAttrParse(boost::property_tree::ptree &pt, AppendBuffer * f, long *value, string find);
+		static bool XMLAttrParse(boost::property_tree::ptree &pt, AppendBuffer * f, float *value, string find);
+		static bool XMLAttrParse(boost::property_tree::ptree &pt, AppendBuffer * f, bool *value, string find, bool defaultValue = false);
+
+		static bool XMLAttrParseColor(boost::property_tree::ptree &pt, AppendBuffer * f, unsigned int * value, string find1, string find2 = "");//这里处理的 int 类型只有 color
+		static bool ParseEnum(string find, boost::property_tree::ptree &pt, AppendBuffer * f, bool *v, string a1 = "", string a2 = "", string a3 = "", string a4 = "", string a5 = "", string a6 = "", string a7 = "", string a8 = "", string a9 = "", string a10 = "", string a11 = "", string a12 = "", string a13 = "", string a14 = "", string a15 = "", string a16 = "");
+		static bool ParseEnum(string find, boost::property_tree::ptree &pt, AppendBuffer * f, int *v, string a1 = "", string a2 = "", string a3 = "", string a4 = "", string a5 = "", string a6 = "", string a7 = "", string a8 = "", string a9 = "", string a10 = "", string a11 = "", string a12 = "", string a13 = "", string a14 = "", string a15 = "", string a16 = "");
+		static string ParseEnum(int v, string a1 = "", string a2 = "", string a3 = "", string a4 = "", string a5 = "", string a6 = "", string a7 = "", string a8 = "", string a9 = "", string a10 = "", string a11 = "", string a12 = "", string a13 = "", string a14 = "", string a15 = "", string a16 = "");
+		static bool XMLParse(string ptreeName, boost::property_tree::ptree &pt,  Renderer** renderer);
+		static bool XMLParseString( char*, AppendBuffer *f, Renderer** renderer);
+	};
+}
+#endif
\ No newline at end of file

+#include "legendParamater.h"
+
+namespace DmapCore_30
+{
+    legendParamater::legendParamater(/* args */)
+    {
+        index = 0;
+
+        rowspacing = 15;
+
+        size_x = 30;
+        
+        size_y = 15;
+
+        pixYIndex = 10;
+
+        pixXIndex = 20;
+
+        fontSize = 10;
+
+        current_Col_Index = 0;
+
+        max_pixXIndex = 10;
+        max_pixYIndex = 10;
+    }
+    
+    legendParamater::~legendParamater()
+    {
+    }
+
+    bool legendParamater::next(char * title)
+    {
+        if(index/row_maxsize>  current_Col_Index)
+        {
+              current_Col_Index ++;
+              pixXIndex = 10 + (current_Col_Index *100);
+              pixYIndex = 10;
+
+            if(pixXIndex> max_pixXIndex)
+            {
+               max_pixXIndex = pixXIndex;
+            }
+              
+        }
+        if(title == nullptr)
+        {
+          
+           index ++;
+           provTitle ="";
+
+           pixYIndex += (rowspacing + size_y);
+
+           if(pixYIndex> max_pixYIndex)
+           {
+               max_pixYIndex = pixYIndex;
+           }
+           return true;
+        }
+        string str_title = title;
+        if(str_title != provTitle)
+        {
+           index ++;
+            provTitle =str_title;
+           pixYIndex += (rowspacing + size_y);
+           if(pixYIndex> max_pixYIndex)
+           {
+               max_pixYIndex = pixYIndex;
+           }
+           return true;
+        }
+        
+        return true;
+       
+    }
+
+}
\ No newline at end of file

+/**************************************************************************
+* file:              legendParamater.h
+
+* Author:            qingxiongf
+* Date:              2021-12-12 23:05:31
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __legendParamater_h__
+#define __legendParamater_h__
+
+#include "dmap_core.h"
+#include <string>
+using namespace std;
+
+namespace DmapCore_30
+{
+    class CORE_EXPORT legendParamater
+    {
+    public:
+        /* data */
+        int index;
+
+        double pixYIndex;
+
+        double pixXIndex;
+
+        double m_dScaleDenominator;
+
+        string provTitle="";
+
+    public:
+
+        int r=0,g=0,b=0; 
+
+        int back_r = 255,back_g = 255, back_b = 255;
+
+        int back_a = 200;
+
+        string title = "图例";
+
+        string font = "宋体";
+
+        bool isbold = false;
+
+        bool showclassification;
+
+        int fontSize;
+
+        double rowspacing;
+
+        double size_x;
+        
+        double size_y;
+
+        int row_maxsize;
+
+        int current_Col_Index;
+
+        double max_pixXIndex;
+        double max_pixYIndex;
+
+    public:
+        legendParamater(/* args */);
+
+        bool next(char * title);
+
+        ~legendParamater();
+    };
+    
+
+    
+}
+
+#endif // __legendParamater_h__
+

-/**************************************************************************
-* file:              dmphttpbase.cpp
-
-* Author:            lijiahuan
-* Date:              2021-12-09 17:41:00
-* Email:             jiahuanl@chinadci.com
-* copyright:         广州城市信息研究所有限公司
-***************************************************************************/
-#include "dmphttpbase.h"
-
-#define HTTP_JSON_BEGIN ("[")
-#define HTTP_JSON_END ("]")
-
-DmpHttp::DmpHttpBase::DmpHttpBase(){}
-DmpHttp::DmpHttpBase::~DmpHttpBase(){}
-int DmpHttp::DmpHttpBase::parseUrl(const std::string& url, std::string& out_server,
-                           std::string& out_port, std::string& out_path){
-const std::string& http_ = "http://";
-const std::string& https_ = "https://";
-std::string temp_data = url;
-if (temp_data.find(http_) == 0) {
-		temp_data = temp_data.substr(http_.length());
-	}
-	else if (temp_data.find(https_) == 0) {
-		temp_data = temp_data.substr(https_.length());
-	}
-	else {
-		return HTTP_ERROR_HTTP_HEAD;
-	}
-    // 解析域名
-	std::size_t idx = temp_data.find('/');
-	// 解析 域名后的page
-	if (std::string::npos == idx) {
-		out_path = "/";
-		idx = temp_data.size();
-	}
-	else {
-		out_path = temp_data.substr(idx);
-	}
-	// 解析域名
-	out_server = temp_data.substr(0, idx);
-	// 解析端口
-	idx = out_server.find(':');
-	if (std::string::npos == idx) {
-		out_port = "80";
-	}
-	else {
-		out_port = out_server.substr(idx + 1);
-		out_server = out_server.substr(0, idx);
-	}
-	return HTTP_SUCCESS;
-}
-
-int DmpHttp::DmpHttpBase::buildPostRequest(const std::string& server, const std::string& path,
-	std::ostream& out_request) {
-	// 分割path中的json数据
-	std::string temp_path(path), temp_json;
-	int json_pos_begin = temp_path.find(HTTP_JSON_BEGIN) + 1;
-	int json_pos_end = temp_path.find(HTTP_JSON_END);
-	if (json_pos_begin != std::string::npos) {
-		// 计算json的长度
-		int temp_json_lenth = std::string::npos;
-		if (json_pos_end != temp_json_lenth) {
-			temp_json_lenth = (json_pos_end - json_pos_begin); 
-		}
-		temp_json = temp_path.substr(json_pos_begin, temp_json_lenth);
-		temp_path = temp_path.substr(0, (json_pos_begin - 1));
-	}
-	out_request << "POST " << temp_path.c_str() << " HTTP/1.0\r\n";
-	out_request << "Host: " << server.c_str() << "\r\n"; 
-	out_request << "Content-Length: " << temp_json.length() << "\r\n";
-	out_request << "Content-Type: application/x-www-form-urlencoded\r\n";
-	out_request << "Accept: */*\r\n";
-	out_request << "Connection: close\r\n\r\n";
-	out_request << temp_json.c_str();
-	return HTTP_SUCCESS;
-}
-
-int DmpHttp::DmpHttpBase::buildGetRequest(const std::string& server, const std::string& path,
-	std::ostream& out_request) {
-	out_request << "GET " << path.c_str() << " HTTP/1.0\r\n";
-	out_request << "Host: " << server.c_str() << "\r\n";
-	out_request << "Accept: */*\r\n";
-	out_request << "Connection: close\r\n\r\n";
-	return HTTP_SUCCESS;
-}
+/**************************************************************************
+* file:              dmphttpbase.cpp
+
+* Author:            lijiahuan
+* Date:              2021-12-09 17:41:00
+* Email:             jiahuanl@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmphttpbase.h"
+
+#define HTTP_JSON_BEGIN ("[")
+#define HTTP_JSON_END ("]")
+
+DmpHttp::DmpHttpBase::DmpHttpBase(){}
+DmpHttp::DmpHttpBase::~DmpHttpBase(){}
+int DmpHttp::DmpHttpBase::parseUrl(const std::string& url, std::string& out_server,
+                           std::string& out_port, std::string& out_path){
+const std::string& http_ = "http://";
+const std::string& https_ = "https://";
+std::string temp_data = url;
+if (temp_data.find(http_) == 0) {
+		temp_data = temp_data.substr(http_.length());
+	}
+	else if (temp_data.find(https_) == 0) {
+		temp_data = temp_data.substr(https_.length());
+	}
+	else {
+		return HTTP_ERROR_HTTP_HEAD;
+	}
+    // 解析域名
+	std::size_t idx = temp_data.find('/');
+	// 解析 域名后的page
+	if (std::string::npos == idx) {
+		out_path = "/";
+		idx = temp_data.size();
+	}
+	else {
+		out_path = temp_data.substr(idx);
+	}
+	// 解析域名
+	out_server = temp_data.substr(0, idx);
+	// 解析端口
+	idx = out_server.find(':');
+	if (std::string::npos == idx) {
+		out_port = "80";
+	}
+	else {
+		out_port = out_server.substr(idx + 1);
+		out_server = out_server.substr(0, idx);
+	}
+	return HTTP_SUCCESS;
+}
+
+int DmpHttp::DmpHttpBase::buildPostRequest(const std::string& server, const std::string& path,
+	std::ostream& out_request) {
+	// 分割path中的json数据
+	std::string temp_path(path), temp_json;
+	int json_pos_begin = temp_path.find(HTTP_JSON_BEGIN) + 1;
+	int json_pos_end = temp_path.find(HTTP_JSON_END);
+	if (json_pos_begin != std::string::npos) {
+		// 计算json的长度
+		int temp_json_lenth = std::string::npos;
+		if (json_pos_end != temp_json_lenth) {
+			temp_json_lenth = (json_pos_end - json_pos_begin); 
+		}
+		temp_json = temp_path.substr(json_pos_begin, temp_json_lenth);
+		temp_path = temp_path.substr(0, (json_pos_begin - 1));
+	}
+	out_request << "POST " << temp_path.c_str() << " HTTP/1.0\r\n";
+	out_request << "Host: " << server.c_str() << "\r\n"; 
+	out_request << "Content-Length: " << temp_json.length() << "\r\n";
+	out_request << "Content-Type: application/x-www-form-urlencoded\r\n";
+	out_request << "Accept: */*\r\n";
+	out_request << "Connection: close\r\n\r\n";
+	out_request << temp_json.c_str();
+	return HTTP_SUCCESS;
+}
+
+int DmpHttp::DmpHttpBase::buildGetRequest(const std::string& server, const std::string& path,
+	std::ostream& out_request) {
+	out_request << "GET " << path.c_str() << " HTTP/1.0\r\n";
+	out_request << "Host: " << server.c_str() << "\r\n";
+	out_request << "Accept: */*\r\n";
+	out_request << "Connection: close\r\n\r\n";
+	return HTTP_SUCCESS;
+}

-/**************************************************************************
-* file:              dmphttpbase.h
-
-* Author:            lijiahuan
-* Date:              2021-12-09 17:41:00
-* Email:             jiahuanl@chinadci.com
-* copyright:         广州城市信息研究所有限公司
-***************************************************************************/
-#ifndef __dmphttpbase_h__
-#define __dmphttpbase_h__
-#include <iostream>
-#include <boost/asio.hpp>
-namespace DmpHttp
-{
-    #define HTTP_SUCCESS            (0)          // 操作成功
-    #define HTTP_ERROR_UNKNOWN      (-1)         // 未知的错误
-    #define HTTP_ERROR_NETWORK      (-2)         // 网络连接失败
-    #define HTTP_ERROR_HTTP_HEAD    (-3)         // 未找到协议头 http || https 
-
-    #define HTTP_ERROR_SERVICE      (-1000)      // 服务器请求失败
-    #define HTTP_ERROR_LOGIN        (-1001)      // 登录失败
-    #define HTTP_ERROR_ID           (-1002)      // 企业ID错误
-    #define HTTP_ERROR_USER         (-1003)      // 帐号不存在
-    #define HTTP_ERROR_PASSWORD     (-1004)      // 密码错误
-
-    #define HTTP_ERROR_PARAMETER    (1)          // 参数错误
-    #define HTTP_ERROR_PHONE        (2)          // 电话号码错误
-    #define HTTP_ERROR_MESSAGE      (3)          // 短信有屏蔽字段
-    #define HTTP_ERROR_FUNCTION     (4)          // 当前平台不支持这个功能
-
-    class DmpHttpBase 
-    {
-    public:
-        DmpHttpBase();
-        virtual ~DmpHttpBase();  
-	    // Post请求
-	    virtual int post(const std::string& url) = 0;
-        // get请求
-        virtual int get(const std::string& url) = 0;  
-	    virtual std::string getResponse(void) = 0;
-
-    protected:
-        typedef int(*pBuildRequest)(const std::string&, const std::string&,std::ostream&);
-
-        static int parseUrl(const std::string& url, std::string& out_server,
-		            std::string& out_port, std::string& out_path);
-        static int buildPostRequest(const std::string& server, const std::string& path,
-					std::ostream& out_request);
-        static int buildGetRequest(const std::string& server, const std::string& path,
-					std::ostream& out_request);   
-    };
-}
-
-
-
-
+/**************************************************************************
+* file:              dmphttpbase.h
+
+* Author:            lijiahuan
+* Date:              2021-12-09 17:41:00
+* Email:             jiahuanl@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#ifndef __dmphttpbase_h__
+#define __dmphttpbase_h__
+#include <iostream>
+#include <boost/asio.hpp>
+namespace DmpHttp
+{
+    #define HTTP_SUCCESS            (0)          // 操作成功
+    #define HTTP_ERROR_UNKNOWN      (-1)         // 未知的错误
+    #define HTTP_ERROR_NETWORK      (-2)         // 网络连接失败
+    #define HTTP_ERROR_HTTP_HEAD    (-3)         // 未找到协议头 http || https 
+
+    #define HTTP_ERROR_SERVICE      (-1000)      // 服务器请求失败
+    #define HTTP_ERROR_LOGIN        (-1001)      // 登录失败
+    #define HTTP_ERROR_ID           (-1002)      // 企业ID错误
+    #define HTTP_ERROR_USER         (-1003)      // 帐号不存在
+    #define HTTP_ERROR_PASSWORD     (-1004)      // 密码错误
+
+    #define HTTP_ERROR_PARAMETER    (1)          // 参数错误
+    #define HTTP_ERROR_PHONE        (2)          // 电话号码错误
+    #define HTTP_ERROR_MESSAGE      (3)          // 短信有屏蔽字段
+    #define HTTP_ERROR_FUNCTION     (4)          // 当前平台不支持这个功能
+
+    class DmpHttpBase 
+    {
+    public:
+        DmpHttpBase();
+        virtual ~DmpHttpBase();  
+	    // Post请求
+	    virtual int post(const std::string& url) = 0;
+        // get请求
+        virtual int get(const std::string& url) = 0;  
+	    virtual std::string getResponse(void) = 0;
+
+    protected:
+        typedef int(*pBuildRequest)(const std::string&, const std::string&,std::ostream&);
+
+        static int parseUrl(const std::string& url, std::string& out_server,
+		            std::string& out_port, std::string& out_path);
+        static int buildPostRequest(const std::string& server, const std::string& path,
+					std::ostream& out_request);
+        static int buildGetRequest(const std::string& server, const std::string& path,
+					std::ostream& out_request);   
+    };
+}
+
+
+
+
 #endif //__dmphttpbase_h__
\ No newline at end of file

@@ -8,14 +8,14 @@
 
     DmpPgsqlUtils::DmpPgsqlUtils()
     {}
-    DmpPgsqlUtils::DmpPgsqlUtils( const char* strConn_,std::string& Msg_)
+    DmpPgsqlUtils::DmpPgsqlUtils( const char* strConn,std::string& Msg)
     {
         //std::string strconn_="hostaddr=172.26.99.160 prot=5432 dbname='DmapServer' user='postgres' password='chinadci'";
-        conn_=strConn_;   
+        conn_=strConn;   
         basepconn_=PQconnectdb(conn_);
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            Msg_= (std::string)PQerrorMessage(basepconn_);          
+            Msg= (std::string)PQerrorMessage(basepconn_);          
         }
     }
     DmpPgsqlUtils::~DmpPgsqlUtils()
@@ -32,9 +32,9 @@
         exit(1);  
     }  
 
-    bool DmpPgsqlUtils::GetDMapServices(std::map<int,DMapService> &dmapServices_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetDMapServices(std::map<int,DMapService> &dmapServices,std::string& Msg)
     {
-        PGresult *res_;
+        PGresult *res;
         const char* strsql="SELECT  name, title, state::character, create_time, update_time, description, node::character, overview, type, service_guid, catalog_guid FROM public.dmap_service where type='WMTS'";
         //char* conn_="hostaddr=172.26.60.100 port=5432 dbname=dmap_manager_test user=postgres password=chinadci";     
         //PGconn* pconn_=PQconnectdb(conn_);
@@ -44,26 +44,26 @@
             PQfinish(basepconn_);
             return false;
         }        
-        res_ = PQexec(basepconn_,strsql);
-        int tuple_num=PQntuples(res_);
-        int field_num=PQnfields(res_);
+        res = PQexec(basepconn_,strsql);
+        int tuple_num=PQntuples(res);
+        int field_num=PQnfields(res);
         if(tuple_num>0)
         {
             for(int i=0;i<tuple_num;i++)
             {
-                std::string name_=PQgetvalue(res_,i,0);
-                std::string state_=PQgetvalue(res_,i,2);
-                std::string createtime_=PQgetvalue(res_,i,3);
-                std::string type_=PQgetvalue(res_,i,8);
-                std::string serviceguid_=PQgetvalue(res_,i,9);
+                std::string name=PQgetvalue(res,i,0);
+                std::string state=PQgetvalue(res,i,2);
+                std::string createtime=PQgetvalue(res,i,3);
+                std::string type=PQgetvalue(res,i,8);
+                std::string serviceguid=PQgetvalue(res,i,9);
                 DMapService service{
-                    .name=name_,
-                    .state=state_,
-                    .create_time=createtime_,
-                    .type=type_,
-                    .service_guid=serviceguid_
+                    .name=name,
+                    .state=state,
+                    .create_time=createtime,
+                    .type=type,
+                    .service_guid=serviceguid
                 };
-                dmapServices_[i]=service;
+                dmapServices[i]=service;
             }
             
         }   
@@ -71,170 +71,170 @@
         {
             return false;
         }
-        PQclear(res_);   
+        PQclear(res);   
         return true; 
     }
-    bool DmpPgsqlUtils::GetDMapService(DMapService &dmapService_,const std::string& servicename_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetDMapService(DMapService &dmapService,const std::string& servicename,std::string& Msg)
     {
-        PGresult *res_;
-        std::string strsql_="SELECT  name, title, state::character, create_time, update_time, description, node::character, overview, type, service_guid, catalog_guid FROM public.dmap_service where name='"+servicename_+"'";
-        const char* csql_=strsql_.c_str();
+        PGresult *res;
+        std::string strsql="SELECT  name, title, state::character, create_time, update_time, description, node::character, overview, type, service_guid, catalog_guid FROM public.dmap_service where name='"+servicename+"'";
+        const char* csql=strsql.c_str();
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            std::string Msg_= (std::string)PQerrorMessage(basepconn_);
+            std::string Msg= (std::string)PQerrorMessage(basepconn_);
             PQfinish(basepconn_);
             return false;
         }        
-        res_ = PQexec(basepconn_,csql_);
-        int tuple_num=PQntuples(res_);
-        int field_num=PQnfields(res_);
+        res = PQexec(basepconn_,csql);
+        int tuple_num=PQntuples(res);
+        int field_num=PQnfields(res);
         if(tuple_num==1)
         {           
-            std::string name_=PQgetvalue(res_,0,0);
-            std::string state_=PQgetvalue(res_,0,2);
-            std::string createtime_=PQgetvalue(res_,0,3);
-            std::string type_=PQgetvalue(res_,0,8);
-            std::string serviceguid_=PQgetvalue(res_,0,9);
+            std::string name=PQgetvalue(res,0,0);
+            std::string state=PQgetvalue(res,0,2);
+            std::string createtime=PQgetvalue(res,0,3);
+            std::string type=PQgetvalue(res,0,8);
+            std::string serviceguid=PQgetvalue(res,0,9);
             DMapService service{
-                .name=name_,
-                .state=state_,
-                .create_time=createtime_,
-                .type=type_,
-                .service_guid=serviceguid_
+                .name=name,
+                .state=state,
+                .create_time=createtime,
+                .type=type,
+                .service_guid=serviceguid
             };
-            dmapService_=service;           
+            dmapService=service;           
         }  
         else
         {
             return false;
         }   
-        PQclear(res_);   
+        PQclear(res);   
         return true; 
     }
     
-    bool DmpPgsqlUtils::GetDMapwmts(const std::string& serviceGuid_,DMapWmtsService& resWmts_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetDMapwmts(const std::string& serviceGuid,DMapWmtsService& resWmts,std::string& Msg)
     {
         //char* conn_="hostaddr=172.26.60.100 port=5432 dbname=dmap_manager_test user=postgres password=chinadci"; 
-        std::string strsql_="SELECT  name, wmts_type, vendor, create_time::character, crs, datasource, metadata_url, scheme_guid	FROM public.dmap_wmts where guid='"+serviceGuid_+"'";
-        const char* csql_=strsql_.c_str();
+        std::string strsql="SELECT  name, wmts_type, vendor, create_time::character, crs, datasource, metadata_url, scheme_guid	FROM public.dmap_wmts where guid='"+serviceGuid+"'";
+        const char* csql=strsql.c_str();
             
         //PGconn* pconn_=PQconnectdb(conn_);
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            std::string Msg_= (std::string)PQerrorMessage(basepconn_);
+            std::string Msg= (std::string)PQerrorMessage(basepconn_);
             PQfinish(basepconn_);
             return false;
         }        
-        PGresult *res_;
-        res_ = PQexec(basepconn_,csql_);
-        int tuple_num=PQntuples(res_);
-        int field_num=PQnfields(res_);
+        PGresult *res;
+        res = PQexec(basepconn_,csql);
+        int tuple_num=PQntuples(res);
+        int field_num=PQnfields(res);
         
         if(tuple_num>0)
         {            
-            resWmts_.name=PQgetvalue(res_,0,0);
-            resWmts_.type=PQgetvalue(res_,0,1);
-            std::string v=PQgetvalue(res_,0,2);            
-            resWmts_.vendor=StringToVendor(v);
-            resWmts_.create_time=PQgetvalue(res_,0,3);
-            resWmts_.crs=PQgetvalue(res_,0,4);
-            resWmts_.datasource=PQgetvalue(res_,0,5);
-            resWmts_.metadata_url=PQgetvalue(res_,0,6);
-            resWmts_.tile_id= PQgetvalue(res_,0,7);           
+            resWmts.name=PQgetvalue(res,0,0);
+            resWmts.type=PQgetvalue(res,0,1);
+            std::string v=PQgetvalue(res,0,2);            
+            resWmts.vendor=StringToVendor(v);
+            resWmts.create_time=PQgetvalue(res,0,3);
+            resWmts.crs=PQgetvalue(res,0,4);
+            resWmts.datasource=PQgetvalue(res,0,5);
+            resWmts.metadata_url=PQgetvalue(res,0,6);
+            resWmts.tile_id= PQgetvalue(res,0,7);           
         }
         else
         {
             return false;
         }
-        PQclear(res_);
+        PQclear(res);
         return true;
     }
-    bool DmpPgsqlUtils::GetDMapwmtsFromName(const std::string& serviceName_, DMapWmtsService& resWmts_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetDMapwmtsFromName(const std::string& serviceName, DMapWmtsService& resWmts,std::string& Msg)
     {
-        std::string strsql_="SELECT  name, wmts_type, vendor, create_time::character, crs, datasource, metadata_url,layer_name, layer_alias, layer_title, layer_style, layer_format, layer_extent, scheme_guid	FROM public.dmap_wmts where name='"+serviceName_+"'";
-        const char* csql_=strsql_.c_str();
+        std::string strsql="SELECT  name, wmts_type, vendor, create_time::character, crs, datasource, metadata_url,layer_name, layer_alias, layer_title, layer_style, layer_format, layer_extent, scheme_guid	FROM public.dmap_wmts where name='"+serviceName+"'";
+        const char* csql=strsql.c_str();
             
         //PGconn* pconn_=PQconnectdb(conn_);
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            std::string Msg_= (std::string)PQerrorMessage(basepconn_);
+            std::string Msg= (std::string)PQerrorMessage(basepconn_);
             PQfinish(basepconn_);
             return false;
         }        
-        PGresult *res_;
-        res_ = PQexec(basepconn_,csql_);
-        int tuple_num=PQntuples(res_);
-        int field_num=PQnfields(res_);
+        PGresult *res;
+        res = PQexec(basepconn_,csql);
+        int tuple_num=PQntuples(res);
+        int field_num=PQnfields(res);
         
         if(tuple_num>0)
         {            
-            resWmts_.name=PQgetvalue(res_,0,0);
-            resWmts_.type=PQgetvalue(res_,0,1);
-            std::string v=PQgetvalue(res_,0,2);            
-            resWmts_.vendor=StringToVendor(v);
-            resWmts_.create_time=PQgetvalue(res_,0,3);
-            resWmts_.crs=PQgetvalue(res_,0,4);
-            resWmts_.datasource=PQgetvalue(res_,0,5);
-            resWmts_.metadata_url=PQgetvalue(res_,0,6);
-            resWmts_.layername=PQgetvalue(res_,0,7);
-            resWmts_.layer_alias=PQgetvalue(res_,0,8);
-            resWmts_.layer_tile=PQgetvalue(res_,0,9);
-            resWmts_.layer_style=PQgetvalue(res_,0,10);
-            resWmts_.layer_format=PQgetvalue(res_,0,11);
-            resWmts_.layer_extent=PQgetvalue(res_,0,12);          
-            resWmts_.tile_id= PQgetvalue(res_,0,13);           
+            resWmts.name=PQgetvalue(res,0,0);
+            resWmts.type=PQgetvalue(res,0,1);
+            std::string v=PQgetvalue(res,0,2);            
+            resWmts.vendor=StringToVendor(v);
+            resWmts.create_time=PQgetvalue(res,0,3);
+            resWmts.crs=PQgetvalue(res,0,4);
+            resWmts.datasource=PQgetvalue(res,0,5);
+            resWmts.metadata_url=PQgetvalue(res,0,6);
+            resWmts.layername=PQgetvalue(res,0,7);
+            resWmts.layer_alias=PQgetvalue(res,0,8);
+            resWmts.layer_tile=PQgetvalue(res,0,9);
+            resWmts.layer_style=PQgetvalue(res,0,10);
+            resWmts.layer_format=PQgetvalue(res,0,11);
+            resWmts.layer_extent=PQgetvalue(res,0,12);          
+            resWmts.tile_id= PQgetvalue(res,0,13);           
         }
         else
         {
             return false;
         }
-        PQclear(res_);
+        PQclear(res);
         return true;
     }
-    bool DmpPgsqlUtils::GetTileScheme(const std::string& guid_,TileScheme& tileScheme_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetTileScheme(const std::string& guid,TileScheme& tileScheme,std::string& Msg)
     {
-        std::string strsql_="SELECT guid, name, alias, description, crs, crs_wkt, extent, top_left, levels, dpi::character, rows::character, cols::character, update_time, parameter FROM public.dmap_tile_scheme where guid='"+guid_+"'";
-        const char* csql_=strsql_.c_str();
+        std::string strsql="SELECT guid, name, alias, description, crs, crs_wkt, extent, top_left, levels, dpi::character, rows::character, cols::character, update_time, parameter FROM public.dmap_tile_scheme where guid='"+guid+"'";
+        const char* csql=strsql.c_str();
             
         //PGconn* pconn_=PQconnectdb(conn_);
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            std::string Msg_= (std::string)PQerrorMessage(basepconn_);
+            std::string Msg= (std::string)PQerrorMessage(basepconn_);
             PQfinish(basepconn_);
             return false;
         }        
-        PGresult *res_;
-        res_ = PQexec(basepconn_,csql_);
-        int tuple_num=PQntuples(res_);
-        int field_num=PQnfields(res_);
+        PGresult *res;
+        res = PQexec(basepconn_,csql);
+        int tuple_num=PQntuples(res);
+        int field_num=PQnfields(res);
         
         if(tuple_num>0)
         {            
-            tileScheme_.guid=PQgetvalue(res_,0,0);
-            tileScheme_.name=PQgetvalue(res_,0,1);
-            tileScheme_.crs=PQgetvalue(res_,0,4);
-            tileScheme_.wkt=PQgetvalue(res_,0,5);
-            tileScheme_.layer_extent=PQgetvalue(res_,0,6);
-            tileScheme_.top_left=PQgetvalue(res_,0,7);
-            tileScheme_.levels=PQgetvalue(res_,0,8);
-            tileScheme_.dpi=PQgetvalue(res_,0,9);
-            tileScheme_.rows=PQgetvalue(res_,0,10);
-            tileScheme_.cols=PQgetvalue(res_,0,11);
+            tileScheme.guid=PQgetvalue(res,0,0);
+            tileScheme.name=PQgetvalue(res,0,1);
+            tileScheme.crs=PQgetvalue(res,0,4);
+            tileScheme.wkt=PQgetvalue(res,0,5);
+            tileScheme.layer_extent=PQgetvalue(res,0,6);
+            tileScheme.top_left=PQgetvalue(res,0,7);
+            tileScheme.levels=PQgetvalue(res,0,8);
+            tileScheme.dpi=PQgetvalue(res,0,9);
+            tileScheme.rows=PQgetvalue(res,0,10);
+            tileScheme.cols=PQgetvalue(res,0,11);
         }
         else
         {
             return false;
         }
-        PQclear(res_);
+        PQclear(res);
         return true;
     }
-    bool DmpPgsqlUtils::CreatServerPTree(const DMapService &dmapServices_,const DMapWmtsService& resWmts_,boost::property_tree::ptree& pt_root)
+    bool DmpPgsqlUtils::CreatServerPTree(const DMapService &dmapServices,const DMapWmtsService& resWmts,boost::property_tree::ptree& pt_root)
     {
         boost::property_tree::ptree pt_properties;
-        pt_root.add("serviceName",dmapServices_.name);
-        pt_root.add("mapType",dmapServices_.type);
-        pt_root.add("state",dmapServices_.state);
-        pt_root.add("capabilities",dmapServices_.type+"Server");
+        pt_root.add("serviceName",dmapServices.name);
+        pt_root.add("mapType",dmapServices.type);
+        pt_root.add("state",dmapServices.state);
+        pt_root.add("capabilities",dmapServices.type+"Server");
         pt_root.add_child("properties",pt_properties);
         pt_properties.add("filePath","postgresql");
         pt_properties.add("maxScale","");
@@ -243,40 +243,40 @@
         //pt_service.add("typeName",atoi(dmpwmtsservices_.type.c_str()));
         pt_service.add("typeName",0);
         pt_service.add("enabled","true");
-        pt_service.add("properties.tileVersion",resWmts_.vendor);
-        pt_service.add("properties.tilePath",resWmts_.datasource);
+        pt_service.add("properties.tileVersion",resWmts.vendor);
+        pt_service.add("properties.tilePath",resWmts.datasource);
         pt_service.add("capabilities","");
         pt_services.push_back(std::make_pair("", pt_service)); 
         pt_root.put_child("services",pt_services);
         return true;
     }
-    bool DmpPgsqlUtils::GetDMapServices(DMapService &dmapService_,const std::string serviceName_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetDMapServices(DMapService &dmapService,const std::string serviceName,std::string& Msg)
     {
-        PGresult *res_;
+        PGresult *res;
         const char* strsql="SELECT  name, title, state::character, create_time, update_time, description, node::character, overview, type, service_guid, catalog_guid FROM public.dmap_service where type='WMTS'";
         //char* conn_="hostaddr=172.26.60.100 port=5432 dbname=dmap_manager_test user=postgres password=chinadci";     
         //PGconn* pconn_=PQconnectdb(conn_);
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            std::string Msg_= (std::string)PQerrorMessage(basepconn_);
+            std::string Msg= (std::string)PQerrorMessage(basepconn_);
             PQfinish(basepconn_);
             return false;
         }        
-        res_ = PQexec(basepconn_,strsql);
-        int tuple_num=PQntuples(res_);
+        res = PQexec(basepconn_,strsql);
+        int tuple_num=PQntuples(res);
         if(tuple_num>0)
         {
-            dmapService_.name=PQgetvalue(res_,0,0);
-            dmapService_.state=PQgetvalue(res_,0,2);
-            dmapService_.create_time=PQgetvalue(res_,0,3);
-            dmapService_.type=PQgetvalue(res_,0,8);
-            dmapService_.service_guid=PQgetvalue(res_,0,9);
+            dmapService.name=PQgetvalue(res,0,0);
+            dmapService.state=PQgetvalue(res,0,2);
+            dmapService.create_time=PQgetvalue(res,0,3);
+            dmapService.type=PQgetvalue(res,0,8);
+            dmapService.service_guid=PQgetvalue(res,0,9);
         }  
         else
         {
             return false;
         }   
-        PQclear(res_);   
+        PQclear(res);   
         return true; 
     }
 

@@ -68,15 +68,15 @@
         DmpPgsqlUtils();
         ~DmpPgsqlUtils();
         
-        void do_exit(PGconn *conn_);
+        void do_exit(PGconn *conn);
         //bool ExecuteQuery(const std::string& sqlstr,resMap& resMap_,std::string& Msg_);
-        bool GetDMapServices(std::map<int,DMapService> &dmapServices_,std::string& Msg_);
-        bool GetDMapService(DMapService &dmapService_,const std::string& servicename_,std::string& Msg_);
-        bool GetDMapwmts(const std::string& serviceGuid_, DMapWmtsService& resWmts_,std::string& Msg_);
-        bool GetDMapwmtsFromName(const std::string& serviceName_, DMapWmtsService& resWmts_,std::string& Msg_);
-        bool GetTileScheme(const std::string& guid_, TileScheme& tileScheme_,std::string& Msg_);
-        bool CreatServerPTree(const DMapService &dmapServices_,const DMapWmtsService& resWmts_,boost::property_tree::ptree& pt_root);
-        bool GetDMapServices(DMapService &dmapService_,const std::string serviceName_,std::string& Msg_);
+        bool GetDMapServices(std::map<int,DMapService> &dmapServices,std::string& Msg);
+        bool GetDMapService(DMapService &dmapService,const std::string& servicename,std::string& Msg);
+        bool GetDMapwmts(const std::string& serviceGuid, DMapWmtsService& resWmts,std::string& Msg);
+        bool GetDMapwmtsFromName(const std::string& serviceName, DMapWmtsService& resWmts,std::string& Msg);
+        bool GetTileScheme(const std::string& guid, TileScheme& tileScheme,std::string& Msg);
+        bool CreatServerPTree(const DMapService &dmapServices,const DMapWmtsService& resWmts,boost::property_tree::ptree& pt_root);
+        bool GetDMapServices(DMapService &dmapService,const std::string serviceName,std::string& Msg);
         std::string StringToVendor(const std::string str);
     };
     

@@ -145,11 +145,11 @@ bool DmpServerManager::stopService(const std::string &serverName, const std::str
 }
 bool DmpServerManager::LoadServices()
 {
-    boost::property_tree::ptree pt_,ptList_;
+    boost::property_tree::ptree pt,ptList;
 
-    const std::string url_="http://172.26.60.100:8841/API/Service/TileService/Reload";
-    std::string strContent_=DmpHttp::get(url_);
-    if(strContent_.length()==0)
+    const std::string url="http://172.26.60.100:8841/API/Service/TileService/Reload";
+    std::string strContent=DmpHttp::get(url);
+    if(strContent.length()==0)
     {
         return false;
     }
@@ -162,21 +162,21 @@ bool DmpServerManager::LoadServices()
     // }
     //boost::property_tree::read_json("./example.txt", pt_);
     
-    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::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)
     {
-        ptList_=pt_.get_child("data.list");
-        for (auto& e : ptList_) 
+        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->publish(type_,name_,capabilities_,project_);
+            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->publish(type,name,capabilities,project);
         }
     }
     return true;

@@ -177,7 +177,7 @@ void DmpManagerApiHandler::startService(const DmpServerApiContext &context) cons
         }
         default:
         {
-       
+            
         }
     }
 }

+/**************************************************************************
+* file:              dmppgsql.cpp
+
+* Author:            qingxiongf
+* Date:              2021-12-11 13:43:42
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmppgsql.h"
+#include <time.h>
+
+namespace mapserver 
+{
+    DmpPgsql::DmpPgsql()
+    {
+        pPGconn_ = NULL;
+		pPGresult_ = NULL;
+		bAutoReconnect_ = true;
+		m_iN = 1;
+		index_ = 0;
+		aliveTime_ = time(nullptr);
+    }
+
+	DmpPgsql::~DmpPgsql()
+    {
+        this->FreeResult();
+		this->CloseConn();
+    }
+
+	void DmpPgsql::refreshAliveTime()
+	{
+		aliveTime_ = time(nullptr);
+	}
+
+	bool DmpPgsql::Connect(const string& s)
+	{
+		return this->Connect(s.c_str());
+	}
+    bool DmpPgsql::Connect(const char * s)
+	{
+		CloseConn();
+		FreeResult();
+		pPGconn_ = PQconnectdb(s);
+		ConnStatusType t = PQstatus(pPGconn_);
+		if (t != CONNECTION_OK)
+			return false;
+		int re = PQsetClientEncoding(pPGconn_, "UTF-8");
+		if (re == -1)
+		{
+			CloseConn(); return false;
+		}
+		this->sConnInfo_ = s;
+		return true;
+	}
+
+	bool DmpPgsql::CloseConn()
+	{
+		if (pPGconn_)
+		{
+			PQfinish(pPGconn_);
+			pPGconn_ = NULL;
+		}
+		return true;
+	}
+
+	bool DmpPgsql::FreeResult()
+	{
+		if (pPGresult_)
+		{
+			PQclear(pPGresult_);
+			pPGresult_ = NULL;
+		}
+		m_iN = 1;
+		index_ = 0;
+		rowCount_ = 0;
+		return true;
+	}
+
+	bool DmpPgsql::ExecWait(const string& sql)
+	{
+		return this->ExecWait(sql.c_str());
+	}
+
+	
+
+    bool DmpPgsql::ExecWait(const char * sql)
+	{
+		FreeResult();
+
+		pPGresult_ = PQexec(pPGconn_, sql);
+		char *sz = PQerrorMessage(pPGconn_);
+		sError_ = sz;
+
+		if (sz &&strlen(sz)>0 && bAutoReconnect_ && pPGresult_== NULL)
+		{
+			if (this->TryReconn())
+			{
+				pPGresult_ = PQexecParams(pPGconn_, sql, 0, 0, 0, 0, 0, 1);
+				sz = PQerrorMessage(pPGconn_);
+				sError_ = sz;
+			}
+		}
+		rowCount_ = PQntuples(pPGresult_);
+		index_ = -1;
+		return sError_ == "";
+	}
+
+
+    bool DmpPgsql::ExecWaitBinary(const std::string& sql)
+	{
+		return this->ExecWaitBinary(sql.c_str());
+	}
+
+
+	bool DmpPgsql::ExecWaitBinary(const char * sql)
+	{
+		FreeResult();
+		pPGresult_ = PQexecParams(pPGconn_, sql, 0, 0, 0, 0, 0, 1);
+		char *sz = PQerrorMessage(pPGconn_);
+		sError_ = sz;
+
+		if (sz &&strlen(sz)>0 && bAutoReconnect_ && pPGresult_ == NULL)
+		{
+			if (this->TryReconn())
+			{
+				pPGresult_ = PQexecParams(pPGconn_, sql, 0, 0, 0, 0, 0, 1);
+				sz = PQerrorMessage(pPGconn_);
+				sError_ = sz;
+			}
+			
+		}
+		rowCount_ = PQntuples(pPGresult_);
+		index_ = -1;
+		return sError_ == "";
+	}
+
+	bool DmpPgsql::ExecOnly(const string& sql)
+	{
+		return this->ExecOnly(sql.c_str());
+	}
+
+	bool DmpPgsql::ExecOnly(const char * sql)
+	{
+		PGresult *r = PQexec(pPGconn_, sql);
+
+		if (r)
+			PQclear(r);
+		char* sz = PQerrorMessage(pPGconn_);   // 这样对吗??? PQclear对　message 获取会不会有影响??
+		sError_ = sz;
+
+		if (sz&&bAutoReconnect_)
+			this->TryReconn();
+		return sError_ == "";
+	}
+
+	int DmpPgsql::next(void)
+	{
+		if (rowCount_ == 0)
+		{
+			rowCount_ = PQntuples(pPGresult_);
+		}
+		index_++;
+
+		if (index_ >= rowCount_)
+		{
+			return false;
+		}
+		else
+		{
+			return true;
+		}
+
+		//return index_;
+	}
+
+	bool DmpPgsql::Get(int index, std::string * str)
+	{
+		*str = PQgetvalue(pPGresult_, index_, index);
+		return true;
+	}
+
+	bool DmpPgsql::Get(int index, double * str)
+	{
+		*str = atof(PQgetvalue(pPGresult_, index_, index));
+		return true;
+	}
+
+
+	bool DmpPgsql::Get(int index, bool * str)
+	{
+		char *ss = PQgetvalue(pPGresult_, index_, index);
+		if (ss == 0)
+		{
+			*str = false;
+		}
+		char c = ss[0];
+		if (c == 0 || c == ' ' || c == 'f' || c == 'F')
+		{
+			*str = false;
+		}
+		else
+		{
+			*str = true;
+		}
+		return true;
+	}
+
+
+
+	int DmpPgsql::getInt(int index)
+	{
+		return atoi(PQgetvalue(pPGresult_, index_, index));
+	}
+
+	double DmpPgsql::getDouble(int index)
+	{
+		return atof(PQgetvalue(pPGresult_, index_, index));
+	}
+
+	const char* DmpPgsql::getString(int index)
+	{
+		if(index_ == -1) index_ = 0;
+		//	static const char *blankstring="";
+		const char *a = PQgetvalue(this->pPGresult_, index_, index);
+		if (a == 0)
+		{
+			return "";
+		}
+		else
+		{
+			return a;
+		}
+	}
+
+	bool DmpPgsql::TryReconn()
+	{
+		if (Connect(this->sConnInfo_.c_str()))return true;
+		return false;
+	}
+
+}
\ No newline at end of file

+/**************************************************************************
+* file:              dmppgsql.h
+
+* Author:            qingxiongf
+* Date:              2021-12-11 13:43:17
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmppgsql_h__
+#define __dmppgsql_h__
+#include <string>
+#include <string.h>
+#include <vector>
+#include"libpq-fe.h"
+
+using namespace std;
+namespace mapserver 
+{
+	enum PGFieldType
+	{	
+		ShapeFieldType,
+		ShapeFieldPoint,
+		ShapeFieldLine,
+		ShapeFieldPolygon,
+		IntFieldType,
+		DoubleFieldType,
+		VarCharFieldType,
+		ByteaFieldType,
+		ClobFieldType,
+		DateFieldType ,
+		BigIntFieldType,
+		TimestampWithoutTimeZone,
+		UnknowFieldType
+	};	
+
+	class DmpPgsql
+	{
+	public:
+
+		DmpPgsql();
+		~DmpPgsql();
+	
+		bool Connect(const string& conninfo);
+		bool Connect(const char* conninfo);
+		bool CloseConn();
+		bool FreeResult();
+		bool ExecWaitBinary(const std::string& sql);
+		bool ExecWaitBinary(const char *sql);
+		bool ExecWait(const char * sql);
+		bool ExecWait(const std::string& sql);
+		bool ExecOnly(const char * sql);
+		bool ExecOnly(const std::string& sql);
+
+		bool ContainTable(string tableName,string schema);
+		bool GetTableList(string &result, bool isXml);
+		bool GetTableInfo(string tableschema,string tablename,  string &shapeType, string &srid);
+		bool GetValueList(string& resultMsg,string tableschema,string layername, string fieldname);
+
+		bool TryReconn(void);
+
+		PGresult* GetPGresult(){ return pPGresult_;}
+
+    //    int GetRowCount();
+	//	int GetFieldCount();
+	//	char *GetFieldName(int index);
+	//	int GetFieldType(int index);
+	public:
+		
+		//void PrepareFieldhead();
+		//void FreeResult(void);
+
+		int next(void);
+		bool Get(int index, std::string *str);
+		bool Get(int index, double *str);
+		bool Get(int index, bool *v);
+
+		const char *getString(int index);
+		double getDouble(int index);
+		int getInt(int index);
+
+	//	bool GetAutoReconnect();
+	//	bool SetAutoReconnect(bool autoReconnect);
+
+
+	//	void ToHexLen(const unsigned char * from, int len, char * to);
+	//	char ToHex1(const int i);
+	//	void ToUpper(char * sz);
+	//	void ToLower(char * sz);
+	//	bool PQescapeStringConnArray(std::vector<std::string> &arr, size_t size);
+
+	//	string TimeToName(time_t tm);
+
+		void refreshAliveTime();
+		long aliveTime(){return aliveTime_;}
+		std::string error() const{return sError_;}
+
+private:
+		bool bAutoReconnect_ = true;
+		int index_ = 0;
+		int rowCount_ =0;
+
+		std::string sConnInfo_;
+	    long aliveTime_;
+
+		void * m_handle;
+
+        int m_iN;        //对象引用计数
+		int fieldCount;
+
+        PGconn* pPGconn_;
+		PGresult* pPGresult_;
+		/*
+		错误信息
+		*/
+		string sError_;
+
+	};
+}
+
+
+#endif // __dmppgsql_h__

+/**************************************************************************
+* file:              dmppgsqlpool.cpp
+
+* Author:            qingxiongf
+* Date:              2021-12-11 11:53:36
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include <thread>
+#include <functional>
+#include <iostream>
+#include "dmppgsqlpool.h"
+#define MAX_SIZE 40
+namespace mapserver
+{
+	DmpPgsqlPool::DmpPgsqlPool()
+	{
+		waitConnectSize_ = MAX_SIZE;
+		connectionTimeout_ = 15000;
+	}
+
+	DmpPgsqlPool::~DmpPgsqlPool()
+	{
+		this->Close();
+	}
+
+	std::shared_ptr<DmpPgsql> DmpPgsqlPool::TestDmpPgsql(void)
+	{
+
+		unique_lock<mutex> lock(mutex_);
+		std::cout << "QCount = " << connectionQue_.size() << endl;
+		while (connectionQue_.empty())
+		{
+			if (cv_status::timeout == cv_.wait_for(lock, std::chrono::milliseconds(20000)))
+			{
+
+				if (connectionQue_.empty())
+				{
+					printf("Failed to get connection:got idle connection timeout!\r\n");
+					return nullptr;
+				}
+				else
+				{
+					printf("Surcce to get connection**!\r\n");
+				}
+			}
+			else
+			{
+				printf("Surcce to get connection!!!!\r\n");
+			}
+		}
+
+		/*
+     * std::shared_ptr智能指针析构时，会把connection资源直接delete掉，
+     * 相当于调用connection的析构函数，connection就被close掉了。
+     * 这里需要自定义std::shared_ptr的释放资源的方式，把connection直接归还到queue当中*/
+		std::shared_ptr<DmpPgsql> sp(connectionQue_.front(),
+								 [&](DmpPgsql *pcon)
+								 {
+									 // 这里是在服务器应用线程中调用的，所以一定要考虑队列的线程安全操作
+									 unique_lock<mutex> lock(mutex_);
+									
+									 pcon->FreeResult();
+									 pcon->refreshAliveTime(); //在归还回空闲连接队列之前要记录一下连接开始空闲的时刻
+									 connectionQue_.push(pcon);
+									 cv_.notify_one();
+									 std::cout << "notify_one = " << connectionQue_.size() << endl;
+								 });
+
+		connectionQue_.pop();
+
+		// 消费者取出一个连接之后，通知生产者，生产者检查队列，如果为空则生产
+
+		return sp;
+
+		//std::shared_ptr<CDmpPgsqlPoolZero2> poolZero(new CDmpPgsqlPoolZero2(this,nullptr));
+		//return poolZero;
+	}
+
+	
+	
+	std::shared_ptr<DmpPgsql> DmpPgsqlPool::GetPgsqlConn(void)
+	{
+
+		unique_lock<mutex> lock(mutex_);
+
+		while (connectionQue_.empty())
+		{
+
+			if(this->connectSize_ < MAX_SIZE)
+			{
+				DmpPgsql *p = this->GetConnect();
+				p->refreshAliveTime();
+				if(p)
+				{
+					std::shared_ptr<DmpPgsql> sp0(p,
+					[&](DmpPgsql *pcon)
+					{
+									 // 这里是在服务器应用线程中调用的，所以一定要考虑队列的线程安全操作
+									 unique_lock<mutex> lock(mutex_);
+
+									 pcon->refreshAliveTime(); //在归还回空闲连接队列之前要记录一下连接开始空闲的时刻
+									 connectionQue_.push(pcon);
+									 cv_.notify_one();
+					});
+
+								// 消费者取出一个连接之后，通知生产者，生产者检查队列，如果为空则生产
+
+					return sp0;
+				}
+			}
+
+			if (cv_status::timeout == cv_.wait_for(lock, std::chrono::milliseconds(connectionTimeout_)))
+			{
+
+				if (connectionQue_.empty())
+				{
+					
+					printf("Failed to get postgresql connection: timeout!\r\n");
+					return nullptr;
+				
+				}
+			}
+		}
+
+
+		//printf("wite conn %d\r\n",connectionQue_.size());
+
+		/*
+     * std::shared_ptr智能指针析构时，会把connection资源直接delete掉，
+     * 相当于调用connection的析构函数，connection就被close掉了。
+     * 这里需要自定义std::shared_ptr的释放资源的方式，把connection直接归还到queue当中*/
+		std::shared_ptr<DmpPgsql> sp(connectionQue_.front(),
+								 [&](DmpPgsql *pcon)
+								 {
+									 // 这里是在服务器应用线程中调用的，所以一定要考虑队列的线程安全操作
+									 unique_lock<mutex> lock(mutex_);
+									 pcon->FreeResult();
+									 pcon->refreshAliveTime(); //在归还回空闲连接队列之前要记录一下连接开始空闲的时刻
+									 connectionQue_.push(pcon);
+									 cv_.notify_one();
+								 });
+
+		connectionQue_.pop();
+
+		// 消费者取出一个连接之后，通知生产者，生产者检查队列，如果为空则生产
+
+		return sp;
+
+		//std::shared_ptr<CDmpPgsqlPoolZero2> poolZero(new CDmpPgsqlPoolZero2(this,nullptr));
+		//return poolZero;
+	}
+
+	void DmpPgsqlPool::ScannerConnectionTask()
+	{
+		for (;;)
+		{
+			// 通过sleep模拟定时效果
+			this_thread::sleep_for(chrono::seconds(300));
+			//thread::s
+			// 扫描队列，释放多余的连接
+
+			if(isClose_) return;
+
+			unique_lock<mutex> lock(mutex_);
+
+			time_t t =time(NULL);
+
+			while (connectionQue_.size() > 2)
+			{
+				DmpPgsql *p = connectionQue_.front();
+				if(!p) continue;
+
+				if( t - p->aliveTime() >300)
+				{
+					connectionQue_.pop();
+					this->connectSize_--;
+					delete p;
+				}
+				else
+				{
+					break; //队头连接没有超时 其他连接肯定没有超时
+				}
+			}
+		}
+	}
+
+	void DmpPgsqlPool::ReleaseHandle(DmpPgsql *handler)
+	{
+		connectionQue_.push(handler);
+		cv_.notify_all();
+	}
+
+	void DmpPgsqlPool::Close()
+	{
+		isClose_ = true;
+		if (connectionQue_.size() > 0)
+		{
+			DmpPgsql *p = connectionQue_.front();
+			{
+				this->connectSize_--;
+				delete p;
+			}
+		}
+	}
+
+	bool DmpPgsqlPool::Connect(const char *s)
+	{
+		this->conninfo_ = s;
+		for (int i = 0; i < 2; i++)
+		{
+			DmpPgsql *pgsqlConn = new DmpPgsql();
+			//bool pConnOK = true;
+			bool b = pgsqlConn->Connect(conninfo_);
+			if (b)
+			{
+				this->connectSize_++;
+				connectionQue_.push(pgsqlConn);
+			}
+			else
+			{
+				//printf("%s connect failed: %s \r\n", s, pgsqlConn->sError_.c_str());
+				delete pgsqlConn;
+				pgsqlConn = NULL;
+				return false;
+			}
+		}
+
+		thread scanner(std::bind(&DmpPgsqlPool::ScannerConnectionTask,this));
+		scanner.detach();
+		return true;
+	}
+
+	DmpPgsql* DmpPgsqlPool::GetConnect()
+	{
+		//this->conninfo_ = s;
+		DmpPgsql *pgsqlConn = new DmpPgsql();
+		//bool pConnOK = true;
+		bool b = pgsqlConn->Connect(conninfo_);
+		if (b)
+		{
+			this->connectSize_++;
+			//connectionQue_.push(pgsqlConn);
+			return pgsqlConn;
+		}
+		else
+		{
+			delete pgsqlConn;
+			pgsqlConn = NULL;
+		}
+		return pgsqlConn;
+	}
+
+}
\ No newline at end of file

+/**************************************************************************
+* file:              dmppgsqlpool.h
+
+* Author:            fanqingxiong
+* Date:              2021-11-19 15:40:28
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmppgsqlpool_h__
+#define __dmppgsqlpool_h__
+
+#include <queue>
+#include <memory>
+#include <mutex>
+#include <condition_variable>
+#include "dmppgsql.h"
+
+namespace mapserver
+{
+	class DmpPgsqlPool
+	{		
+public:
+		DmpPgsqlPool();
+		~DmpPgsqlPool();
+	    void ScannerConnectionTask();
+		std::shared_ptr<DmpPgsql> TestDmpPgsql(void);
+        std::shared_ptr<DmpPgsql> GetPgsqlConn(void);
+		void ReleaseHandle(DmpPgsql*);
+
+		void Close(void);
+		bool Connect(const char * s);
+		DmpPgsql* GetConnect();
+        std::string guid()const { return guid_;} 
+	    std::string name()const { return name_;} 
+	    std::string alias()const{ return alias_;} 
+
+private:
+        std::string conninfo_;
+		// 存储连接的队列
+        queue<DmpPgsql*> connectionQue_;
+		int waitConnectSize_;
+		int connectSize_ = 0;
+		mutex mutex_;
+		//连接超时时间
+		int connectionTimeout_;  
+
+      // 设置条件变量，用于连接生产线程和连接消费线程的通信
+       condition_variable cv_;
+	   bool isClose_ = false;
+       std::string guid_;
+	   std::string name_;
+	   std::string alias_;
+	};
+	
+}
+
+
+#endif //__dmppgsqlpool_h__
+

+/**************************************************************************
+* file:              dmppgsqlsourcepools.cpp
+
+* Author:            qingxiongf
+* Date:              2021-12-11 11:53:36
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#include "dmppgsqlsourcepools.h"
+#include <iostream>
+//#include "DES.h"
+//#include "StringHelp.h"
+
+namespace mapserver
+{
+    DmpPgsqlSourcePools* DmpPgsqlSourcePools::instance_ptr = nullptr;
+
+    DmpPgsqlSourcePools* DmpPgsqlSourcePools::get_instance()
+    {
+        if(instance_ptr==nullptr){
+              instance_ptr = new DmpPgsqlSourcePools();
+        }
+        return instance_ptr;
+    }
+
+
+    DmpPgsqlSourcePools::DmpPgsqlSourcePools()
+    {
+
+    }
+
+    DmpPgsqlSourcePools::~DmpPgsqlSourcePools()
+    {
+
+    }
+
+    shared_ptr<DmpPgsql> DmpPgsqlSourcePools::GetDefaultPgsqlConn()
+    {
+        if (defaultPool_ != nullptr)
+        {
+            return defaultPool_->GetPgsqlConn();
+        }
+        return nullptr;
+    }
+/*
+    shared_ptr<DmpPgsql> DmpPgsqlSourcePools::GetPgsqlConn(char* name)
+    {
+        if(name == 0)
+        {
+            return GetDefaultPgsqlConn();
+        }
+        else
+        {
+            string n = name;
+            return GetPgsqlConn(n);
+        }
+    }
+*/
+
+    shared_ptr<DmpPgsql> DmpPgsqlSourcePools::GetPgsqlConn(const string& name)
+    {
+       
+        map<string, shared_ptr<DmpPgsqlPool>>::iterator poolIter = this->pgsqlPool_.find(name);
+        if (poolIter != this->pgsqlPool_.end())
+        {
+            shared_ptr<DmpPgsqlPool> pool = poolIter->second;
+            return pool->GetPgsqlConn();
+        }
+
+      
+        unique_lock<mutex> lock(mutex_);
+
+        map<string, shared_ptr<DmpPgsqlPool>>::iterator poolIter3 = this->pgsqlPool_.find(name);
+        if (poolIter3 != this->pgsqlPool_.end())
+        {
+            shared_ptr<DmpPgsqlPool> pool = poolIter3->second;
+            return pool->GetPgsqlConn();
+        }
+
+       
+        AddDatabasePool("postgis", name, name,name, name);
+
+         map<string, shared_ptr<DmpPgsqlPool>>::iterator poolIter2 = this->pgsqlPool_.find(name);
+        if (poolIter2 != this->pgsqlPool_.end())
+        {
+            shared_ptr<DmpPgsqlPool> pool = poolIter2->second;
+            return pool->GetPgsqlConn();
+        }
+
+        return nullptr;
+    }
+
+
+
+/*
+    shared_ptr<DmpPgsql> DmpPgsqlSourcePools::GetPgsqlConn(string name)
+    {
+        if(name == "")
+        {
+            return GetDefaultPgsqlConn();
+        }
+        unique_lock<mutex> lock(mutex_);
+        map<string, shared_ptr<DmpPgsqlPool>>::iterator poolIter = this->pgsqlPool_.find(name);
+        if (poolIter != this->pgsqlPool_.end())
+        {
+            shared_ptr<DmpPgsqlPool> pool = poolIter->second;
+            return pool->GetPgsqlConn();
+        }
+
+        for(poolIter =  this->pgsqlPool_.begin(); poolIter != this->pgsqlPool_.end(); poolIter++)
+        {
+            shared_ptr<DmpPgsqlPool> pool = poolIter->second;
+            if(pool->alias() == name)
+            {
+                return pool->GetPgsqlConn();
+            }
+        }
+        if(!this->updateLock_)
+        {
+            this->updateLock_ = true;
+            UpdateDatabasePool();
+            this->updateLock_ = false;
+        }
+      
+
+        map<string, shared_ptr<DmpPgsqlPool>>::iterator poolIter2 = this->pgsqlPool_.find(name);
+        if (poolIter2 != this->pgsqlPool_.end())
+        {
+            shared_ptr<DmpPgsqlPool> pool = poolIter2->second;
+            return pool->GetPgsqlConn();
+        }
+
+        for(poolIter2 =  this->pgsqlPool_.begin(); poolIter2 != this->pgsqlPool_.end(); poolIter2++)
+        {
+            shared_ptr<DmpPgsqlPool> pool = poolIter2->second;
+            if(pool->alias() == name)
+            {
+                return pool->GetPgsqlConn();
+            }
+        }
+
+        return nullptr;
+    }
+*/
+    string DmpPgsqlSourcePools::GetDbSourceID(string name)
+    {
+       if(name == "")
+        {
+            return "";
+        }
+        map<string, shared_ptr<DmpPgsqlPool>>::iterator poolIter = this->pgsqlPool_.find(name);
+        if (poolIter != this->pgsqlPool_.end())
+        {
+            return name;
+        }
+
+        for(poolIter =  this->pgsqlPool_.begin(); poolIter != this->pgsqlPool_.end(); poolIter++)
+        {
+            shared_ptr<DmpPgsqlPool> pool = poolIter->second;
+            if(pool->alias() == name)
+            {
+                return pool->guid();
+            }
+        }
+        return "";
+    }
+
+    bool DmpPgsqlSourcePools::UpdateDatabasePool()
+    {
+        printf("InitDatabasePool\r\n");
+        char sqlBuff[500];
+        sprintf(sqlBuff, "SELECT guid, name, alias, sqlalchemy_uri,connectstr FROM %s.%s",DMAP_SCHEMA, DMAP_DMDMS_DATABASE);
+        
+        shared_ptr<DmpPgsql> pPgsqlConn = this->GetDefaultPgsqlConn();
+        if(pPgsqlConn == nullptr)
+        {
+            return false;
+        }
+        bool result = pPgsqlConn->ExecWaitBinary(sqlBuff);
+        if(result == false)
+        {
+            std::cout<< "InitDatabasePool error:" << pPgsqlConn->error().c_str();
+            return false;
+        }
+
+        map<string,bool> list;
+        for( map<string, shared_ptr<DmpPgsqlPool>>::iterator iter= pgsqlPool_.begin();
+             iter !=  pgsqlPool_.end(); iter++)
+            {
+                list[iter->first] = false;
+            }
+
+        while (pPgsqlConn->next())
+        {
+           string guid = pPgsqlConn->getString(0);
+           string name = pPgsqlConn->getString(1);
+           string alias = pPgsqlConn->getString(2);
+           string uri = pPgsqlConn->getString(3);
+           string connectstr = pPgsqlConn->getString(4);
+
+          
+
+           list[guid] = true;
+
+           string pgConnect= "";
+           if(connectstr != "")
+           {
+               char key[] = "Chinadci";
+               char decry[500] = { 0 };
+              // shared_ptr<clsMalloc> b = DmapDll::StringHelp::base64_decode_rbyte(connectstr);
+             //  Decrypt((unsigned char*)b->mem, b->GetSize(), (unsigned char*)key, (unsigned char*)decry);
+              // string connectstrUrl = decry;
+             //  printf("");
+             //  UpdDatabasePool("postgresql", guid, name,alias, connectstrUrl);
+           }
+           else if(uri != "")
+           {
+               char key[] = "Chinadci";
+               char decry[500] = { 0 };
+              //  shared_ptr<clsMalloc> b = DmapDll::StringHelp::base64_decode_rbyte(connectstr);
+              //  Decrypt((unsigned char*)b->mem,b->GetSize(), (unsigned char*)key, (unsigned char*)decry);
+                string jdbcConnect = "";
+
+                string dbType = "";
+               
+                if(jdbcConnect != "")
+                {
+                    string username = "";
+                    string password = "";
+                    string ip = "";
+                    string port = "5432";
+                    string dbname = "";
+
+                    size_t n =0;
+                    if ((n = jdbcConnect.find("://")) != string::npos)
+                    {
+                        dbType =  jdbcConnect.substr(0,n);
+                        jdbcConnect =  jdbcConnect.substr(n+3);
+                    }
+                   
+                    if ((n = jdbcConnect.find(":")) != string::npos)
+                    {
+                        username =  jdbcConnect.substr(0,n);
+                        jdbcConnect =  jdbcConnect.substr(n+1);
+                    }
+
+                    if ((n = jdbcConnect.find_last_of("@")) != string::npos)
+                    {
+                        password =  jdbcConnect.substr(0,n);
+                        jdbcConnect =  jdbcConnect.substr(n+1);
+                    }
+
+                    if ((n = jdbcConnect.find("/")) != string::npos)
+                    {
+                        dbname =  jdbcConnect.substr(n+1);
+                        jdbcConnect =  jdbcConnect.substr(0,n);
+                    }
+
+                    if ((n = jdbcConnect.find(":")) != string::npos)
+                    {
+                        ip =  jdbcConnect.substr(0,n);
+                        port =  jdbcConnect.substr(n+1);
+                    }
+                    else
+                    {
+                        ip = jdbcConnect;
+                    }
+
+                    sprintf(decry,"hostaddr=%s port=%s dbname='%s' user='%s' password='%s'",
+                     ip.c_str(),
+                     port.c_str(),
+                     dbname.c_str(),
+                     username.c_str(),
+                     password.c_str());
+
+                    pgConnect = decry;
+                }
+              
+
+                //postgresql://postgres:chinadci@172.26.99.156:5433/dmap_data1
+                if(pgConnect!="")
+                {
+                     UpdDatabasePool(dbType, guid, name,alias, pgConnect);
+                }
+
+           }
+        } 
+
+        for( map<string,bool>::iterator iter_list= list.begin();iter_list !=  list.end(); iter_list++)
+            {
+                bool b = iter_list->second;
+                if(b == false)
+                {
+                    printf("删除 数据库连接 undo\r\n");
+                }
+            }
+            return true;
+    }
+
+
+    bool DmpPgsqlSourcePools::InitDatabasePool()
+    {
+        printf("InitDatabasePool\r\n");
+        
+        char sqlBuff[500];
+        sprintf(sqlBuff, "SELECT guid, name, alias, sqlalchemy_uri,connectstr FROM %s.%s",DMAP_SCHEMA, DMAP_DMDMS_DATABASE);
+        
+        shared_ptr<DmpPgsql> pPgsqlConn = this->GetDefaultPgsqlConn();
+        if(pPgsqlConn == nullptr)
+        {
+            return false;
+        }
+        pPgsqlConn->ExecWaitBinary(sqlBuff);
+        while (pPgsqlConn->next())
+        {
+           string guid = pPgsqlConn->getString(0);
+           string name = pPgsqlConn->getString(1);
+           string alias = pPgsqlConn->getString(2);
+           string uri = pPgsqlConn->getString(3);
+           string connectstr = pPgsqlConn->getString(4);
+          /* if(guid == "74c73a18-00c9-11ec-aced-0242ac110002")
+           {
+               continue;
+           }*/
+
+           
+
+           string pgConnect= "";
+           if(connectstr != "")
+           {
+               char key[] = "Chinadci";
+               char decry[500] = { 0 };
+             //  shared_ptr<clsMalloc> b = DmapDll::StringHelp::base64_decode_rbyte(connectstr);
+             //  Decrypt((unsigned char*)b->mem, b->GetSize(), (unsigned char*)key, (unsigned char*)decry);
+               for(size_t i =0; i< strlen(decry) && i<500; i++)
+               {
+                   if(decry[i]== '\b')
+                   {
+                       decry[i]= '\0';
+                       break;
+                   }
+                      
+               }
+               string connectstrUrl = decry;
+               printf("%s  %s\r\n",guid.c_str(),connectstrUrl.c_str());
+               // if(guid == "53636306-407a-11ec-8237-0242ac110002")
+               //{
+                // connectstrUrl = "hostaddr=124.71.38.197 port=5432 dbname='dmap' user='root' password='DMap@123'";
+               //}
+               AddDatabasePool("postgresql", guid, name,alias, connectstrUrl);
+           }
+           else if(uri != "")
+           {
+               char key[] = "Chinadci";
+               char decry[500] = { 0 };
+             //   shared_ptr<clsMalloc> b = DmapDll::StringHelp::base64_decode_rbyte(uri);
+            //    Decrypt((unsigned char*)b->mem,b->GetSize(), (unsigned char*)key, (unsigned char*)decry);
+                for(int i = 0;decry[i] >0; i++)
+                {
+                    if(decry[i]=='\b')
+                    {
+                         decry[i] =0;
+                        break;
+                    }
+                   
+                }
+
+                string jdbcConnect = decry;
+
+                string dbType = "";
+
+                if(jdbcConnect != "")
+                {
+                    string username = "";
+                    string password = "";
+                    string ip = "";
+                    string port = "5432";
+                    string dbname = "";
+
+                    size_t n =0;
+                    if ((n = jdbcConnect.find("://")) != string::npos)
+                    {
+                        dbType =  jdbcConnect.substr(0,n);
+                        jdbcConnect =  jdbcConnect.substr(n+3);
+                    }
+                   
+                    if ((n = jdbcConnect.find(":")) != string::npos)
+                    {
+                        username =  jdbcConnect.substr(0,n);
+                        jdbcConnect =  jdbcConnect.substr(n+1);
+                    }
+
+                    if ((n = jdbcConnect.find_last_of("@")) != string::npos)
+                    {
+                        password =  jdbcConnect.substr(0,n);
+                        jdbcConnect =  jdbcConnect.substr(n+1);
+                    }
+
+                    if ((n = jdbcConnect.find("/")) != string::npos)
+                    {
+                        dbname =  jdbcConnect.substr(n+1);
+                        jdbcConnect =  jdbcConnect.substr(0,n);
+                    }
+
+                    if ((n = jdbcConnect.find(":")) != string::npos)
+                    {
+                        ip =  jdbcConnect.substr(0,n);
+                     //   ip = "124.71.38.197";
+                        port =  jdbcConnect.substr(n+1);
+                    }
+                    else
+                    {
+                        ip = jdbcConnect;
+                    }
+
+                    sprintf(decry,"hostaddr=%s port=%s dbname='%s' user='%s' password='%s'",
+                     ip.c_str(),
+                     port.c_str(),
+                     dbname.c_str(),
+                     username.c_str(),
+                     password.c_str());
+                   
+                    pgConnect = decry;
+                }
+              
+
+                //postgresql://postgres:chinadci@172.26.99.156:5433/dmap_data1
+                if(pgConnect!="")
+                {
+                     printf("%s  %s\r\n",guid.c_str(),pgConnect.c_str());
+                     AddDatabasePool(dbType, guid, name,alias, pgConnect);
+                }
+
+           } 
+        }
+        return true;
+
+    }
+
+    bool DmpPgsqlSourcePools::CreateDefaultDatabasePool(string dataType, string connStr)
+    {
+        shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool());
+        defaultPool_ = newPool;
+        bool result = defaultPool_->Connect(connStr.c_str());
+      
+        return true;
+    }
+
+    bool DmpPgsqlSourcePools::AddDatabasePool(string dataType,
+                                          string guid,
+                                          string databaseName,
+                                          string alias,
+                                          string connStr)
+    {
+       
+        shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool());
+       // newPool->guid() = guid;
+        //  newPool->m_name = databaseName;
+        //  newPool->m_alias = alias;
+        newPool->Connect(connStr.c_str());
+         //newPool->Connect("PostgreSQLConn=hostaddr=172.26.99.173 port=5433 dbname='postgres' user='postgres' password='chinadci'");
+         pgsqlPool_[guid] = newPool;
+        return true;
+    }
+
+     bool DmpPgsqlSourcePools::UpdDatabasePool(string dataType, string guid, string databaseName, string alias, string connStr)
+     {
+         if(pgsqlPool_.find(guid) == pgsqlPool_.end())
+         {
+            shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool());
+           // newPool->guid() = guid;
+           // newPool->m_name = databaseName;
+           // newPool->m_alias = alias;
+           // newPool->Connect(connStr.c_str());
+        // newPool->Connect("PostgreSQLConn=hostaddr=172.26.99.173 port=5433 dbname='postgres' user='postgres' password='chinadci'");
+           // pgsqlPool_[guid] = newPool;
+            return true;
+         }
+         return false;
+     }
+}
\ No newline at end of file

+/**************************************************************************
+* file:              dmppgsqlsourcepools.h
+
+* Author:            fanqingxiong
+* Date:              2021-11-19 15:40:28
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+
+#ifndef __dmppgsqlsourcepools_h__
+#define __dmppgsqlsourcepools_h__
+
+#include <map>
+#include "dmppgsqlpool.h"
+#include <mutex>
+#define DMAP_DMDMS_DATABASE "dmdms_database"
+#define DMAP_SCHEMA "public"
+#define MAXCOUNT 200000
+
+namespace mapserver
+{
+    class DmpPgsqlPool;
+    class DmpPgsqlSourcePools
+    {
+    public:
+
+        DmpPgsqlSourcePools();
+        ~DmpPgsqlSourcePools();
+        static DmpPgsqlSourcePools* get_instance();
+
+        //获取默认数据库连接
+        shared_ptr<DmpPgsql> GetDefaultPgsqlConn();
+
+        //获取数据库连接
+        shared_ptr<DmpPgsql> GetPgsqlConn(const string& name);
+
+       // shared_ptr<DmpPgsql> GetPgsqlConn(char* name);
+
+        string GetDbSourceID(string name);
+
+        bool InitDatabasePool();
+
+        bool UpdateDatabasePool();
+        //创建默认数据库连接池
+        bool CreateDefaultDatabasePool(string dataType, string connStr);
+        // 添加数据库连接池
+        bool AddDatabasePool(string dataType, string guid, string databaseName, string alias, string connStr);
+        // Update 数据库连接池
+        bool UpdDatabasePool(string dataType, string guid, string databaseName, string alias, string connStr);
+      private:
+        shared_ptr<DmpPgsqlPool> defaultPool_;
+        map<string, shared_ptr<DmpPgsqlPool>> pgsqlPool_;
+        bool updateLock_ = false;
+
+     private:
+       mutex mutex_;
+       static DmpPgsqlSourcePools* instance_ptr;
+    };
+}
+
+
+#endif //__dmppgsqlsourcepools_h__
+

+/**************************************************************************
+* file:              dmprasterbuffer.cpp
+
+* Author:            qingxiongf
+* Date:              2021-12-13 09:25:24
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmprasterbuffer.h"
\ No newline at end of file

+/**************************************************************************
+* file:              dmprasterbuffer.h
+
+* Author:            qingxiongf
+* Date:              2021-12-13 09:24:09
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmprasterbuffer_h__
+#define __dmprasterbuffer_h__
+
+#define MS_SUCCESS 1
+
+
+/* COLOR OBJECT */
+typedef struct {
+  int red;
+  int green;
+  int blue;
+  int alpha;
+} colorObj;
+
+enum MS_RASTER_BUFFER_TYPE { MS_BUFFER_NONE=2000, MS_BUFFER_BYTE_RGBA, MS_BUFFER_BYTE_PALETTE };
+
+typedef struct {
+  unsigned char *pixels;
+  unsigned int pixel_step, row_step;
+  unsigned char *a,*r,*g,*b;
+} rgbaArrayObj;
+
+typedef struct {
+  unsigned char b,g,r,a;
+} rgbaPixel;
+
+typedef struct {
+  unsigned char r,g,b;
+} rgbPixel;
+
+
+typedef struct {
+  unsigned char *pixels; /*stores the actual pixel indexes*/
+  rgbaPixel *palette; /*rgba palette entries*/
+  unsigned int num_entries; /*number of palette entries*/
+  unsigned int scaling_maxval;
+} paletteArrayObj;
+
+typedef struct {
+  int type;
+  unsigned int width,height;
+  union {
+    rgbaArrayObj rgba;
+    paletteArrayObj palette;
+  } data;
+} rasterBufferObj;
+
+
+
+/* NOTE: RB_SET_PIXEL() will premultiply by alpha, inputs should not be
+         premultiplied */
+
+#define RB_SET_PIXEL(rb,x,y,red,green,blue,alpha) \
+    {  \
+        int _rb_off = (x) * (rb)->data.rgba.pixel_step + (y) * (rb)->data.rgba.row_step;   \
+        if( !(rb)->data.rgba.a ) { \
+           (rb)->data.rgba.r[_rb_off] = red; \
+           (rb)->data.rgba.g[_rb_off] = green; \
+           (rb)->data.rgba.b[_rb_off] = blue; \
+        } else { \
+           double a = alpha/255.0; \
+           (rb)->data.rgba.r[_rb_off] = red * a; \
+           (rb)->data.rgba.g[_rb_off] = green * a; \
+           (rb)->data.rgba.b[_rb_off] = blue * a; \
+           (rb)->data.rgba.a[_rb_off] = alpha; \
+        } \
+    }
+
+/* This versions receives an input red/green/blue that is already
+   premultiplied with alpha */
+#define RB_SET_PIXEL_PM(rb,x,y,red,green,blue,alpha) \
+    {  \
+        int _rb_off = (x) * (rb)->data.rgba.pixel_step + (y) * (rb)->data.rgba.row_step;   \
+        (rb)->data.rgba.r[_rb_off] = red; \
+        (rb)->data.rgba.g[_rb_off] = green; \
+        (rb)->data.rgba.b[_rb_off] = blue; \
+        if( rb->data.rgba.a ) { \
+           (rb)->data.rgba.a[_rb_off] = alpha; \
+        } \
+    }
+
+/* NOTE: RB_MIX_PIXEL() will premultiply by alpha, inputs should not be
+         premultiplied */
+
+#define RB_MIX_PIXEL(rb,x,y,red,green,blue,alpha) \
+    {  \
+        int _rb_off = (x) * (rb)->data.rgba.pixel_step + (y) * (rb)->data.rgba.row_step;   \
+        \
+        msAlphaBlend(  red, green, blue, alpha, \
+                       (rb)->data.rgba.r + _rb_off, \
+                       (rb)->data.rgba.g + _rb_off, \
+                       (rb)->data.rgba.b + _rb_off, \
+                       ((rb)->data.rgba.a == NULL ) ? NULL : (rb)->data.rgba.a + _rb_off );  \
+    }
+
+
+
+struct imageCacheObj {
+  int symbol;
+  int size;
+  colorObj color;
+  colorObj outlinecolor;
+  colorObj backgroundcolor;
+  rasterBufferObj img;
+  struct imageCacheObj *next;
+};
+
+#endif // __dmprasterbuffer_h__

@@ -17,7 +17,8 @@
 #include "dmpserverresponse.h"
 #include "dmpwms.h"
 #include "dmplogger.h"
-
+#include "dmpwmsgetcapabilities.h"
+#include "dmpwmsgetmap.h"
 using namespace std;
 
 namespace DmpWms
@@ -34,6 +35,33 @@ namespace DmpWms
 
   void DmpWMSService::executeRequest(const DmpServerContext &context) 
   {
+      const DmpWmsParameters params(context.request()->ServerParameters());
+      const DmpProject* project = context.project();
+      const std::string request = params.Request();
+      if (request.empty())
+      {
+         context.response()->writeHtml("wms,Operation is null");
+      }
+      else if(boost::iequals(request, "getcapabilities"))
+      {
+         writeGetCapabilities(context,params, project);
+      }
+      else if(boost::iequals(request, "getmap"))
+      {
+          writeGetMap(context,params, project);
+      } 
+      else if(boost::iequals(request,"thumbnail"))
+      {
+          writeThumbnail(context,params, project);
+      }
+      else if(boost::iequals(request, "getfeatureinfo")) 
+      {
+          
+      } 
+      else if(request == "getlegendgraphic")
+      {
+          
+      }
   }
 } 
 

@@ -11,6 +11,7 @@
 #define __dmpwms_h__
 #include <string>
 #include "dmpservice.h"
+#include "dmpwmsparameters.h"
 
 namespace DmpWms
 {

+/**************************************************************************
+* file:              dmpwmsgetcapabilities.cpp
+
+* Author:            qingxiongf
+* Date:              2021-12-07 09:00:53
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpwmsgetcapabilities.h"
+#include "dmpserverresponse.h"
+#include "dmpserverrequest.h"
+
+namespace DmpWms
+{
+  void writeGetCapabilities( const DmpServerContext &context, const DmpWmsParameters& params, 
+                             const  DmpProject* project,  bool projectSettings)
+  {
+    std::string version = params.Version();
+    std::string hrefUrl;
+    char char_hrefUrl[1024] = {0}; 
+	  std::string domain = context.request()->domain();
+    std::string port = context.request()->port();
+    if(port == "80" || port =="")
+    {
+      sprintf(char_hrefUrl, "http://%s%s", domain.c_str(), context.request()->path().c_str());
+    }
+    else
+    {
+      sprintf(char_hrefUrl, "http://%s:%s%s", domain.c_str(),port.c_str(), context.request()->path().c_str());
+    }
+    hrefUrl = char_hrefUrl;
+   // hrefUrl = "http://172.26.40.51:8821/?mapService=test";
+    std::shared_ptr<boost::property_tree::ptree> doc = getCapabilities(project, version,hrefUrl, projectSettings);
+
+    std::stringstream stream; 
+    write_xml(stream, *doc.get());
+    std::string xml;
+    xml = stream.str();
+
+   // DmpServerResponse* response = context.response();
+    context.response()->removeHeader("Content-Type");
+    context.response()->setHeader("Content-Type", "text/xml;charset=utf-8");
+    context.response()->write(xml);
+  }
+
+   std::shared_ptr<boost::property_tree::ptree>  getCapabilities( const DmpProject* project,
+                                const std::string &version, const std::string &hrefUrl,
+                                bool projectSettings )
+  {
+    std::shared_ptr<boost::property_tree::ptree> xmlRootDoc(new boost::property_tree::ptree());
+    boost::property_tree::ptree xmlRoot;
+    std::string rootname;
+
+    if ( version == "1.1.1" )
+    {
+      rootname = "WMT_MS_Capabilities";
+      xmlRoot.add("<xmlattr>.version", version);
+    }
+    else // 1.3.0 as default
+    {
+      rootname = "WMS_Capabilities";
+     // xmlRoot.add("<xmlattr>.xmlns:xsi","http://www.w3.org/2001/XMLSchema-instance");
+     // xmlRoot.add("<xmlattr>.xmlns","http://www.opengis.net/wms");
+     // xmlRoot.add("<xmlattr>.xmlns:sld","http://www.opengis.net/sld");
+     // xmlRoot.add("<xmlattr>.xsi:schemaLocation","http://www.opengis.net/wms http://schemas.opengis.net/wms/1.3.0/capabilities_1_3_0.xsd  http://www.opengis.net/sld http://schemas.opengis.net/sld/1.1.0/sld_capabilities.xsd");
+      xmlRoot.add("<xmlattr>.version", version);
+    }
+    
+    boost::property_tree::ptree ptService;
+    ptService.add("Name",  project->name());
+    ptService.add("Title", project->title()==""?  project->name():  project->title());
+    ptService.add("Abstract", "dmap wms service");
+    ptService.add("Keywords", "WMS,DMAP," + project->name());
+    ptService.add("OnlineResource", hrefUrl);
+    ptService.add("Fees","none");
+    ptService.add("AccessConstraints","none");
+    xmlRoot.add_child("Service",ptService);
+ 
+    boost::property_tree::ptree ptCapability;
+
+    addCapabilitiesRequest(ptCapability,hrefUrl);
+    boost::property_tree::ptree format;
+    format.add("Format", "XML");
+    ptCapability.add_child("Exception",format);
+    addCapabilitiesLayers(ptCapability,project);
+
+    xmlRoot.add_child("Capability",ptCapability);
+    xmlRootDoc->add_child(rootname,xmlRoot);
+    return xmlRootDoc;
+
+  }
+
+
+  void addCapabilitiesRequestNode(boost::property_tree::ptree &pt, const std::string &hrefUrl, const char* request,const std::vector<const char*>& formatList)
+  {
+    boost::property_tree::ptree pt_request;
+    boost::property_tree::ptree pt_dcpType;
+    boost::property_tree::ptree pt_http;
+    boost::property_tree::ptree pt_method;
+    boost::property_tree::ptree pt_onlineRes;
+
+    for(int i =0; i< formatList.size(); i++)
+    {
+      const char* format = formatList.at(i);
+      pt_request.add("Format",format);
+    }
+  
+    pt_onlineRes.add("<xmlattr>.xmlns:xlink","http://www.w3.org/1999/xlink");
+    pt_onlineRes.add("<xmlattr>.xmlns:type","simple");
+    pt_onlineRes.add("<xmlattr>.xmlns:href",hrefUrl);
+
+    pt_method.add_child("OnlineResource",pt_onlineRes);
+    pt_http.add_child("Get",pt_method);
+    pt_dcpType.add_child("HTTP",pt_http);
+    pt_request.add_child("DCPType",pt_dcpType);
+    pt.add_child(request,pt_request);
+
+  }
+
+
+  void addCapabilitiesRequest(boost::property_tree::ptree &pt, const std::string &hrefUrl)
+  {
+    boost::property_tree::ptree pt_request;
+    std::vector<const char*> formatList;
+
+    formatList.push_back("text/xml");
+    addCapabilitiesRequestNode(pt_request,hrefUrl,"GetCapabilities",formatList);
+
+    formatList.clear();
+    formatList.push_back("png");
+    formatList.push_back("jpeg");
+    formatList.push_back("image/jpeg");
+    formatList.push_back("image/png");
+    addCapabilitiesRequestNode(pt_request,hrefUrl,"GetMap",formatList);
+
+    formatList.clear();
+    formatList.push_back("text/json");
+    formatList.push_back("text/xml");
+    addCapabilitiesRequestNode(pt_request,hrefUrl,"GetFeatureInfo",formatList);
+    
+    pt.add_child("Request", pt_request);
+    return;
+  }
+
+  void addCapabilitiesLayers(boost::property_tree::ptree &pt,const DmpProject* project)
+  {
+    std::string srs = "EPSG:" + std::__cxx11::to_string(project->crs().srid());
+
+    boost::property_tree::ptree ptProject;
+   // ptProject.add("<xmlattr>.queryable","1");
+    ptProject.add("Name", project->name());
+    ptProject.add("Title",  project->title()==""? project->name(): project->title());
+    ptProject.add("CRS", srs);
+
+
+    double minx,miny,maxx,maxy;
+    int i =0;
+    std::map<std::string, DmpMapLayer*> mapLayers = project->mapLayers();
+    for (std::map<std::string, DmpMapLayer*>::iterator iter = mapLayers.begin();iter != mapLayers.end(); iter++)
+    {
+      DmpMapLayer* layer = iter->second;
+       if(i ==0)
+       {
+          minx = layer->extent().xmin();
+          miny = layer->extent().ymin();
+          maxx = layer->extent().xmax();
+          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();
+       }
+       i++;
+    }
+
+    boost::property_tree::ptree ptGeographicBoundingbox; 
+    ptGeographicBoundingbox.add("westBoundLongitude", minx);
+    ptGeographicBoundingbox.add("eastBoundLongitude", maxx);
+    ptGeographicBoundingbox.add("southBoundLatitude", miny);
+    ptGeographicBoundingbox.add("northBoundLatitude", maxy);
+    ptProject.add_child("EX_GeographicBoundingBox",ptGeographicBoundingbox);
+
+    boost::property_tree::ptree ptBoundingbox;
+    ptBoundingbox.add("<xmlattr>.CRS", srs);
+    if (boost::iequals(srs, "CRS:84")|| boost::iequals(srs, "EPSG:4326"))
+    {
+      ptBoundingbox.add("<xmlattr>.miny", minx);
+      ptBoundingbox.add("<xmlattr>.maxy", maxx);
+      ptBoundingbox.add("<xmlattr>.minx", miny);
+      ptBoundingbox.add("<xmlattr>.maxx", maxy);
+    }
+    else
+    {
+      ptBoundingbox.add("<xmlattr>.minx", minx);
+      ptBoundingbox.add("<xmlattr>.maxx", maxx);
+      ptBoundingbox.add("<xmlattr>.miny", miny);
+      ptBoundingbox.add("<xmlattr>.maxy", maxy);
+    }
+    ptProject.add_child("BoundingBox",ptBoundingbox);
+
+    for (std::map<std::string, DmpMapLayer*>::iterator iter= mapLayers.begin();iter != mapLayers.end(); iter++)
+    {
+      DmpMapLayer* layer = iter->second;
+      addCapabilitiesLayer(ptProject, layer,srs);
+    }
+    pt.add_child("Layer", ptProject);
+  }
+
+  void addCapabilitiesLayer(boost::property_tree::ptree &pt, DmpMapLayer* layer, const std::string& srs)
+  {
+    boost::property_tree::ptree ptLayer;
+    ptLayer.add("<xmlattr>.queryable","1");
+    ptLayer.add("Name", layer->name());
+    ptLayer.add("Title", layer->title());
+    ptLayer.add("CRS", srs);
+
+    boost::property_tree::ptree ptGeographicBoundingbox; 
+    ptGeographicBoundingbox.add("westBoundLongitude", layer->extent().xmin());
+    ptGeographicBoundingbox.add("eastBoundLongitude", layer->extent().xmax());
+    ptGeographicBoundingbox.add("southBoundLatitude", layer->extent().ymin());
+    ptGeographicBoundingbox.add("northBoundLatitude", layer->extent().ymax());
+    ptLayer.add_child("EX_GeographicBoundingBox",ptGeographicBoundingbox);
+
+    boost::property_tree::ptree ptBoundingbox;
+    ptBoundingbox.add("<xmlattr>.CRS", srs);
+   if (boost::iequals(srs, "CRS:84")|| boost::iequals(srs, "EPSG:4326"))
+   {
+      ptBoundingbox.add("<xmlattr>.miny",  layer->extent().xmin());
+      ptBoundingbox.add("<xmlattr>.maxy",  layer->extent().xmax());
+      ptBoundingbox.add("<xmlattr>.minx",  layer->extent().ymin());
+      ptBoundingbox.add("<xmlattr>.maxx",  layer->extent().ymax());
+   }
+   else
+   {
+      ptBoundingbox.add("<xmlattr>.minx",  layer->extent().xmin());
+      ptBoundingbox.add("<xmlattr>.maxx",  layer->extent().xmax());
+      ptBoundingbox.add("<xmlattr>.miny",  layer->extent().ymin());
+      ptBoundingbox.add("<xmlattr>.maxy",  layer->extent().ymax());
+   }
+    
+    
+    ptLayer.add_child("BoundingBox",ptBoundingbox);
+ 
+    pt.add_child("Layer", ptLayer);
+  }
+
+  void coordInvert(double& x1,double& y1,double& x2, double& y2)
+  {
+      double temp1 = x1; x1 = y1; y1 = temp1;
+      double temp2 = x2; x2 = y2; y2=  temp2;
+  }
+
+
+} // namespace QgsWms

+/**************************************************************************
+* file:              dmpwmsgetcapabilities.h
+
+* Author:            fanqingxiong
+* Date:              2021-11-19 15:40:28
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef  __dmpwmsgetcapabilities_h__
+#define  __dmpwmsgetcapabilities_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
+{
+
+  /**
+   * Output GetCapabilities response
+   */
+  void writeGetCapabilities( const DmpServerContext &context,const DmpWmsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings = false);
+
+  /**
+   * Creates the WMS GetCapabilities XML document.
+   * \param serverIface Interface for plugins
+   * \param project Project
+   * \param version WMS version
+   * \param request WMS request
+   * \param projectSettings If TRUE, adds extended project information (does not validate against WMS schema)
+   * \returns GetCapabilities XML document
+   */
+    std::shared_ptr<boost::property_tree::ptree>  getCapabilities( const DmpProject* project,
+                                const std::string &version, const std::string &hrefUrl,
+                                bool projectSettings );
+
+    void addCapabilitiesRequest(boost::property_tree::ptree &pt, const std::string &hrefUrl);
+
+    void addCapabilitiesRequestNode(boost::property_tree::ptree &pt, const std::string &hrefUrl,
+          const char* request,const std::vector<const char*>& formatList);
+
+    void addCapabilitiesLayers(boost::property_tree::ptree &pt,const DmpProject* project);
+
+    void addCapabilitiesLayer(boost::property_tree::ptree &pt,DmpMapLayer* layer,const std::string& srs);
+
+    void coordInvert(double& x1,double& y1,double& x2, double& y2);
+} // namespace DmpWms
+
+#endif

+/**************************************************************************
+* file:              dmpwmsgetmap.cpp
+
+* Author:            qingxiongf
+* Date:              2021-12-11 11:53:36
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpwmsgetmap.h"
+#include "dmpwmsrenderer.h"
+#include "dmpserverresponse.h"
+#include "dmpserverrequest.h"
+#include <map>
+#include <memory>
+namespace DmpWms
+{
+
+    void writeGetMap(const DmpServerContext &context,const DmpWmsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings )
+    {
+		string exception = WmsGetMap(context,params, project,projectSettings);
+		if(exception.length() >0)
+		{
+			
+		}
+    }
+
+
+    std::string WmsGetMap(const DmpServerContext &context, const DmpWmsParameters& params, 
+                             const  DmpProject* project,  bool projectSettings)
+   {
+        try
+		{
+		
+			double boxX1, boxY1, boxX2, boxY2;
+            std::string srs = params.Srs();
+            std::string recbox = params.BBox();
+
+            int width = params.Width();
+            int height = params.Height();
+			std::string layerDefs = params.layerDefs();
+            std::string regionDefs = params.regionDefs();
+			std::map<std::string, std::string> mapLayerDefs;
+            std::map<std::string, std::string> mapRegionDefs;
+            StrDefs2Map(mapLayerDefs,layerDefs);
+            StrDefs2Map(mapRegionDefs,regionDefs);
+
+			if (boost::iequals(srs, "CRS:84")|| boost::iequals(srs, "EPSG:4326"))
+			{
+				sscanf(recbox.c_str(), "%lf,%lf,%lf,%lf", &boxY1, &boxX1, &boxY2, &boxX2); 
+			}
+			else
+			{
+				sscanf(recbox.c_str(), "%lf,%lf,%lf,%lf", &boxX1, &boxY1, &boxX2, &boxY2); 
+			}
+
+			
+			//stbstb:应该检查大量地方的 width和height不为零 ,char* regionDefs
+			if (width <= 0 || height <= 0) return  "width和height 参数错误";
+            if (width > 8000 || height > 6000) return  "参数错误,图片大小 宽不能大于8000像素 高大于6000像素";
+		
+			DmpWms::DmpWmsRenderer mapRenderer(height, width);
+
+            std::string layers = params.Layers();
+			if (layers !="")
+			{
+				mapRenderer.AddWmsMapLayers(project);
+			}
+			else
+			{
+				char strlayers[1000] = {0};
+				strcpy(strlayers,(char *)layers.c_str());
+				mapRenderer.AddWmsMapLayers(project, strlayers);
+			}
+			
+	
+			shared_ptr<Rect> rect (new Rect(boxY2, boxX2, boxY1, boxX1));
+			mapRenderer.SetExtent(rect);
+			mapRenderer.GetMap(&mapLayerDefs,&mapRegionDefs);
+			string responseData;
+			mapRenderer.ToStream(responseData);
+			context.response()->removeHeader("Content-Type");
+    		context.response()->setHeader("Content-Type", "image/png");
+			context.response()->write(responseData);
+			return "";
+		}
+		catch (const std::exception &e)
+		{
+			std::cerr << " GetMap " << e.what() << '\n';
+			return  e.what();
+		}
+   }
+
+    void writeThumbnail(const DmpServerContext &context,const DmpWmsParameters& params, 
+                     const  DmpProject* project,bool projectSettings = false)
+	{
+		 try
+		{
+		
+			double boxX1, boxY1, boxX2, boxY2;
+           // int width = params.Width();
+           // int height = params.Height();
+		   	DmpWms::DmpWmsRenderer mapRenderer(231,256);
+			double boxX1 =  rect_service->m_dLeft;
+			double boxY1 = rect_service->m_dBottom;
+			double boxX2 = rect_service->m_dRight;
+			double boxY2 = rect_service->m_dTop;
+
+			double dx = (boxX2 - boxX1) *0.1;
+			double dy = (boxY2 - boxY1) *0.1;
+	
+			shared_ptr<Rect> rect (new Rect(boxY2, boxX2, boxY1, boxX1));
+			mapRenderer.SetExtent(rect);
+			mapRenderer.GetMap(&mapLayerDefs,&mapRegionDefs);
+			string responseData;
+			mapRenderer.ToStream(responseData);
+			context.response()->removeHeader("Content-Type");
+    		context.response()->setHeader("Content-Type", "image/png");
+			context.response()->write(responseData);
+			return "";
+		}
+		catch (const std::exception &e)
+		{
+			std::cerr << " GetMap " << e.what() << '\n';
+			return  e.what();
+		}
+	}
+
+
+   
+	int StrDefs2Map(std::map<std::string,std::string>& mapDefs,std::string& strDefs)
+	{
+		char layerDefs[2000] = {0};
+		strcpy( layerDefs,(char*) strDefs.c_str());
+
+		if (layerDefs && strlen(layerDefs) > 0)
+		{
+			int i = 0;
+			int len = strlen(layerDefs);
+
+			for (; i < len; i++)
+			{
+				if (layerDefs[i] == '{')
+				{
+					break;
+				}
+			}
+
+			while (i<len && layerDefs[i] != '}')
+			{
+				while (i < len && layerDefs[i] != '}' && layerDefs[i] != ',')
+				{
+					std::string layername;
+					std::string expression;
+
+					char *p;
+					while (i < len && layerDefs[i] != '}' && layerDefs[i] != ',' &&  layerDefs[i] != '\"'){ i++; }
+					i++;
+					p = &layerDefs[i];
+					while (i < len && layerDefs[i] != '}' && layerDefs[i] != ',' &&  layerDefs[i] != '\"'){ i++; }
+					layerDefs[i] = 0;
+					layername = p;
+
+
+					while (i < len && layerDefs[i] != '}' && layerDefs[i] != ',' &&  layerDefs[i] != '\"'){ i++; }
+					i++;
+					p = &layerDefs[i];
+					char*p1 = &layerDefs[i - 2];
+					*p1 = '\"';
+					int leftKh =0;
+					//p1++;
+					while (i < len && layerDefs[i] != '}' && layerDefs[i] != ',' &&
+						layerDefs[i] != '\"' && (layerDefs[i] != ' ') && layerDefs[i] != '>' &&
+						layerDefs[i] != '<' &&  layerDefs[i] != '=' && layerDefs[i] != '!')
+					{
+						
+						layerDefs[i - 1] = layerDefs[i];
+						i++;
+					}
+					layerDefs[i - 1] = '\"';
+					while (i < len && layerDefs[i] != '}'  && (( layerDefs[i] != ','  &&  layerDefs[i] != '\"')|| leftKh> 0))
+					{
+						if(layerDefs[i] == '(')
+						{
+							leftKh ++;
+						}
+						if(layerDefs[i] == ')')
+						{
+							leftKh --;
+						}
+						 i++; 
+					}
+					layerDefs[i] = 0;
+					expression = p1;
+					i++;
+					mapDefs[layername] = expression;
+				}
+				if (layerDefs[i] == '}' || layerDefs[i] == ',')i++;
+				//i++;
+			}
+
+		}
+		return mapDefs.size();
+	}
+}
\ No newline at end of file

+/**************************************************************************
+* file:              dmpwmsgetmap.h
+
+* Author:            fanqingxiong
+* Date:              2021-11-19 15:40:28
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+
+#ifndef __dmpwmsgetmap_h__
+#define __dmpwmsgetmap_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 writeGetMap(const DmpServerContext &context,const DmpWmsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings = false );
+     std::string WmsGetMap(const DmpServerContext &context,const DmpWmsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings = false );
+
+     void writeThumbnail(const DmpServerContext &context,const DmpWmsParameters& params, 
+                     const  DmpProject* project,bool projectSettings = false);
+
+     int StrDefs2Map(std::map<std::string,std::string>& mapDefs,std::string& strDefs);
+
+}
+
+#endif //__dmpwmsgetmap_h__
+

+/**************************************************************************
+* file:              dmpwmsparameters.cpp
+
+* Author:            qingxiongf
+* Date:              2021-12-07 09:00:53
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include <iostream>
+#include "dmpwmsparameters.h"
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
+#include "dmplogger.h"
+#include "dmpserverutils.h"
+
+namespace DmpWms
+{
+    DmpWmsParameters::DmpWmsParameters()
+        : DmpServerParameters()
+    {
+    }
+
+    DmpWmsParameters::DmpWmsParameters(const DmpServerParameters &params)
+    {
+        params_ = params.Parameters();
+    }
+
+    bool DmpWmsParameters::GetStringParameter(const char* key, std::string &value) const
+    {
+        std::map<std::string, std::string>::const_iterator iter;
+        iter = params_.find(key);
+        if (iter != params_.end())
+        {
+            try
+            {
+                value = boost::lexical_cast<std::string>(iter->second);
+                return true;
+            }
+            catch (boost::bad_lexical_cast &e)
+            {
+               LOGGER_ERROR(e.what());
+            }
+        }
+        return false;
+    }
+
+    bool DmpWmsParameters::GetIntParameter(const char* key, int& value) const
+    {
+        std::map<std::string, std::string>::const_iterator iter;
+        iter = params_.find(key);
+        if (iter != params_.end())
+        {
+            try
+            {
+                value= boost::lexical_cast<int>(iter->second);
+                return true;
+            }
+            catch (boost::bad_lexical_cast &e)
+            {
+               LOGGER_ERROR(e.what());
+            }
+        }
+         return false;
+    }
+
+
+    std::string DmpWmsParameters::Service() const
+    {
+        std::string value = "WMS";
+        this->GetStringParameter("SERVICE", value);
+        return value;
+    }
+
+    //必须 值为GetMap GetCapabilities GetFeatureInfo GetFeatureInfo GetLegendGraphic
+    std::string DmpWmsParameters::Request() const
+    {
+        std::string value = "";
+        GetStringParameter("REQUEST",value);
+        return value;
+    }
+    
+    //必须  默认全部， 要在地图上显示的图层。值是以逗号分隔的图层名称列表。
+    std::string DmpWmsParameters::Layers() const
+    {
+        std::string value = "";
+        GetStringParameter("LAYERS",value);
+        return value;
+    }
+
+
+    //必须  服务版本， 值为 1.0.0, 1.1.0, 1.1.1, 1.3
+    std::string DmpWmsParameters::Version() const
+    {
+        std::string value = "";
+        GetStringParameter("VERSION",value);
+        return value;
+    }
+
+
+
+    //GetMap 必须 坐标系 地图输出的空间参考系统。值的格式为EPSG:4490. crs是WMS 1.3.0中使用的参数键
+    std::string DmpWmsParameters::Srs() const
+    {
+        std::string value = "";
+        if(GetStringParameter("SRS",value))
+        {
+            return value;
+        }
+
+        GetStringParameter("CRS",value);
+        return value;
+    }
+
+    std::string DmpWmsParameters::BBox() const
+    {
+        std::string value = "";
+        GetStringParameter("BBOX",value);
+        return value;
+    }
+
+    int DmpWmsParameters::Width() const
+    {
+        int value = 0;
+        GetIntParameter("WIDTH",value);
+        return value;
+    }
+
+    int DmpWmsParameters::Height() const
+    {
+        int value = 0;
+        GetIntParameter("HEIGHT",value);
+        return value;
+    }
+
+    bool DmpWmsParameters::Transparent() const
+    {
+        return true;
+    }
+
+    // Value is in the form RRGGBB. Default is FFFFFF (white).
+    std::string DmpWmsParameters::BgColor() const
+    {
+        return "";
+    }
+
+
+    //报告异常的格式。默认值为application/vnd.ogc.se_xml。
+    std::string DmpWmsParameters::Exceptions() const
+    {
+        return "application/vnd.ogc.se_xml";
+    } 
+
+    std::string DmpWmsParameters::sld_body() const
+    {
+        return "";
+    } 
+
+    std::string DmpWmsParameters::layerDefs() const
+    {
+        std::string value = "";
+        GetStringParameter("LAYERDDEFS",value);
+        return value;
+    }
+
+    std::string DmpWmsParameters::regionDefs() const
+    {
+        std::string value = "";
+        GetStringParameter("REGIONDEFS",value);
+        return value;
+    }
+
+
+
+    DmpWmsParameters::Format DmpWmsParameters::ResFormat() const
+    {
+        std::string frm;
+        std::map<std::string, std::string>::const_iterator iter;
+        iter = params_.find("format");
+        if (iter != params_.end())
+        {
+            frm = iter->second;
+            if (frm.empty()) {
+              return DmpWmsParameters::Format::NONE;
+            }
+            Format f = Format::PNG;
+            boost::to_lower(frm);
+            if (frm.compare("jpg") == 0 || frm.compare("jpeg") == 0 || frm.compare("image/jpeg") == 0 ) {
+              f = DmpWmsParameters::Format::JPG;
+            }
+            return f;
+        }
+        return DmpWmsParameters::Format::NONE;
+    }
+} // namespace DmpWms
\ No newline at end of file

+/**************************************************************************
+* file:              dmpwmsparameters.h
+
+* Author:            qingxiongf
+* Date:              2021-12-19 15:40:28
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpwmsparameters_h__
+#define __dmpwmsparameters_h__
+#include "dmpserverparameters.h"
+
+namespace DmpWms
+{
+    class DmpWmsParameters : public DmpServerParameters
+    {
+    public:
+        enum class Format
+        {
+            NONE,
+            JPG,
+            PNG,
+            TEXT,
+            XML,
+            HTML,
+            GML,
+            GeoJson
+        };
+        DmpWmsParameters(const DmpServerParameters &parameters);
+        DmpWmsParameters();
+        virtual ~DmpWmsParameters() = default;
+        std::string Service() const;  //必须 值为WMS
+        std::string Request() const;  //必须 值为GetMap GetCapabilities GetFeatureInfo GetFeatureInfo GetLegendGraphic
+
+        std::string Layers() const;  //必须  默认全部， 要在地图上显示的图层。值是以逗号分隔的图层名称列表。
+        std::string Version() const; //必须  服务版本， 值为 1.0.0, 1.1.0, 1.1.1, 1.3
+
+        //GetMap
+        std::string Srs() const; //必须 坐标系 地图输出的空间参考系统。值的格式为EPSG:4490. crs是WMS 1.3.0中使用的参数键
+        std::string BBox() const; //必须
+        int Width() const; //必须
+        int Height() const; //必须
+
+        bool Transparent() const; //地图背景是否应该是透明的。值是真是假。默认值为true
+       // bool Time() const;  
+        std::string BgColor() const;// Value is in the form RRGGBB. Default is FFFFFF (white).
+        std::string Exceptions() const; //报告异常的格式。默认值为application/vnd.ogc.se_xml。
+        std::string sld_body() const; //URL编码的StyledLayerDescriptor XML文档，用于控制或增强地图图层和样式
+
+        std::string layerDefs() const;
+        std::string regionDefs() const;
+        
+        // GetFeatureInfo
+        std::string QueryLayers() const; //查询图层
+        std::string FeatureCount() const; //查询记录数量
+        int X() const; //地图上查询点的X坐标，以像素为单位。0是左侧。i是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
+    private:
+        bool GetStringParameter(const char* key, std::string &value) const;
+        bool GetIntParameter(const char* key, int& value) const;
+      
+
+
+    };
+} // namespace DmpWmts
+#endif //__dmpwmsparameters_h__

+/**************************************************************************
+* file:              dmpwmsrenderer.cpp
+
+* Author:            qingxiongf
+* Date:              2021-12-12 21:55:38
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpwmsrenderer.h"
+#include <sstream>
+#include <stdarg.h>
+#include <set>
+#include <png.h>
+#include <math.h>
+namespace DmpWms
+{
+	static cairo_status_t cairo_write_func(void *pbuff, const unsigned char *data, unsigned int length)
+	{
+		std::string* responseData  = (std::string*)pbuff;
+		responseData->append((char*)data,length);
+		return CAIRO_STATUS_SUCCESS;
+	}
+
+	static void png_write_data_to_buffer(png_structp png_ptr, png_bytep data, png_size_t length)
+	{
+		
+  		std::string* responseData =  (std::string*)png_get_io_ptr(png_ptr);
+		responseData->append((char*)data,length);
+	}
+
+	static void png_flush_data(png_structp png_ptr)
+    {
+
+    }
+
+    DmpWmsRenderer::DmpWmsRenderer(double height, double width)
+    {
+        rasterBufferObj* rb = (rasterBufferObj*)malloc(sizeof(rasterBufferObj));
+		initializeRasterBufferCairo(rb, width, height);
+
+		pRasterBufferObj = rb;
+
+		oneInchInLayoutUnits = 0.0254;
+
+		m_dHeight = height;
+		m_dWidth = width;
+		m_vLayers = {};
+		m_WMSServers = {};
+		m_iN = 1;
+		m_iBackColor = 0xffffffff;																				   //背景默认白色
+		cairo_surface_t *surface = cairo_image_surface_create_for_data(rb->data.rgba.pixels,  
+		CAIRO_FORMAT_ARGB32, (int)m_dWidth, (int)m_dHeight,rb->data.rgba.row_step); //cairo_win32_surface_create(hdc);
+		m_pClsSurfDC = new clsCrSurf(surface);
+		cairo_surface_t *surfaceBuffer = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, (int)m_dWidth, (int)m_dHeight);
+		m_pClsSurfBuff = new clsCrSurf(surfaceBuffer);
+		cairo_surface_t *maxSurfaceBuffer = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, (int)m_dWidth, (int)m_dHeight);
+		m_pClsMaxSurfBuffer = new clsCrSurf(maxSurfaceBuffer);
+
+		m_pExtent = shared_ptr<Rect>(new Rect(0, 0, 0, 0));
+    }
+
+    int DmpWmsRenderer::initializeRasterBufferCairo(rasterBufferObj *rb, int width, int height)
+    {
+        rb->type = MS_BUFFER_BYTE_RGBA;
+        rb->width = width;
+        rb->height = height;
+        rb->data.rgba.pixel_step = 4;
+        rb->data.rgba.row_step = width * 4;
+        rb->data.rgba.pixels = (unsigned char*)calloc(width*height*4,sizeof(unsigned char));
+        rb->data.rgba.r = &(rb->data.rgba.pixels[2]);
+        rb->data.rgba.g = &(rb->data.rgba.pixels[1]);
+        rb->data.rgba.b = &(rb->data.rgba.pixels[0]);
+        rb->data.rgba.a = &(rb->data.rgba.pixels[3]);
+        return MS_SUCCESS;
+    }
+
+	DmpWmsRenderer::~DmpWmsRenderer()
+	{
+		m_vLayers.clear();
+		if(this->pRasterBufferObj)
+		{
+			cairo_surface_finish(m_pClsSurfDC->m_pSurf);
+			if( this->pRasterBufferObj->data.rgba.pixels)
+			{
+				free(this->pRasterBufferObj->data.rgba.pixels);
+				this->pRasterBufferObj->data.rgba.pixels  = nullptr;
+			}
+			free(this->pRasterBufferObj);
+			this->pRasterBufferObj = nullptr;
+		}
+
+		if (m_pClsMaxSurfBuffer)
+		{
+			delete m_pClsMaxSurfBuffer;
+			m_pClsMaxSurfBuffer = nullptr;
+		}
+		if (m_pClsSurfDC)
+		{
+			delete m_pClsSurfDC;
+			m_pClsSurfDC = nullptr;
+		}
+
+		if (m_pClsSurfBuff)
+		{
+			delete m_pClsSurfBuff;
+			m_pClsSurfBuff = nullptr;
+		}
+	}
+
+    std::string DmpWmsRenderer::format(const char *fmt, ...)
+	{
+		va_list argptr;
+		int cnt;
+		char buffer[10000];
+		va_start(argptr, fmt);
+
+		cnt = vsnprintf(buffer, 2000, fmt, argptr);
+
+		va_end(argptr);
+
+		return buffer;
+	}
+
+
+    
+	string DmpWmsRenderer::GetDrawSQL(DmpVectorLayer* layer, Rect *pRect, const char *layerdef)
+	{
+		if (layer == 0 || layer->geom().size() == 0)
+			return "";
+
+		//char sql[6000];
+		string ss = "SELECT \"%s\" "; //这个 %s 是表示　shape 字段
+
+		shared_ptr<Renderer>  renderer = layer->GetRenderer30();
+
+		//	int renType = renderer->RendererType();
+		vector<string> vFieldName;
+		renderer->TryAddField(vFieldName);
+
+		int length = (int)(vFieldName.size());
+		for (int i = 0; i < length; i++)
+		{
+			string filename = vFieldName[i];
+			ss += ",\"" + (filename) + "\"::varchar ";
+		}
+
+		string tableName = layer->name(); //layer->name();
+		string shapeName = layer->geom();
+		shared_ptr<DmpVectorThinLayer> pVectorThinLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
+
+		if (pVectorThinLayer != nullptr)
+		{
+			tableName = pVectorThinLayer->tableName();
+		}
+
+		ss += " FROM \"%s\".\"%s\" "; // 这个 %s 是tableName
+		ss += " WHERE \"%s\" && \'BOX3D(%lf %lf,%lf %lf)\'::box3d";
+		if (layer->wherestr().length() > 0)
+		{
+			ss += " and  ";
+			ss += layer->wherestr();
+		}
+
+		if (layerdef != nullptr && strcmp(layerdef, "") != 0)
+		{
+			ss += " and  ";
+			ss += layerdef;
+		}
+   		ss +=  format(" limit %d ",MAXCOUNT);
+		//ss += " limit 40000 ";
+
+		double t = pRect->m_dTop, r = pRect->m_dRight, b = pRect->m_dBottom, l = pRect->m_dLeft;
+		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());
+		return sql;
+	}
+
+
+	
+	string DmpWmsRenderer::GetRegionQuerySQL(DmpVectorLayer* layer,Rect *pRect,string srid, const char *regionDef,const char *layerdef)
+	{
+		if (layer == 0 || layer->geom().size() == 0)
+			return "";
+		string sql = "";
+		shared_ptr<DmpPgsql> pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
+		if (pPgsqlConn != nullptr)
+		{
+			double t = pRect->m_dTop, r = pRect->m_dRight, b = pRect->m_dBottom, l = pRect->m_dLeft;
+		  // if(pPgsqlConn->ExecWait(sql.c_str()) && pPgsqlConn->next())
+		   {
+			  		// const char * polygon = pPgsqlConn->getString(0);
+					string ss = "SELECT \"%s\" "; //这个 %s 是表示　shape 字段
+
+					shared_ptr<Renderer>  renderer = layer->GetRenderer30();
+
+					//	int renType = renderer->RendererType();
+					vector<string> vFieldName;
+					renderer->TryAddField(vFieldName);
+
+					int length = (int)(vFieldName.size());
+					for (int i = 0; i < length; i++)
+					{
+						string filename = vFieldName[i];
+						ss += ",\"" + (filename) + "\"::varchar ";
+					}
+
+					string tableName = layer->name(); //layer->name();
+					string shapeName = layer->geom();
+					shared_ptr<DmpVectorThinLayer> pVectorThinLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
+
+					if (pVectorThinLayer != nullptr)
+					{
+						tableName = pVectorThinLayer->tableName();
+					}
+
+					ss += " FROM \"%s\".\"%s\"  "; // 这个 %s 是tableName
+					ss += " WHERE  ST_Intersects( (select (ST_Intersection(ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),'%s'::Geometry)) ),\"%s\" )";
+					if (layer->wherestr().length() > 0)
+					{
+						ss += " and  ";
+						ss += layer->wherestr();
+					}
+
+				if (layerdef != nullptr && strcmp(layerdef, "") != 0)
+				{
+					ss += " and  ";
+					ss += layerdef;
+				}
+				ss +=  format(" limit %d ",MAXCOUNT);
+			//	ss += " limit 40000 ";
+				//size_t size = strlen(regionDef);
+				std::string sql1 = format(ss.c_str(), shapeName.c_str(), layer->schema().c_str(),
+				 tableName.c_str(),l,t,  r,t, r, b,  l, b  ,l, t,srid.c_str(), regionDef,shapeName.c_str() );
+
+				 //	printf("%s\r\n",sql1.c_str());
+
+               return sql1;
+		  }
+		 //  else
+		   {
+			   return "";
+		   }
+
+						   
+		}
+		return "";
+	}
+
+	
+	
+	string DmpWmsRenderer::GetRegionQuerySQL(DmpVectorLayer* layer,Rect *pRect,string srid, const string &regionLayerName,const string &regionDef,const char *layerdef)
+	{
+		if (layer == 0 || layer->geom().size() == 0)
+			return "";
+		string sql = "";
+		//shared_ptr<DmpPgsql> pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetDefaultWorkspace();
+		//if (pPgsqlConn != nullptr)
+		{
+			double t = pRect->m_dTop, r = pRect->m_dRight, b = pRect->m_dBottom, l = pRect->m_dLeft;
+			size_t pos = regionDef.find("not in");
+			if(pos == string::npos)
+			{
+				sql =  format( "select ST_Intersection( \
+ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
+(select st_union(geom) from  \"%s\" where %s))",
+    l,t,  r,t, r, b,  l, b  ,l, t, srid.c_str(),regionLayerName.c_str(),regionDef.c_str());
+			}
+			else
+			{
+				string field = regionDef.substr(0, pos);
+				string exp = regionDef.substr(pos+6);
+				sql =  format( "select (ST_Difference( \
+ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
+(select st_union(geom) from  \"%s\" where %s in %s)))",
+    l,t,  r,t, r, b,  l, b  ,l, t, srid.c_str(), regionLayerName.c_str(),field.c_str(),exp.c_str());
+
+				//regionDef = StringHelp::
+			}
+
+            
+
+
+		 // if(pPgsqlConn->ExecWait(sql.c_str()) && pPgsqlConn->next())
+		   {
+			  		// const char * polygon = pPgsqlConn->getString(0);
+					string ss = "SELECT \"%s\" "; //这个 %s 是表示　shape 字段
+
+					shared_ptr<Renderer>  renderer = layer->GetRenderer30();
+
+					//	int renType = renderer->RendererType();
+					vector<string> vFieldName;
+					renderer->TryAddField(vFieldName);
+
+					int length = (int)(vFieldName.size());
+					for (int i = 0; i < length; i++)
+					{
+						string filename = vFieldName[i];
+						ss += ",\"" + (filename) + "\"::varchar ";
+					}
+
+					string tableName = layer->name(); //layer->name();
+					string shapeName = layer->geom();
+					shared_ptr<DmpVectorThinLayer> pVectorThinLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
+
+					if (pVectorThinLayer != nullptr)
+					{
+						tableName = pVectorThinLayer->tableName();
+					}
+
+					ss += " FROM \"%s\".\"%s\"  "; // 这个 %s 是tableName
+					ss += " WHERE  \"%s\" && \'BOX3D(%lf %lf,%lf %lf)\'::box3d and  ST_Intersects( (%s),\"%s\" )"; //'%s'::Geometry
+					if (layer->wherestr().length() > 0)
+					{
+						ss += " and  ";
+						ss += layer->wherestr();
+					}
+
+				if (layerdef != nullptr && strcmp(layerdef, "") != 0)
+				{
+					ss += " and  ";
+					ss += layerdef;
+				}
+
+				ss +=  format(" limit %d ",MAXCOUNT);
+
+				std::string sql1 = format(ss.c_str(), shapeName.c_str(), layer->schema().c_str(),
+				tableName.c_str(), shapeName.c_str(), l, b, r, t,  sql.c_str(),shapeName.c_str() );
+
+				//printf("%s\r\n",sql1.c_str());
+
+               return sql1;
+		   }
+		   //else
+		   {
+			   return "";
+		   }
+
+						   
+		}
+		 return "";
+	}
+	
+
+	string DmpWmsRenderer::GetDrawSQLAll_Catch(DmpVectorLayer* layer, shared_ptr<DmpVectorThinLayer> pVectorThinLayer)
+	{
+		if (layer == 0 || layer->geom().size() == 0)
+			return "";
+
+		//char sql[6000];
+		string ss = "SELECT \"%s\" "; //这个 %s 是表示　shape 字段
+
+		shared_ptr<Renderer>  renderer = layer->GetRenderer30();
+
+		//	int renType = renderer->RendererType();
+		vector<string> vFieldName;
+		renderer->TryAddField(vFieldName);
+
+		int length = (int)(vFieldName.size());
+		for (int i = 0; i < length; i++)
+		{
+			string filename = vFieldName[i];
+			//StringHelp::ToLower(filename); layer->GetFieldName
+			ss += ",\"" + (filename) + "\"::varchar ";
+		}
+
+		ss += " FROM \"%s\".\"%s\" "; // 这个 %s 是tableName
+
+		if (layer->wherestr().length() > 0)
+		{
+			ss += " where  ";
+			ss += layer->wherestr();
+		}
+
+		string tableName = layer->name();
+		if (pVectorThinLayer != nullptr)
+		{
+			tableName = pVectorThinLayer->tableName();
+		}
+
+		string shapeName = layer->geom();
+		std::string sql = format(ss.c_str(), shapeName.c_str(), layer->schema().c_str(), tableName.c_str(), shapeName.c_str());
+
+		return sql;
+	}
+
+	string DmpWmsRenderer::GetDrawSQLAll(DmpVectorLayer* layer)
+	{
+		if (layer == 0  || layer->geom().size() == 0)
+			return "";
+
+		//char sql[6000];
+		string ss = "SELECT \"%s\" "; //这个 %s 是表示　shape 字段
+
+		shared_ptr<Renderer>  renderer = layer->GetRenderer30();
+
+		//	int renType = renderer->RendererType();
+		vector<string> vFieldName;
+		renderer->TryAddField(vFieldName);
+
+		int length = (int)(vFieldName.size());
+		for (int i = 0; i < length; i++)
+		{
+			string filename = vFieldName[i];
+			//StringHelp::ToLower(filename); layer->GetFieldName
+			ss += ",\"" + (filename) + "\"::varchar ";
+		}
+
+		ss += " FROM \"%s\".\"%s\" "; // 这个 %s 是tableName
+
+		if (layer->wherestr().length() > 0)
+		{
+			ss += " where  ";
+			ss += layer->wherestr();
+		}
+
+		string tableName = layer->name();
+		string shapeName = layer->geom();
+
+		std::string sql = format(ss.c_str(), shapeName.c_str(), layer->schema().c_str(), tableName.c_str(), shapeName.c_str());
+
+		return sql;
+	}
+
+	string DmpWmsRenderer::GetDrawSQLAllOrderby(DmpVectorLayer* layer)
+	{
+		if (layer == 0  || layer->geom().size() == 0)
+			return "";
+
+		//char sql[6000];
+		string ss = "SELECT \"%s\" "; //这个 %s 是表示　shape 字段
+
+		shared_ptr<Renderer>  renderer = layer->GetRenderer30();
+
+		//	int renType = renderer->RendererType();
+		vector<string> vFieldName;
+		renderer->TryAddField(vFieldName);
+
+		int length = (int)(vFieldName.size());
+		for (int i = 0; i < length; i++)
+		{
+			string filename = vFieldName[i];
+			//StringHelp::ToLower(filename);layer->GetFieldName
+			ss += ",\"" + (filename) + "\"::varchar ";
+		}
+
+		ss += " FROM \"%s\".\"%s\" "; // 这个 %s 是tableName
+
+		if (layer->wherestr().length() > 0)
+		{
+			ss += " where  ";
+			ss += layer->wherestr();
+		}
+
+        ss +=  format(" limit %d ",MAXCOUNT);
+
+		string tableName = layer->name();
+		string shapeName = layer->geom();
+
+		std::string sql = format(ss.c_str(), shapeName.c_str(), layer->schema().c_str(), tableName.c_str(), shapeName.c_str());
+		//StringHelp::ToLower(sql);
+		return sql;
+	}
+
+	string DmpWmsRenderer::GetCountSQL(DmpVectorLayer* layer)
+	{
+		if (layer == 0  || layer->geom().size() == 0)
+			return "";
+
+		//char sql[6000];
+		string ss = "SELECT count(*) "; //这个 %s 是表示　shape 字段
+		ss += " FROM \"%s\".\"%s\" ";	// 这个 %s 是tableName
+
+		if (layer->wherestr().length() > 0)
+		{
+			ss += " where  ";
+			ss += layer->wherestr();
+		}
+
+		string tableName = layer->name();
+		string shapeName = layer->geom();
+
+		if (layer->thinLayers().size() > 0)
+		{
+			tableName = layer->thinLayers()[0]->tableName();
+		}
+
+		std::string sql = format(ss.c_str(), layer->schema().c_str(), tableName.c_str());
+		return sql;
+	}
+
+	string DmpWmsRenderer::GetFeatureInfoSQL(DmpVectorLayer* layer, double x, double y, double dis,int feature_count)
+	{
+		if (layer == 0 || layer->geom().size() == 0)
+			return "";
+
+		
+
+		string ss = "SELECT  "; //这个 %s 是表示　shape 字段
+
+		string fields_str = "";
+
+		shared_ptr<DmpPgsql> pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
+		if (pPgsqlConn != nullptr)
+		{
+
+			char tablesql_buff[300];
+			sprintf(tablesql_buff, "select column_name,data_type from information_schema.columns where table_schema = '%s' and table_name = '%s'",
+					layer->schema().c_str(),
+					layer->name().c_str());
+
+			int returnResult = pPgsqlConn->ExecWait(tablesql_buff);
+			if (!returnResult)
+			{
+				string fields_str = " * ";
+			}
+			else
+			{
+			    
+				for (int i = 0; pPgsqlConn->next(); i++)
+				{
+					if (i > 0 && fields_str.length() >0 && fields_str[fields_str.length() -1]!=',')
+					{
+						fields_str += ",";
+					}
+					string fieldname = pPgsqlConn->getString(0);
+					string typeString = pPgsqlConn->getString(1);
+					int typeInt = PGFieldType::VarCharFieldType;
+					if (layer->geom() == fieldname || typeString == "geometry")
+					{
+						typeString = "geometry";
+						typeInt = PGFieldType::ShapeFieldType;
+						fields_str += " st_asgeojson(\"" + (fieldname) + "\") as geometry_as_geojson";
+					}
+					else if (typeString == "integer")
+					{
+						typeInt = PGFieldType::BigIntFieldType;
+						fields_str += " \"" + (fieldname) + "\" ";
+					}
+					else if (typeString == "bigint")
+					{
+						typeInt = PGFieldType::BigIntFieldType;
+						fields_str += " \"" + (fieldname) + "\"::varchar ";
+					}
+					else if (typeString == "double precision" || typeString == "real" || typeString == "numeric")
+					{
+						typeInt = PGFieldType::DoubleFieldType;
+						fields_str += " \"" + (fieldname) + "\" ";
+					}
+					else if (typeString == "character varying" || typeString == "text")
+					{
+						typeInt = PGFieldType::VarCharFieldType;
+						fields_str += " \"" + (fieldname) + "\" ";
+					}
+					else if (typeString == "bytea")
+					{
+						continue;
+					}
+					else if (typeString == "timestamp without time zone")
+					{
+						fields_str += " \"" + (fieldname) + "\"::varchar ";
+					}
+				}
+			}
+		}
+		else
+		{
+			fields_str = " * ";
+		}
+
+		ss += fields_str;
+		ss += " FROM \"%s\".\"%s\" "; // 这个 %s 是tableName
+
+		if (layer->wherestr().length() > 0)
+		{
+			ss += format("where %s and ", layer->wherestr().c_str() );
+	
+		}
+		else
+		{
+			ss += " where  ";
+		}
+
+		string tableName = layer->name();
+		std::string sql = format(ss.c_str(), layer->schema().c_str(), tableName.c_str());
+
+		string shapeName = layer->geom();
+		sql += format(" ST_DWithin(\"%s\", ST_GeometryFromText('POINT(%f %f)',%s), %f) limit %d ",	
+		      shapeName.c_str(),x, y , layer->crs().srid(), dis, feature_count);
+		//cout<<sql.c_str() <<endl;
+		return sql;
+	}
+
+    
+	bool DmpWmsRenderer::AddWmsMapLayers(const DmpProject* project) //插入型加入
+	{
+        std::map<std::string, DmpMapLayer*> mapLayers =  project->mapLayers();
+		for(std::map<std::string, DmpMapLayer*>::iterator iter= mapLayers.begin();
+			 iter != mapLayers.end(); iter++)
+		{
+			this->AddMapLayer(-1, (DmpVectorLayer *)iter->second);
+		}
+		return true;
+	}
+
+	bool DmpWmsRenderer::AddWmsMapLayers(const DmpProject* project, char *layer) //插入型加入
+	{
+		bool layerIndex = true;
+		for (size_t i = 0; layer[i] != 0; i++)
+		{
+			if (!(layer[i] >= '0' && layer[i] <= '9') && layer[i] != ',')
+			{
+				layerIndex = false;
+				break;
+			}
+		}
+		if (!layerIndex)
+		{
+			set<string> set_layer;
+			int i = 0;
+			char *pl = layer;
+			while (true)
+			{
+				if (layer[i] == ',')
+				{
+					layer[i] = 0;
+					set_layer.insert(pl);
+					pl = &layer[i + 1];
+				}
+				else if (layer[i] == 0)
+				{
+					set_layer.insert(pl);
+					break;
+				}
+				i++;
+			}
+
+            std::map<std::string, DmpMapLayer*> mapLayers =  project->mapLayers();
+		    for (std::map<std::string, DmpMapLayer*>::iterator iter= mapLayers.begin(); 
+                iter != mapLayers.end(); iter++)
+		    {
+                if (set_layer.find(iter->first) != set_layer.end())
+				{
+					this->AddMapLayer(-1, (DmpVectorLayer *)iter->second);
+				}
+            }
+
+			/*for (size_t i = 0; i < pWmsServer->layers.size(); i++)
+			{
+				shared_ptr<MapLayer> layer = pWmsServer->layers.at(i);
+				if (set_layer.find(layer->m_layerName) != set_layer.end())
+				{
+					this->AddMapLayer(-1, layer);
+				}
+			}*/
+		}
+		else
+		{
+			try
+			{
+				set<int> set_layer;
+				int i = 0;
+				char *pl = layer;
+				while (true)
+				{
+					if (layer[i] == ',')
+					{
+						layer[i] = 0;
+						set_layer.insert(atoi(pl));
+						pl = &layer[i + 1];
+					}
+					else if (layer[i] == 0)
+					{
+						set_layer.insert(atoi(pl));
+						break;
+					}
+					i++;
+				}
+
+				/*for (size_t i = 0; i < pWmsServer->layers.size(); i++)
+				{
+					if (set_layer.find(i) != set_layer.end())
+					{
+						shared_ptr<MapLayer> layer = pWmsServer->layers.at(i);
+						this->AddMapLayer(-1, layer);
+					}
+				}*/
+			}
+			catch (...)
+			{
+			}
+		}
+		//pWmsServer->layers.clear();
+		return true;
+	}
+
+	
+	bool DmpWmsRenderer::AddMapLayer(int index, DmpVectorLayer* layer)
+	{
+		if (!layer)
+			return false;
+		int length = (int)m_vLayers.size();
+		if (index > length)
+			return false;
+
+		if (index < 0 || index == length)
+		{
+			m_vLayers.push_back(layer);
+		}
+		else
+		{
+			m_vLayers.insert(m_vLayers.begin() + index, layer);
+		}
+
+		return true;
+	}
+
+	bool DmpWmsRenderer::SetExtent(shared_ptr<Rect> rect)
+	{
+		m_pExtent = rect;
+		bool flag = this->RecalculateScale();
+		return flag;
+	}
+
+	bool DmpWmsRenderer::GetParameters(double *pR, double *pXdis, double *pYdis)
+	{
+		*pR = m_dR / ((resolution / oneInchInLayoutUnits));
+		*pXdis = m_dXdis / ((resolution / oneInchInLayoutUnits));
+		*pYdis = m_dYdis / ((resolution / oneInchInLayoutUnits));
+		return true;
+	}
+	bool DmpWmsRenderer::SetParameters(double r, double xdis, double ydis)
+	{
+		m_dR = r * ((resolution / oneInchInLayoutUnits));
+		m_dXdis = xdis * ((resolution / oneInchInLayoutUnits));
+		m_dYdis = ydis * ((resolution / oneInchInLayoutUnits));
+		return true;
+	}
+
+	bool DmpWmsRenderer::RecalculateScale()
+	{
+		double w = m_pExtent->m_dRight - m_pExtent->m_dLeft;
+		double h = m_pExtent->m_dTop - m_pExtent->m_dBottom;
+		if ((w > pow(10, 12)) || (w < pow(10, -12)))
+			return false;
+		if ((h > pow(10, 12)) || (h < pow(10, -12)))
+			return false;
+
+		long double R1 = m_dWidth / w;
+		long double R2 = m_dHeight / 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;
+		m_dR = r;
+		m_dXdis = m_dWidth / 2.0 - m_dR * (m_pExtent->m_dRight + m_pExtent->m_dLeft) / 2.0;
+		m_dYdis = m_dHeight / 2.0 + m_dR * (m_pExtent->m_dTop + m_pExtent->m_dBottom) / 2.0;
+
+		if(R1 < R2)
+		{
+			 double top = (m_pExtent->m_dTop + m_pExtent->m_dBottom) / 2.0 +  m_dHeight/(m_dR * 2);
+			 double bottom = (m_pExtent->m_dTop + m_pExtent->m_dBottom) / 2.0 - m_dHeight/( m_dR * 2) ;
+			 m_pExtent->m_dTop = top;
+			 m_pExtent->m_dBottom = bottom;
+		}
+		else
+		{
+			double right= (m_pExtent->m_dRight + m_pExtent->m_dLeft) / 2.0 +  m_dWidth/(2 * m_dR);
+			double left = (m_pExtent->m_dRight + m_pExtent->m_dLeft) / 2.0 -  m_dWidth/(2 * m_dR) ;
+			m_pExtent->m_dRight = right;
+			m_pExtent->m_dLeft = left;
+		}
+
+		bool isWGS84 = m_pExtent->m_dLeft <= 180 && m_pExtent->m_dRight < 180 &&
+					   m_pExtent->m_dLeft >= -180 && m_pExtent->m_dRight >= -180 &&
+					   m_pExtent->m_dTop < 90 && m_pExtent->m_dBottom < 90;
+
+		if (isWGS84)
+		{
+			m_dScaleDenominator = (this->resolution / oneInchInLayoutUnits) * (1 / r) * 111000;
+			//m_dR = r *(96 / 0.0254) *111000 ;//111000 为赤道1经度等于 111000米
+		}
+		else
+		{
+			m_dScaleDenominator = (this->resolution / oneInchInLayoutUnits) * 1 / r;
+		}
+
+		return true;
+	}
+
+	//所有的绘图都是调用这里
+	/*
+1. 在 dc 上绘图时,传入 类变量 m_pClsSurfImage
+2. 切图时,给定额外的surface
+3. DrawShape是, 传入 类变量 m_pClsSurfBuffer
+4. 好像不会传 NULL
+*/
+	bool DmpWmsRenderer::DrawSimpleData(DataCollection *data, Renderer *renderer, clsCrSurf *pClsCS)
+	{
+		/*
+	一次绘图只创建一次 cairo
+	*/
+		int iPartCount = data->m_iPartCount;
+		if (iPartCount > 0 && data->m_pData)
+		{
+			renderer->DrawData(pClsCS, data, true);
+			return true;
+		}
+		if (iPartCount == 0)
+			return false;
+		else
+		{
+			return false;
+		}
+		return true;
+	}
+/*
+	bool DmpWmsRenderer::DrawData(DataCollection *data, Renderer *renderer, clsCrSurf *pClsCS)
+	{
+	
+		int iPartCount = data->m_iPartCount;
+		if (iPartCount > 0 && data->m_pData)
+		{
+			renderer->DrawData(pClsCS, data, false);
+			return true;
+		}
+		if (iPartCount == 0)
+			return false;
+		else
+		{
+			return false;
+		}
+
+		return true;
+	}
+*/
+	bool DmpWmsRenderer::ResetDrawShapeBuffer()
+	{
+		int iW = (int)m_dWidth;
+		int iH = (int)m_dHeight;
+		unsigned char *buffer = cairo_image_surface_get_data(m_pClsSurfBuff->m_pSurf);
+		memset(buffer, 0, iW * iH * 4);
+		return true;
+	}
+	bool DmpWmsRenderer::ResetMaxBuffer()
+	{
+		int iW = m_pClsMaxSurfBuffer->m_iW;
+		int iH = m_pClsMaxSurfBuffer->m_iH;
+		unsigned char *buffer = cairo_image_surface_get_data(m_pClsMaxSurfBuffer->m_pSurf);
+		memset(buffer, 0, iW * iH * 4);
+		return true;
+	}
+
+
+    bool DmpWmsRenderer::BufferCopy(clsCrSurf *pClsCSFrom, clsCrSurf *pClsCSTo)
+	{
+		if (pClsCSFrom == NULL)
+			pClsCSFrom = m_pClsSurfBuff;
+		if (pClsCSTo == NULL)
+			pClsCSTo = m_pClsSurfDC;
+
+		cairo_t *cr = pClsCSTo->m_pCr;
+		cairo_set_source_surface(cr, pClsCSFrom->m_pSurf, 0, 0);
+		cairo_paint(cr);
+		return true;
+	}
+
+	//不需要传参,map 只有一份surface
+	bool DmpWmsRenderer::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;
+		clsUtil::ToCairoColor(iColor, r, g, b, a);
+		cairo_set_source_rgba(cr, r, g, b, 0);
+		cairo_fill(cr);
+		return true;
+	}
+	
+
+	//在DC上绘制时是否使用一个临时的 image_surface, 然后拷上去,这样具体的细节处理就没有区别了
+	bool DmpWmsRenderer::GetMap(map<string, string> *map_layerDefs,map<string, string> * map_regionDefs, clsCrSurf *pClsCS, bool isThumbnail,
+					  shared_ptr<Rect> pRect, double r__, double x_dis__, double y_dis__)
+	{
+		/*确定参数*/
+		clsCrSurf *pClsSurfThis;
+		if (pClsCS == NULL)
+		{
+			pClsSurfThis = m_pClsSurfBuff; //refresh画图在  buff 中
+			this->DoSetBackGround(pClsSurfThis, m_iBackColor);
+		}
+		else
+		{
+			pClsSurfThis = pClsCS;
+			this->DoSetBackGround(pClsSurfThis, 0xffffffff);
+		}
+
+		shared_ptr<Rect> pExtent;
+		if (pRect == NULL)
+			pExtent = m_pExtent;
+		else
+			pExtent = pRect;
+		double r, x_dis, y_dis;
+		if (r__ == -1)
+		{
+			r = m_dR;
+			x_dis = m_dXdis;
+			y_dis = m_dYdis;
+		}
+		else
+		{
+			r = r__;
+			x_dis = x_dis__;
+			y_dis = y_dis__;
+		}
+
+   /*
+	* 重置文字避让
+	*/
+		//文字避让是否写成局部??
+		pClsSurfThis->InitFlag(); //已初始化文字避让数组,在 pClsSurfThis中
+		//char* pFlag = pClsSurfThis->m_pFlag;
+		this->ResetMaxBuffer();
+
+		bool has_regionDefs = false;
+		string strRegionColDefs = "";
+		string strRegionLayerNameDefs = "";
+
+		if(map_regionDefs)
+		{
+			map<string, string>::iterator iter_regionDef = map_regionDefs->begin();
+			if (iter_regionDef != map_regionDefs->end())
+			{
+				strRegionColDefs = iter_regionDef->second.c_str();
+				strRegionLayerNameDefs = iter_regionDef->first.c_str();
+				has_regionDefs = true;
+			}
+		}
+		
+
+		map<DmpVectorLayer*, shared_ptr<DataCollection>> map_DataCollection;
+
+		for (int i = 0; i < (int)(m_vLayers.size()); i++)
+		{
+			DmpVectorLayer* layer = m_vLayers[i];
+		
+
+			double r1 = layer->maxScale(); // *
+			double r2 = layer->minScale(); // *
+			bool has_layerDef = false;
+			const char *strLayerDef = nullptr;
+
+			//if ((this->m_dScaleDenominator > r1 || this->m_dScaleDenominator < r2 || layer->GetRenderer30() == nullptr) && isThumbnail == false)
+			//	continue;
+
+			if (map_layerDefs)
+			{
+				map<string, string>::iterator iter_layerDef = map_layerDefs->find(layer->name());
+				if (iter_layerDef != map_layerDefs->end())
+				{
+					has_layerDef = true;
+					strLayerDef = iter_layerDef->second.c_str();
+				}
+			}
+
+			//bool isbuffQuery = false;
+		//	double width_scale = abs((layer->m_pDataset->maxx - layer->m_pDataset->minx) / (pExtent->m_dRight - pExtent->m_dLeft));
+			{
+				//std::printf("db \r\n ");
+				double start = clock();
+				double cost, cost2;
+
+				string sql ="";
+				shared_ptr<DmpVectorThinLayer> pVectorThinLayer = nullptr;
+
+				bool renderHeat = false;
+				shared_ptr<DataCollection> data(new DataCollection());
+
+				if(!has_regionDefs)
+				{
+                    sql = GetDrawSQL(layer, pExtent.get(), strLayerDef);
+				}
+				else
+				{
+					sql = GetRegionQuerySQL(layer, pExtent.get(), format("%d",layer->crs().srid()), strRegionLayerNameDefs,strRegionColDefs, strLayerDef);
+				}
+
+				pVectorThinLayer = layer->GetCurrentScaleTable(1 / this->m_dR);
+
+			// printf( "%s\r\n", sql.c_str());
+			// this->GetDrawSQL(layer, pExtent.get(), strLayerDef); //sql语句中使用 ::box
+				if (sql == "")
+					continue;
+
+				string tableName = layer->name();
+
+				
+				if (pVectorThinLayer != nullptr)
+				{
+			       tableName = pVectorThinLayer->tableName();
+		        }
+
+				if(tableName.length() > 32)
+				{
+					tableName = tableName.substr(32);
+				}
+
+				
+				const char *ss__ = "";
+				const char **pmsg = &ss__;
+				try
+				{
+
+					shared_ptr<DmpPgsql> pPgsqlConn = nullptr;
+					if(pVectorThinLayer == nullptr)
+					{
+						pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
+					}
+					else
+					{
+						pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetDefaultPgsqlConn();
+					}
+					
+					if (pPgsqlConn == nullptr)
+							break;
+					if (pPgsqlConn->ExecWaitBinary(sql))
+					{
+						PGresult *res = pPgsqlConn->GetPGresult();
+						if (PQntuples(res) == 0)
+							continue;
+
+						int shapeType = layer->GeometryType();
+						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, (int)layer->subset, m_dR, m_dScaleDenominator, x_dis, y_dis);
+						map_DataCollection[layer] = data;
+						//data_ptr = data;
+						auto endTime_data = chrono::steady_clock::now();
+
+						allDataCount += PQntuples(res);
+						this->DrawSimpleData(data.get(), layer->GetRenderer30().get(), pClsSurfThis);
+					//	DrawText(StringHelp::fmt("data %.0fm",(endTime_data - startTime).count()/1000000.0) 
+					//		,pClsSurfThis,10,50);
+
+					/*
+						DrawText(tableName ,pClsSurfThis,10,100);
+
+						char ptext[100] = {0};
+						sprintf(ptext, "count = %d",allDataCount);
+						DrawText2(ptext ,pClsSurfThis,10,140);
+
+						*/
+					}
+					else if(pVectorThinLayer != nullptr)
+					{
+						shared_ptr<DmpPgsql>  pPgsqlConn1 = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
+						
+						if (pPgsqlConn1 == nullptr)
+							break;
+						if (pPgsqlConn1->ExecWaitBinary(sql))
+						{
+							PGresult *res = pPgsqlConn1->GetPGresult();
+							if (PQntuples(res) == 0)
+								continue;
+
+							int shapeType = layer->GeometryType();
+							shared_ptr<DataCollection> data(new DataCollection());
+							if(!renderHeat)
+							{
+								data->InitDataCollection(res, shapeType, this->m_dWidth, this->m_dHeight, 0, m_dR, m_dScaleDenominator, x_dis, y_dis);
+							}
+							else
+							{
+								data->InitHeatCollection(res, shapeType, this->m_dWidth, this->m_dHeight, 
+								 pExtent->m_dLeft,  pExtent->m_dRight, pExtent->m_dBottom, pExtent->m_dTop, 0, m_dR, m_dScaleDenominator, x_dis, y_dis);
+							}
+							
+							map_DataCollection[layer] = data;
+
+							//auto endTime_data = chrono::steady_clock::now();
+							//data_ptr = data;
+
+							allDataCount += PQntuples(res);
+							this->DrawSimpleData(data.get(), layer->GetRenderer30().get(), pClsSurfThis);
+
+						}
+						else
+						{
+							//DrawText2("获取数据失败,找不到图层" ,pClsSurfThis,10,10);	
+						}
+					}
+
+				}
+				catch (const std::exception &e)
+				{
+					std::cerr << "#DrawSimpleData " << e.what() << '\n';
+				}
+			}
+		}
+
+
+		map_DataCollection.clear();
+
+		//return true;
+		if (pClsCS == NULL) //这个时候证明是在 buffer 上绘图,直接拷到 dc上
+		{
+			this->BufferCopy(m_pClsSurfBuff, m_pClsMaxSurfBuffer);
+			this->BufferCopy(m_pClsSurfBuff, m_pClsSurfDC);
+		}
+		return true;
+	}
+
+
+	bool DmpWmsRenderer::ToStream(std::string& responseData)
+	{
+		responseData.reserve(10240);
+		if(this->pRasterBufferObj == nullptr)
+		{
+			cairo_surface_write_to_png_stream(m_pClsSurfDC->m_pSurf, cairo_write_func, &responseData);
+			return true;
+		}
+		else
+        {
+			return ToPngStream(this->pRasterBufferObj, responseData);
+		}
+	}
+
+	
+bool DmpWmsRenderer::ToPngStream(rasterBufferObj *rb,std::string& responseData)
+{
+	png_infop info_ptr;
+    int color_type;
+    int row;
+    unsigned int *rowdata;
+	int compression = 9;
+    png_structp png_ptr = png_create_write_struct(
+                            PNG_LIBPNG_VER_STRING, NULL,NULL,NULL);
+
+    if (!png_ptr)
+      return (false);
+
+    png_set_compression_level(png_ptr, compression);
+    png_set_filter (png_ptr,0, PNG_FILTER_NONE);
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+      png_destroy_write_struct(&png_ptr,
+                               (png_infopp)NULL);
+      return (false);
+    }
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+      png_destroy_write_struct(&png_ptr, &info_ptr);
+      return (false);
+    }
+    //if(info->fp)
+    //  png_set_write_fn(png_ptr,info, png_write_data_to_stream, png_flush_data);
+    //else
+    png_set_write_fn(png_ptr,&responseData, png_write_data_to_buffer, png_flush_data);
+
+    if(rb->data.rgba.a)
+      color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+    else
+      color_type = PNG_COLOR_TYPE_RGB;
+
+    png_set_IHDR(png_ptr, info_ptr, rb->width, rb->height,
+                 8, color_type, PNG_INTERLACE_NONE,
+                 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+    png_write_info(png_ptr, info_ptr);
+
+    if(!rb->data.rgba.a && rb->data.rgba.pixel_step==4)
+      png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
+
+    rowdata = (unsigned int*)malloc(rb->width*sizeof(unsigned int));
+    for(row=0; row<rb->height; row++) {
+      unsigned int *pixptr = rowdata;
+      int col;
+      unsigned char *a,*r,*g,*b;
+      r=rb->data.rgba.r+row*rb->data.rgba.row_step;
+      g=rb->data.rgba.g+row*rb->data.rgba.row_step;
+      b=rb->data.rgba.b+row*rb->data.rgba.row_step;
+      if(rb->data.rgba.a) {
+        a=rb->data.rgba.a+row*rb->data.rgba.row_step;
+        for(col=0; col<rb->width; col++) {
+          if(*a) {
+            double da = *a/255.0;
+            unsigned char *pix = (unsigned char*)pixptr;
+            pix[0] = *r/da;
+            pix[1] = *g/da;
+            pix[2] = *b/da;
+            pix[3] = *a;
+          } else {
+            *pixptr=0;
+          }
+          pixptr++;
+          a+=rb->data.rgba.pixel_step;
+          r+=rb->data.rgba.pixel_step;
+          g+=rb->data.rgba.pixel_step;
+          b+=rb->data.rgba.pixel_step;
+        }
+      } else {
+        for(col=0; col<rb->width; col++) {
+          unsigned char *pix = (unsigned char*)pixptr;
+          pix[0] = *r;
+          pix[1] = *g;
+          pix[2] = *b;
+          pixptr++;
+          r+=rb->data.rgba.pixel_step;
+          g+=rb->data.rgba.pixel_step;
+          b+=rb->data.rgba.pixel_step;
+        }
+      }
+
+      png_write_row(png_ptr,(png_bytep)rowdata);
+
+    }
+    png_write_end(png_ptr, info_ptr);
+    free(rowdata);
+    png_destroy_write_struct(&png_ptr, &info_ptr);
+    return MS_SUCCESS;
+}
+
+
+}

+/**************************************************************************
+* file:              dmpwmsrenderer.h
+
+* Author:            qingxiongf
+* Date:              2021-12-12 21:55:51
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpwmsrenderer_h__
+#define __dmpwmsrenderer_h__
+#include <iostream>
+#include <string>
+#include <map>
+#include <boost/dll/alias.hpp> // for BOOST_DLL_ALIAS
+#include <boost/filesystem.hpp>
+#include <boost/function.hpp>
+#include <boost/make_shared.hpp>
+#include "legendParamater.h"
+#include "clsCrSurf.h"
+#include "clsRect.h"
+#include "clsUtil.h"
+#include "DataCollection.h"
+#include "dmpvectorlayer.h"
+#include "dmpvectorthinlayer.h"
+#include "dmprasterbuffer.h"
+#include "dmpproject.h"
+#include "dmppgsqlsourcepools.h"
+
+using namespace std;
+using namespace DmapCore_30;
+using namespace mapserver;
+namespace DmpWms
+{
+
+
+    class DmpWmsRenderer
+    {
+    public:
+		DmpWmsRenderer(double height, double width);
+		~DmpWmsRenderer();
+
+		int  initializeRasterBufferCairo(rasterBufferObj *rb, int width, int height);
+
+		bool GetMapLog(std::stringstream&  outputStream, map<string,string>* map_layerDefs = NULL,map<string,string>* map_regionDefs = NULL,  shared_ptr<Rect> pRect = nullptr, double r__ = -1, double x_dis__ = 0, double y_dis__ = 0);
+		bool GetMap(map<string,string>* map_layerDefs = NULL,map<string,string>* map_regionDefs = NULL, clsCrSurf* pClsSurf = NULL,bool isThumbnail = false, shared_ptr<Rect> pRect = nullptr, double r__ = -1, double x_dis__ = 0, double y_dis__ = 0);
+		bool GetFeatureInfo(std::stringstream& ab, int gmlVersion, int x, int y, int feature_count);
+		
+		bool GetMapLegend( std::stringstream& ab, shared_ptr<legendParamater> pLegendParamater);
+		bool GetMapLegend( shared_ptr<legendParamater> pLegendParamater, clsCrSurf* pClsSurf);
+		
+		string GetDrawSQLAll_Catch(DmpVectorLayer* layer,shared_ptr<DmpVectorThinLayer> pMapLayerThinning);
+		string GetDrawSQL(DmpVectorLayer* layer, Rect* pRect,const char* layerdef = nullptr);
+		string GetDrawSQLAll(DmpVectorLayer* layer);
+		string GetDrawSQLAllOrderby(DmpVectorLayer* layer);
+		string GetRegionQuerySQL(DmpVectorLayer* layer,Rect *pRect,string srid,const char *regionDef,const char *layerdef);
+		string GetRegionQuerySQL(DmpVectorLayer* layer,Rect *pRect,string srid, const string &regionLayerName,const string &regionDef,const char *layerdef);
+		string GetCountSQL(DmpVectorLayer* layer);
+		string GetFeatureInfoSQL(DmpVectorLayer* layer,double x, double y, double dis, int feature_count);
+		std::string format(const char*, ...);
+
+		void TryAddField1(vector<string>&pvField, string str);
+		bool AddMapLayer(int index, DmpVectorLayer* layer);   //插入型加入
+		bool AddWmsMapLayers(const DmpProject*);   //插入型加入
+		bool AddWmsMapLayers(const DmpProject*, char *);   //插入型加入
+		bool EnableToServer();
+		bool ResetMaxBuffer();
+		bool ResetDrawShapeBuffer();
+
+		int SaveWmsMapLayers();   //插入型加入
+		bool DrawSimpleData(DataCollection* data, Renderer* renderer, clsCrSurf* pClsSurf);
+
+		//shared_ptr<Rect> GetFullExtent(bool bRecalculate); //加一个bool值,如果为false , 无需计算
+		//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);
+		bool ToRealCoord(double x, double y, double* realX, double* realY);
+		bool BufferCopy(clsCrSurf* clsSufFrom = NULL, clsCrSurf* clsSurfTo = NULL);
+
+		
+		bool ToStream(string &responseData);
+		bool ToPngStream(rasterBufferObj *rb,string &responseData); //streamInfo *info
+
+		//int GetLayerCount();
+		//bool RemoveMapLayer(int index);
+		//shared_ptr<DmpVectorLayer> GetMapLayer(int index);
+		bool SetMapLayer(int index, shared_ptr<DmpVectorLayer> layer);
+		bool ClearLayers();
+	
+		bool SetBackGround(int color);
+		int  GetBackGround();
+		bool SortByID();   //使用 layer 中的ID 号, 将 map 中的所有layer 重新排序
+
+		clsCrSurf* GetSurfDC();
+		/*
+		合成一个函数, map为 NULL 时, 读取,map 不为NULL , 写入
+		真的有必要?
+		*/
+
+	
+
+		clsCrSurf* m_pClsSurfDC; // 此surface使用 DC 构造
+		//clsSurface* m_pClsSurfImage;  //这个按 DC大小构造的 image_surface, 绘图都在这上面完成
+		clsCrSurf* m_pClsSurfBuff;    //这个也是 image_surface,大小也与dc一致
+
+		int resolution = 96;
+		double oneInchInLayoutUnits = 0.0254;
+
+		double m_dR;
+		double m_dScaleDenominator;
+		double m_dXdis;
+		double m_dYdis;
+		double m_dHeight;     //HDC 高;
+		double m_dWidth;      //HDC 宽
+		shared_ptr<Rect> m_pExtent;        //绘图范围
+
+		vector<string> m_vWKS_name;
+		vector<string> m_vWKS_conn;
+
+		int allDataCount =0;
+
+        rasterBufferObj* pRasterBufferObj = nullptr;;
+		clsCrSurf* m_pClsMaxSurfBuffer;
+		
+	private:
+		int m_iN;
+	public:
+		vector<DmpVectorLayer* > m_vLayers;
+		vector<DmpProject*> m_WMSServers;
+
+	private:
+		int m_iBackColor;
+		shared_ptr<Rect> m_pFullExtent;
+		bool DoSetBackGround(clsCrSurf* pClsSurf, int iColor); //设置背景色
+		bool RecalculateScale();
+	private:
+	
+		//string CutMap(Rect* rect, double rule, const char* path, FILE* f);
+		//bool GetCutMapData(Rect* rect, double r, double x_dis, double y_dis);
+		//string CutMapOnce(clsCrSurf* pClsSurf, double x0, double y0, double r, double x_dis, double y_dis, const char* path, FILE*f);
+		bool CreateCutMapXML(double x, double y, double width, double height, vector<double>* pvDouble, const char* path);
+		bool CollectRules(const char* sRules);
+		bool CollectRules2(const char* sRules);
+
+		//void FormatWFSJsonCAll(shared_ptr<Workspace> pWorkspace, AppendBuffer *ab, char *layerNAMEc,int gmlVersion,char *srsOut);
+		//void FormatWFSXMLCAll(shared_ptr<Workspace> pWorkspace, AppendBuffer *ab, char *layerNAMEc, int gmlVersion,char *srsOut);
+    };
+}
+
+#endif // __dmpwmsrenderer_h__

+
+URL 路径：
+http://localhost:8088/DMap/Services/广州地址/MapServer/WMSService?Service=WMS
+
+/DMap/Services/?([\\w./]*)/MapServer/([\\w]+)
+

@@ -35,38 +35,38 @@ namespace DmpTms
     
     if(context.request()->isRestful())
     {
-      std::string path_=context.request()->path();
-      std::vector<std::string> vec_;
-      boost::split(vec_,context.request()->path(),boost::is_any_of("/"),boost::token_compress_on);
-      int isize_=vec_.size();
-      if(isize_<4)
+      std::string path=context.request()->path();
+      std::vector<std::string> vec;
+      boost::split(vec,context.request()->path(),boost::is_any_of("/"),boost::token_compress_on);
+      int isize=vec.size();
+      if(isize<4)
       {
         context.response()->write("Tms,Operation is null");
         return;
       }
-      std::string::size_type idx0_,idx1_;
-      idx0_=vec_[isize_-1].find("png");
-      idx1_=vec_[isize_-1].find("jpg");
+      std::string::size_type idx0,idx1;
+      idx0=vec[isize-1].find("png");
+      idx1=vec[isize-1].find("jpg");
       
-      if((idx0_!=std::string::npos)||(idx1_!=std::string::npos))
+      if((idx0!=std::string::npos)||(idx1!=std::string::npos))
       {
-        std::vector<std::string> vec0_;
-        boost::split(vec0_,vec_[isize_-1],boost::is_any_of("."),boost::token_compress_on);
-        int tileCol_=atoi(vec0_[0].c_str());
-        int tileRow_=atoi(vec_[isize_-2].c_str());
-        int tileMatrix_=atoi(vec_[isize_-3].c_str());
+        std::vector<std::string> vec0;
+        boost::split(vec0,vec[isize-1],boost::is_any_of("."),boost::token_compress_on);
+        int tileCol=atoi(vec0[0].c_str());
+        int tileRow=atoi(vec[isize-2].c_str());
+        int tileMatrix=atoi(vec[isize-3].c_str());
         const DmpProject *project = context.project();
-        DmpTileLayer *tileLayer = static_cast<DmpTileLayer *>(project->getLayer("layer"));
-        std::string format_=vec0_[1].c_str();
-        std::string filePath_=tileLayer->getDataSource();
-        if(filePath_.empty())
+        DmpTileLayer *tileLayer = static_cast<DmpTileLayer *>(project->getLayer());
+        std::string format=vec0[1].c_str();
+        std::string filePath=tileLayer->getDataSource();
+        if(filePath.empty())
         {
           context.response()->write("Tms,Operation is null");
         }
         else
         {
-          DmpTmsTileProvider provider_=DmpTmsTileProvider(filePath_);
-          provider_.WriteTile(tileRow_, tileCol_, tileMatrix_, format_, *context.response()); 
+          DmpTmsTileProvider provider_=DmpTmsTileProvider(filePath);
+          provider_.WriteTile(tileRow, tileCol, tileMatrix, format, *context.response()); 
         }
       }
       else

@@ -52,56 +52,56 @@ namespace DmpWmts
         return;
       }
    }
-   void DmpCapabiliTilesOperation::WriteCapabilities(boost::property_tree::ptree& pt_,const std::string& host_,const std::string& servicename,DmpServerResponse& response)
+   void DmpCapabiliTilesOperation::WriteCapabilities(boost::property_tree::ptree& pt,const std::string& host,const std::string& servicename,DmpServerResponse& response)
    {
       //构建能力文档
-      boost::property_tree::ptree pt_root_,pt_TileMatrix_;
-      CreateGetCapabilitiesDocument(host_,servicename,pt_root_);
-      pt_root_.add("Capabilities.Contents.Layer.ows:Title",pt_.get<std::string>("Layer.ows:Title"));
-      pt_root_.add("Capabilities.Contents.Layer.ows:Abstract",pt_.get<std::string>("Layer.ows:Abstract"));
-      pt_root_.add("Capabilities.Contents.Layer.ows:Identifier",pt_.get<std::string>("Layer.ows:Identifier"));
+      boost::property_tree::ptree pt_root,pt_TileMatrix;
+      CreateGetCapabilitiesDocument(host,servicename,pt_root);
+      pt_root.add("Capabilities.Contents.Layer.ows:Title",pt.get<std::string>("Layer.ows:Title"));
+      pt_root.add("Capabilities.Contents.Layer.ows:Abstract",pt.get<std::string>("Layer.ows:Abstract"));
+      pt_root.add("Capabilities.Contents.Layer.ows:Identifier",pt.get<std::string>("Layer.ows:Identifier"));
       //pt_root_.add("Capabilities.Contents.Layer.Style.<xmlattr>.isDefault",pt_.get<std::string>("Layer.Style.<xmlattr>.isDefault"));
-      pt_root_.add("Capabilities.Contents.Layer.Style",pt_.get<std::string>("Layer.Style"));
-      pt_root_.add("Capabilities.Contents.Layer.Format",pt_.get<std::string>("Layer.Format"));
-      pt_root_.add("Capabilities.Contents.Layer.TileMatrixSetLink.TileMatrixSet",pt_.get<std::string>("Layer.TileMatrixSetLink.TileMatrixSet"));
+      pt_root.add("Capabilities.Contents.Layer.Style",pt.get<std::string>("Layer.Style"));
+      pt_root.add("Capabilities.Contents.Layer.Format",pt.get<std::string>("Layer.Format"));
+      pt_root.add("Capabilities.Contents.Layer.TileMatrixSetLink.TileMatrixSet",pt.get<std::string>("Layer.TileMatrixSetLink.TileMatrixSet"));
       
-      boost::property_tree::ptree pt_TileMatrixSet_;
-      pt_TileMatrixSet_.add("ows:Identifier",pt_.get<std::string>("TileMatrixSet.ows:Identifier"));
-      pt_TileMatrixSet_.add("ows:SupportedCRS",pt_.get<std::string>("TileMatrixSet.ows:SupportedCRS"));
-      pt_TileMatrixSet_.add("TileWidth",pt_.get<std::string>("TileMatrixSet.TileWidth"));
-      pt_TileMatrixSet_.add("TileHeight",pt_.get<std::string>("TileMatrixSet.TileHeight"));
-      pt_TileMatrixSet_.add("TopLeftCorner",pt_.get<std::string>("TileMatrixSet.TopLeftCorner"));
-      pt_TileMatrixSet_.add("Dpi",pt_.get<std::string>("TileMatrixSet.DPI"));
+      boost::property_tree::ptree pt_TileMatrixSet;
+      pt_TileMatrixSet.add("ows:Identifier",pt.get<std::string>("TileMatrixSet.ows:Identifier"));
+      pt_TileMatrixSet.add("ows:SupportedCRS",pt.get<std::string>("TileMatrixSet.ows:SupportedCRS"));
+      pt_TileMatrixSet.add("TileWidth",pt.get<std::string>("TileMatrixSet.TileWidth"));
+      pt_TileMatrixSet.add("TileHeight",pt.get<std::string>("TileMatrixSet.TileHeight"));
+      pt_TileMatrixSet.add("TopLeftCorner",pt.get<std::string>("TileMatrixSet.TopLeftCorner"));
+      pt_TileMatrixSet.add("Dpi",pt.get<std::string>("TileMatrixSet.DPI"));
      
       //pt_TileMatrix_=pt_.get_child("TileMatrixSet.TileMatrix");
-      pt_TileMatrix_=pt_.get_child("TileMatrixSet.Levels");
-      int i=pt_TileMatrix_.size();
-      boost::property_tree::ptree::iterator pos_ = pt_TileMatrix_.begin();
-      for (; pos_ != pt_TileMatrix_.end(); ++pos_ )
+      pt_TileMatrix=pt.get_child("TileMatrixSet.Levels");
+      int i=pt_TileMatrix.size();
+      boost::property_tree::ptree::iterator pos = pt_TileMatrix.begin();
+      for (; pos != pt_TileMatrix.end(); ++pos )
       {
-            boost::property_tree::ptree pt_level_;
-            boost::property_tree::ptree ptTile_ = pos_->second;
-            std::string level_=ptTile_.get<std::string>("level");
-            std::string scale_=ptTile_.get<std::string>("scale");
-            std::string resolution_=ptTile_.get<std::string>("resolution");
-            pt_level_.add("ows:Identifier",level_);
-            pt_level_.add("ows:ScaleDenominator",scale_);
-            pt_level_.add("ows:Resolution",resolution_);
+            boost::property_tree::ptree pt_level;
+            boost::property_tree::ptree ptTile = pos->second;
+            std::string level=ptTile.get<std::string>("level");
+            std::string scale=ptTile.get<std::string>("scale");
+            std::string resolution=ptTile.get<std::string>("resolution");
+            pt_level.add("ows:Identifier",level);
+            pt_level.add("ows:ScaleDenominator",scale);
+            pt_level.add("ows:Resolution",resolution);
             
-            pt_TileMatrixSet_.add_child("TileMatrix",pt_level_);
+            pt_TileMatrixSet.add_child("TileMatrix",pt_level);
       }
-      pt_root_.add_child("Capabilities.Contents.TileMatrixSet",pt_TileMatrixSet_);
+      pt_root.add_child("Capabilities.Contents.TileMatrixSet",pt_TileMatrixSet);
       //pt_root_.add("Capabilities.Contents.TileMatrixSet.TileMatrix.ows:Identifier",pt_.get<std::string>("TileMatrixSet.TileMatrix.ows:Identifier"));
       //pt_root_.add("Capabilities.Contents.TileMatrixSet.TileMatrix.TopLeftCorner",pt_.get<std::string>("TileMatrixSet.TileMatrix.TopLeftCorner"));
-      std::string http_cap0_="http://"+host_+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/WMTSCapabilities.xml";
-      pt_root_.add("Capabilities.ServiceMetadataURL.<xmlattr>.xlink:href",http_cap0_);
+      std::string http_cap0="http://"+host+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/WMTSCapabilities.xml";
+      pt_root.add("Capabilities.ServiceMetadataURL.<xmlattr>.xlink:href",http_cap0);
       
       //写入流
       std::stringstream ss;
-      boost::property_tree::write_xml(ss,pt_root_);
-      std::string strExtent_=ss.str();    
+      boost::property_tree::write_xml(ss,pt_root);
+      std::string strExtent=ss.str();    
       response.setHeader("Content-Type", "application/xml;charset=utf-8");
-      response.write(strExtent_);
+      response.write(strExtent);
       return;
       /*
       //文件流代换写入
@@ -138,7 +138,7 @@ namespace DmpWmts
    void DmpCapabiliTilesOperation::GetCapabilitiesDocument(DmpServerResponse& response)
    {    
    }
-   void DmpCapabiliTilesOperation::CreateGetCapabilitiesDocument(const std::string& host_,const std::string& servicename,boost::property_tree::ptree& pt)
+   void DmpCapabiliTilesOperation::CreateGetCapabilitiesDocument(const std::string& host,const std::string& servicename,boost::property_tree::ptree& pt)
    {
       pt.add("Capabilities.<xmlattr>.xmlns",WMTS_NAMESPACE);
       pt.add("Capabilities.<xmlattr>.xmlns:gml",GML_NAMESPACE);
@@ -153,7 +153,7 @@ namespace DmpWmts
       pt.add_child("Capabilities.ows:ServiceIdentification",pt_Identification);
       GetServiceProviderElement(pt_Provider);
       pt.add_child("Capabilities.ows:ServiceProvider",pt_Provider);
-      GetServiceMetadataElement(host_,servicename,pt_Metadata);
+      GetServiceMetadataElement(host,servicename,pt_Metadata);
       pt.add_child("Capabilities.ows:OperationsMetadata",pt_Metadata);
       //pt.add("Capabilities.Contents.Layer",servicename);
 
@@ -178,38 +178,38 @@ namespace DmpWmts
       pt.add("ows:ServiceContact.ows:ContactInfo.ows:Phone","020-87578877");
    }
 
-   void DmpCapabiliTilesOperation:: GetServiceMetadataElement(const std::string& host_,const std::string& servicename,boost::property_tree::ptree& pt)
+   void DmpCapabiliTilesOperation:: GetServiceMetadataElement(const std::string& host,const std::string& servicename,boost::property_tree::ptree& pt)
    {
       //localhost:8080/DMap/Services/GDWMTS/MapServer/WMTSServer?request=GetCapabilities
-      std::string http_cap0_="http://"+host_+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/WMTSCapabilities.xml";
-      std::string http_cap1_="http://"+host_+"/DMap/Services/"+servicename+"/TileServer/WMTSService?";
-      std::string http_cap2_="http://"+host_+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/";   
-      boost::property_tree::ptree pt_child0_,pt_child1_;
+      std::string http_cap0="http://"+host+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/WMTSCapabilities.xml";
+      std::string http_cap1="http://"+host+"/DMap/Services/"+servicename+"/TileServer/WMTSService?";
+      std::string http_cap2="http://"+host+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/";   
+      boost::property_tree::ptree pt_child0,pt_child1;
       
-      pt_child0_.add("<xmlattr>.name","GetCapabilities");
-      boost::property_tree::ptree pt_child00_,pt_child01_;
-      pt_child00_.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap0_);
-      pt_child00_.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
-      pt_child00_.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","RESTful");
-      pt_child0_.add_child("ows:DCP",pt_child00_);
+      pt_child0.add("<xmlattr>.name","GetCapabilities");
+      boost::property_tree::ptree pt_child00,pt_child01;
+      pt_child00.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap0);
+      pt_child00.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
+      pt_child00.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","RESTful");
+      pt_child0.add_child("ows:DCP",pt_child00);
 
-      pt_child01_.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap1_);
-      pt_child01_.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
-      pt_child01_.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","KVP");
-      pt_child0_.add_child("ows:DCP",pt_child01_);
-      pt.add_child("ows:Operation",pt_child0_);
+      pt_child01.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap1);
+      pt_child01.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
+      pt_child01.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","KVP");
+      pt_child0.add_child("ows:DCP",pt_child01);
+      pt.add_child("ows:Operation",pt_child0);
       
-      pt_child1_.add("<xmlattr>.name","GetTile");
-      boost::property_tree::ptree pt_child10_,pt_child11_;
-      pt_child10_.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap2_);
-      pt_child10_.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
-      pt_child10_.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","RESTful");
-      pt_child1_.add_child("ows:DCP",pt_child10_);
-      pt_child11_.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap1_);
-      pt_child11_.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
-      pt_child11_.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","KVP");
-      pt_child1_.add_child("ows:DCP",pt_child11_);
-      pt.add_child("ows:Operation",pt_child1_);    
+      pt_child1.add("<xmlattr>.name","GetTile");
+      boost::property_tree::ptree pt_child10,pt_child11;
+      pt_child10.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap2);
+      pt_child10.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
+      pt_child10.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","RESTful");
+      pt_child1.add_child("ows:DCP",pt_child10);
+      pt_child11.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap1);
+      pt_child11.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
+      pt_child11.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","KVP");
+      pt_child1.add_child("ows:DCP",pt_child11);
+      pt.add_child("ows:Operation",pt_child1);    
    }
    void GetServiceTileMatrixSetElement(const std::string& servicename,boost::property_tree::ptree& pt)
    {

@@ -30,21 +30,22 @@ namespace DmpWmts
     try
     {
       std::string tileVersion= dmpTileLayer->getVendor();
-      std::string tilePath_=dmpTileLayer->getDataSource();
+      std::string tilePath=dmpTileLayer->getDataSource();
       //std::string tilePath_ = "/mnt/d/Code/tiles/gdmap/_alllayers";
       //std::string tileVersion_ = "ESRI_V1";
-      int iver=StringToVector(tileVersion);      
+      int iver=StringToVector(tileVersion);    
       Vendor version = (Vendor)boost::lexical_cast<int>(iver);
       switch(version)
 		  {
 			  case Vendor::ESRI_V0: 
-          provider = std::make_shared<DmpEsriTileProvider>(tilePath_);
+          provider = std::make_shared<DmpEsriTileProvider>(tilePath);
 				  break;
     	  case Vendor::ESRI_V1:
-          provider = std::make_shared<DmpEsriBundleV1Provider>(tilePath_);
+          provider = std::make_shared<DmpEsriBundleV1Provider>(tilePath);
 				  break;
         case Vendor::ESRI_V2: 
-          provider = std::make_shared<DmpEsriBundleV2Provider>(tilePath_);
+          provider = std::make_shared<DmpEsriBundleV2Provider>(tilePath);
+
 				  break;
 			  default:
           provider = nullptr;
@@ -60,24 +61,24 @@ namespace DmpWmts
   }
   int TileProviderFactory::StringToVector(std::string& strVector)
   {
-        int iVector_=-1;
+        int iVector=-1;
         if(std::strcmp(strVector.c_str(),"ESRI_V0")==0)
         {
-            iVector_=0;
+            iVector=0;
         }
         else if(std::strcmp(strVector.c_str(),"ESRI_V1")==0)
         {
-            iVector_=1;
+            iVector=1;
         }    
         else if(std::strcmp(strVector.c_str(),"ESRI_V2")==0)
         {
-            iVector_=2;
+            iVector=2;
         } 
         else
         {
-            iVector_=3;
+            iVector=3;
         }        
-        return iVector_;
+        return iVector;
   } 
   // CapabiliTileProviderFactory::CapabiliTileProviderFactory()
   // {

@@ -82,8 +82,8 @@ namespace DmpWmts
     }
     else if (boost::iequals(req, "GetCapabilities"))
     {
-      const std::string host_=context.request()->domain()+":"+context.request()->port();;
-      const std::string servicename_=context.request()->serviceName();
+      const std::string host=context.request()->domain()+":"+context.request()->port();;
+      const std::string servicename=context.request()->serviceName();
       
       boost::property_tree::ptree pt;
       pt.add("Layer.ows:Title",tileLayer->title());
@@ -100,18 +100,18 @@ namespace DmpWmts
       {
         pt.add("Layer.TileMatrixSetLink.TileMatrixSet",(*iter)->id());
         
-        boost::property_tree::ptree ptLevels_;
-        std::vector<TileLevel*> tileLevels_=(*iter)->tileLevels();
-        for(auto leviter=tileLevels_.cbegin();leviter!=tileLevels_.cend();leviter++)
+        boost::property_tree::ptree ptLevels;
+        std::vector<TileLevel*> tileLevels=(*iter)->tileLevels();
+        for(auto leviter=tileLevels.cbegin();leviter!=tileLevels.cend();leviter++)
         {
-          boost::property_tree::ptree pt_level_;
+          boost::property_tree::ptree pt_level;
         
-          pt_level_.add("level",(*leviter)->id);
-          pt_level_.add("scale",(*leviter)->scaleDenominator);
-          pt_level_.add("resolution",(*leviter)->resolution);
-          ptLevels_.add_child("TileMatrix",pt_level_);
+          pt_level.add("level",(*leviter)->id);
+          pt_level.add("scale",(*leviter)->scaleDenominator);
+          pt_level.add("resolution",(*leviter)->resolution);
+          ptLevels.add_child("TileMatrix",pt_level);
         }
-        pt.add_child("TileMatrixSet.Levels",ptLevels_); 
+        pt.add_child("TileMatrixSet.Levels",ptLevels); 
         pt.add("TileMatrixSet.ows:Identifier",(*iter)->id());
         pt.add("TileMatrixSet.ows:SupportedCRS",(*iter)->crs());
         pt.add("TileMatrixSet.TileWidth",(*iter)->tileCols());
@@ -122,7 +122,7 @@ namespace DmpWmts
       //boost::property_tree::write_json("/mnt/d/json.txt",pt);
 
       DmpCapabiliTilesOperation capOper;
-      capOper.WriteCapabilities(pt,host_,servicename_,*context.response());
+      capOper.WriteCapabilities(pt,host,servicename,*context.response());
 
     }
   }