#include "MLMicroStructure.h"
#include "MLPline.h"
#include "GMLDimsIter.h"
#include "MLFuncom.h"

#include <QFile>
#include <QThread>
#include <QFuture>
#include <QtConcurrent>
#include <QPolygonF>
#include <QTimer>
#include <QDate> 

namespace geos
{
	namespace geom
	{
		class GeometryFactory;
		class Geometry;
		class CoordinateSequence;
		namespace prep
		{
			class PreparedGeometry;
		};
	}
};

class QwtDotsCommand
{
public:
	const MLPlineList* series;
	int from;
	int to;

	double offsetDis;
	double redundant;
	double closeDis;
	double minAngle;
	double minRadius;
	bool  outCircle;
};

#include <geos/geom.h>
#include <geos/operation/buffer/BufferParameters.h>
#include <geos/operation/buffer/BufferBuilder.h>
#include <geos/algorithm/MinimumDiameter.h>
#include <geos/operation/distance/IndexedFacetDistance.h>
#include <geos/algorithm/construct/MaximumInscribedCircle.h>
#include <geos/algorithm/MinimumBoundingCircle.h>

// geos
#include <capi/geos_c.h>

using namespace geos::geom;
using namespace geos::io;

// 得到曲内网格平均值
double getGridPolygonValue(MLPline* polyline, GMLDimsIter* pDimsIter, double* minValue = nullptr, double* maxValue = nullptr);

double getGridPolylineValue(MLPline* polyline, GMLDimsIter* grid, double* minValue = nullptr, double* maxValue = nullptr);

// 删除圈闭内的线
void deleteInsidePline(MLPlineList* pPlineList);

// 删除圈闭内的线
void deleteInsidePline(MLPlineList& plineList);


// 删除圈闭内的线,使用曲线面积法，
void deleteInsidePlineArea(MLPlineList& plineList);


void deleteInsideSubPline(MLPlineList& plineList);

void sortContourPlineArea(MLPlineList& plineList);

//排列判断
bool compareDataArea(MLPline* pPline1, MLPline* pPline2)
{
	double value1 = pPline1->getArea();
	double value2 = pPline2->getArea();

	if (value1 > value2)
	{
		return true;
	}
	return false;
}

void deleteInsidePlineArea(MLPlineList& plineList)
{
	// 大在前，小在后
	sortContourPlineArea(plineList);

	int num = plineList.getCount();
	for (int i = 0; i < plineList.getCount(); i++)
	{
		MLPline* pContour1 = plineList.getPline(i);
		if (pContour1 == nullptr)
			continue;

		pContour1->resetBox();
		pContour1->calculateBox();
	}

	deleteInsideSubPline(plineList);
}

int LinePolyline(MLPlNode& data1, MLPlNode& data2, MLPline* curve, MLPlNode& data, bool bExtend);

// 取折线两个节点之间的线
MLPline getPolyline(const MLPoint& pt1, const MLPoint& pt2, const MLPline& polyline);

MLPlineList* getOffsetPline(QwtDotsCommand command);

// 合并多边形
void combinaPolygon(QList<QPolygonF*>& PolygonList);

// 检测两个多边形是否相交
bool checkPolygonCross(const QPolygonF& polygon1, const QPolygonF& polygon2);

// 检测两个多边形是否相交,并返回相交多边形
bool checkPolygonCross(const QPolygonF& polygon1, const QPolygonF& polygon2, QPolygonF& polygonDes);

// 删除相交的多边形(因为凹多边形与凸多边形有叠合)
void deletePolygon(QList<QPolygonF*>& PolygonList);

// 删除相交的多边形(因为凹多边形与凸多边形有叠合)
void deletePolygon(QList<QPolygonF*>& PolygonList1, QList<QPolygonF*>& PolygonList2, double unitSacle);

QPointF getCentroid(const QPolygonF& polygon);

// 计算QT多边形面积
double calculateArea(const QPolygonF& polygon);

MLPline* getOffsetPl(MLPline* pPolyline, double dDistance);

void GetBezierData(int bIsClose, double sd, MLPline& OrgPline, MLPline& NewPline);


//得到第一条折线切第二条折线,得到距离点保存在xy中
int  GetCrossPt(MLPline &c1, MLPline &c2, QVector<MLPlNode> &xy, bool bAddTailPt = false);

int getCurve(double l1, double l2, QVector<MLPlNode> &dp, MLPline& dPline, int bDoubleHeadTail = 1, bool bNoLineValue = false);


// 非过点光滑
//     1、bClose为真，封闭式光滑
//     2、起止点重合，封闭式光滑
//     3、否则，开放式光滑
void smoothPoints(MLPline& destPline, const MLPline& srcPline, int nInsertPts, bool bClose)
{
	destPline.removeAll();

	int ii, nCnt = srcPline.getCount();
	if (nCnt <= 2)
	{
		for (ii = 0; ii < nCnt; ii++)
			destPline.addTailPt(srcPline.getAtPt(ii));
		return;
	}

	MLPlNode dptSta(srcPline.getHeadPt());
	MLPlNode dptEnd(srcPline.getTailPt());

	MLPointAry arrSourPt;
	arrSourPt.clear();

	bool bEqual = (dptSta == dptEnd);
	if (bClose || bEqual) // 封闭式光滑
	{
		arrSourPt.append(dptSta);

		for (ii = 1; ii < nCnt - 1; ii++)
			arrSourPt.append(srcPline.getAtPt(ii));

		if (!bEqual)
			arrSourPt.append(dptEnd);
		arrSourPt.append(dptSta);

		for (ii = 1; ii < 4; ii++)
		{
			int jj = ii % nCnt;
			arrSourPt.append(srcPline.getAtPt(ii));
		}
	}
	else // 开放式光滑
	{
		arrSourPt.append(dptSta);
		arrSourPt.append(dptSta);
		arrSourPt.append(dptSta);

		for (ii = 1; ii < nCnt - 1; ii++)
			arrSourPt.append(srcPline.getAtPt(ii));

		arrSourPt.append(dptEnd);
		arrSourPt.append(dptEnd);
		arrSourPt.append(dptEnd);
	}

	MLPoint dptTmp, dpt[4];
	double A[4], B[4], t1, t2, t3;

	nCnt = (int)arrSourPt.count();
	for (int ii = 0; ii < nCnt - 3; ii++)
	{
		for (int jj = 0; jj < 4; jj++)
			dpt[jj] = arrSourPt.at(ii + jj);

		A[0] = (dpt[0].x + 4.0 * dpt[1].x + dpt[2].x) / 6.0;
		A[1] = -(dpt[0].x - dpt[2].x) / 2.0;
		A[2] = (dpt[0].x - 2.0 * dpt[1].x + dpt[2].x) / 2.0;
		A[3] = -(dpt[0].x - 3.0 * dpt[1].x + 3.0 * dpt[2].x - dpt[3].x) / 6.0;

		B[0] = (dpt[0].y + 4.0 * dpt[1].y + dpt[2].y) / 6.0;
		B[1] = -(dpt[0].y - dpt[2].y) / 2.0;
		B[2] = (dpt[0].y - 2.0 * dpt[1].y + dpt[2].y) / 2.0;
		B[3] = -(dpt[0].y - 3.0 * dpt[1].y + 3.0 * dpt[2].y - dpt[3].y) / 6.0;

		for (int kk = 0; kk <= nInsertPts; kk++)
		{
			t1 = (double)kk / (double)(nInsertPts + 1);
			t2 = t1 * t1;
			t3 = t2 * t1;
			dptTmp.x = A[0] + A[1] * t1 + A[2] * t2 + A[3] * t3;
			dptTmp.y = B[0] + B[1] * t1 + B[2] * t2 + B[3] * t3;
			destPline.addTailPt(dptTmp);

			if (ii == nCnt - 4 && (bClose || bEqual))
				break;
		}
	}
}


bool PtAtPolyline(const MLPoint& point, const MLPline& polyline)
{
	for (int i = 0; i < polyline.getCount(); i++)
	{
		if (fabs(point.x - polyline[i].x) < 0.01 &&
			fabs(point.y - polyline[i].y) < 0.01)
		{
			return true;
		}

		if (i > 0)
		{
			MLPoint pt1 = polyline.getAtPt(i - 1);
			MLPoint pt2 = polyline.getAtPt(i);

			double dis = GetDistance(pt1, pt2);
			double dis1 = GetDistance(pt1, point);
			double dis2 = GetDistance(point, pt2);

			// 
			if (fabs(dis - (dis1 + dis2)) <= 0.01)
			{
				return true;
			}
		}
	}

	return false;
}
// 重新计算面积、幅度差、长轴，短轴；

void calPolygonInfo(MLPlineList& plineList, GMLDimsIter* grid,	const QString&	name, double dRadiusScale,double minDepth, double maxDepth)
{
	MLPlineList plineListTmp;
	// 临时存储线
	for (int i = 0; i < plineList.getCount(); i++)
	{
		MLPline* pPline = plineList.getPline(i);
		MLPline* pNewPline = pPline->clone();
		pNewPline->calculateLength();
		plineListTmp.addPline(pNewPline);
	}

	plineList.clearPline();

	geos::geom::PrecisionModel pm(1e+10);
	geos::geom::GeometryFactory::Ptr geometryFactory = geos::geom::GeometryFactory::create(&pm);

	// 凸闭合圈闭
	for (int i = 0; i < plineListTmp.getCount(); i++)
	{
		MLPline* pPline = plineListTmp.getPline(i);

		// 两个点不进行计算
		if (pPline->getCount() <= 2)
			continue;

		// 计算面积
		pPline->calculateArea();
		double area = pPline->getArea();

		// 面积太小，过滤
		if (area <= 1)
			continue;

		// 面积除
		area /= 1000;

		// 幅度差
		double minValue = 0; double maxValue = 0;
		getGridPolygonValue(pPline, grid, &minValue, &maxValue);
		double deltValue = (maxValue - minValue);

		// 过滤幅度差
		if (deltValue < minDepth || deltValue > maxDepth)
			continue;   

		// 长轴
		geos::geom::CoordinateArraySequence sequence;
		for (int j = 0; j < pPline->getCount(); j++)
		{
			sequence.add(Coordinate(pPline->getAtPt(j).x, pPline->getAtPt(j).y));
		}

		if (pPline->getHeadPt() != pPline->getTailPt())
		{
			sequence.add(Coordinate(pPline->getAtPt(0).x, pPline->getAtPt(0).y));
		}

		geos::geom::LinearRing* pLineString = geometryFactory->createLinearRing(sequence);

		// 半径
		geos::algorithm::MinimumBoundingCircle mbc(pLineString);
		double actualRadius1 = mbc.getRadius() * 2;
		geos::geom::Coordinate actualCentre = mbc.getCentre();

		// 短轴
		geos::geom::Polygon* pPolygon = geometryFactory->createPolygon(pLineString, nullptr);
		double tolerance = 0.01;
		geos::algorithm::construct::MaximumInscribedCircle mic(pPolygon, tolerance);

		// 半径
		std::unique_ptr<LineString> radiusLine = mic.getRadiusLine();
		double actualRadius2 = radiusLine->getLength() * 2;

		// 过滤比较细长的圈闭
		if (actualRadius2 > 0.000001)
		{
			// 长短轴的比大于10，进行删除
			double scale = actualRadius1 / actualRadius2;
			if (scale > dRadiusScale)
			{
				continue;
			}
		}

		QString sName = QString("%1=%2,%3,%4,%5,%6")
			.arg(name)
			.arg(i)
			.arg(area, 0, 'f', 6)
			.arg(deltValue, 0, 'f', 2)
			.arg(actualRadius1, 0, 'f', 2)
			.arg(actualRadius2, 0, 'f', 2);

		pPline->setName(sName.toLocal8Bit().data());
		MLPline* pNewPline = pPline->clone();
		plineList.addPline(pNewPline);

		geometryFactory->destroyGeometry(pLineString); 
	}
}

MLMicroStructure::MLMicroStructure()
{
	m_dimsIter = new GMLDimsIter;

	m_minArea = 1000;
	m_limitNum = 4;
	m_bFaultFilter = true;
	m_faultCloseDis = 100;

	m_bCloseShape = true;
	m_closeDis = 50;

	m_bFaultShape = true;
	m_extendDis = 200;

	m_bNoseShape = true;
	m_offsetDis = 250;
	m_minAngle = 140;
	m_redundant = 0.6;
	m_radius = 800;

	m_smooth = false;
	m_zoomin = 10;
	m_unitSacle = 0.7;
	
	m_minDepth = 0;
	m_maxDepth = 100;
}

void MLMicroStructure::setContourList(const MLPlineList& contourList)
{
	m_contourList.clearPline();

	for (int i = 0; i < contourList.getCount(); i++)
	{
		MLPline* pPline = contourList.getPline(i);
		m_contourList.addPline(pPline->clone());
	}
}

void MLMicroStructure::setFaultList(const MLPlineList& faultList)
{
	m_faultList.clearPline();

	for (int i = 0; i < faultList.getCount(); i++)
	{
		MLPline* pPline = faultList.getPline(i);
		m_faultList.addPline(pPline->clone());
	}
}

void MLMicroStructure::setGridInfo(double* xyRange, int* nxny, double* inc, double*zRange)
{
	m_dimsIter->setGridInfo(xyRange, nxny, inc, zRange);
}

void MLMicroStructure::setZData(long num, float* data)
{
	m_dimsIter->setZData(num, data);
}

bool MLMicroStructure::run()
{
	// 过滤最小面积
	double minArea = m_minArea;
	int limitNum = m_limitNum;

	// 删除断层内部
	bool bFaultFilter = m_bFaultFilter;
	double faultCloseDis = m_faultCloseDis;

	// 闭合圈闭
	bool  bCloseShape = m_bCloseShape; 
	double closeDis = m_closeDis;

	// 断层圈闭
	bool bFaultShape = m_bFaultShape;
	double extendDis = m_extendDis;

	// 鼻状
	bool bNoseShape = m_bNoseShape;
	double offsetDis = m_offsetDis;
	double minAngle = m_minAngle;
	double redundant = m_redundant;
	double minRadius = m_radius;
	bool smooth = m_smooth;
	double zoomin = m_zoomin;	// 放大系数
	double unitSacle = m_unitSacle;

	bool outCircle = m_bOutCircle;
	double dRadiusScale = m_dRadiusScale;
	
	double minDepth = m_minDepth;
	double maxDepth = m_maxDepth;

	// 判断文件是否存在
	if (m_faultList.getCount() <=0)
	{
		//QMessageBox::warning(this, "error", "open fault polygon file failed");
		//return false;
	}

	if (m_contourList.getCount() <=0)
	{
		//QMessageBox::warning(this, "error", "open contour file failed");
		return false;
	}

	bool bReadGrid = true;
	if (m_dimsIter->getXnYnTotal() <=0)
	{
		//QMessageBox::warning(this, "error", "open grid file failed");
		bReadGrid = false;
	}

	// 使用面积和节点过滤等值线
	int num = m_contourList.getCount();
	for (int i = m_contourList.getCount() - 1; i >= 0; i--)
	{
		MLPline* pPline = m_contourList.getPline(i);
		double area = pPline->getArea();
		if (area < minArea)
		{
			m_contourList.removePline(pPline);
			delete pPline;
			pPline = nullptr;
			continue;
		}
		// 小于4个点
		if (pPline->getCount() < limitNum)
		{
			m_contourList.removePline(pPline);
			delete pPline;
			pPline = nullptr;
			continue;
		}

		pPline->redundant();
	}

	// 删除断层多边形内部等值线
	if (bFaultFilter)
	{
		num = m_faultList.getCount();
		for (int i = 0; i < m_faultList.getCount(); i++)
		{
			MLPline* pFault = (MLPline*)m_faultList.getPline(i);
			pFault->calculateBox();

			if (pFault->getHeadTailDistance() > faultCloseDis)
			{
				continue;
			}

			for (int j = m_contourList.getCount() - 1; j >= 0; j--)
			{
				MLPline* pPline = m_contourList.getPline(j);
				pPline->calculateBox();

				// 不相交
				if (!CrossRtRt(pPline->getBox(), pFault->getBox()))
				{
					continue;
				}

				int notes = pPline->getCount();
				int cenpt = int(notes / 2);
				if (pFault->contains(pPline->getAtPt(cenpt)))
				{
					m_contourList.removePline(pPline);
					delete pPline;
					pPline = nullptr;
				}
			}
		}
	}

	// 闭合圈闭 ***********************************************************************
	MLPlineList  closeObjAry;
	if (bCloseShape && m_contourList.getCount() > 0)
	{
		for (int i = m_contourList.getCount() - 1; i >= 0; i--)
		{
			MLPline* pPline = m_contourList.getPline(i);

			// 首尾距离判断闭合圈闭
			double dis = pPline->getHeadTailDistance();
			if (dis <= closeDis)
			{
				closeObjAry.addPline(pPline);
				m_contourList.removePline(pPline);
			}
		}

		// 清空闭合圈闭内部线
		//deleteInsidePline(closeObjAry);
		deleteInsidePlineArea(closeObjAry);

		m_closeObjPosiAry.clearPline();
		m_closeObjNegaAry.clearPline();

		// 根据网格判断是否高还是低
		if (bReadGrid)
		{
			for (int i = 0; i < closeObjAry.getCount(); i++)
			{
				MLPline* closePline = closeObjAry.getPline(i);
				double dPlValue = atof(closePline->getName());
				double dAveValue = getGridPolygonValue(closePline, m_dimsIter);

				if (dPlValue > 0)
				{
					if (dAveValue <= dPlValue)
						m_closeObjPosiAry.addPline(closePline->clone());
					else
						m_closeObjNegaAry.addPline(closePline->clone());
				}
				else
				{
					if (dAveValue <= dPlValue)
						m_closeObjNegaAry.addPline(closePline->clone());
					else
						m_closeObjPosiAry.addPline(closePline->clone());
				}
			}
		}
	}

	num = m_contourList.getCount();
	
	// 断层圈闭*************************************************************
	MLPlineList  faultObjAry;
	if (bFaultShape && m_faultList.getCount() > 0)
	{
		for (int i = num - 1; i >= 0; i--)
		{
			MLPline* pContour = m_contourList.getPline(i);
			pContour->calculateBox();

			int index1 = -1;
			int index2 = -1;
			bool bFirst1 = true;
			bool bFirst2 = true;
			double distan1 = 0.0;
			double distan2 = 0.0;
			MLPlNode CrossPt1, CrossPt2;

			// 等值线开头两个点
			MLPlNode pt11 = pContour->getAtPt(0);
			MLPlNode pt12 = pContour->getAtPt(1);

			// 等值线结尾两个点
			MLPlNode pt21 = pContour->getAtPt(pContour->getCount() - 1);
			MLPlNode pt22 = pContour->getAtPt(pContour->getCount() - 2);

			for (int j = 0; j < m_faultList.getCount(); j++)
			{
				MLPline* pFault = (MLPline*)m_faultList.getPline(j);
				pFault->calculateBox();

				// 不相交
				if (!CrossRtRt(pContour->getBox(), pFault->getBox()))
				{
					continue;
				}

				MLPlNode crossPt;

				// 记录等值线头与断层相交
				if (LinePolyline(pt12, pt11, pFault, crossPt, true))
				{
					double dis1 = GetDistance(pt11.x, pt11.y, crossPt.x, crossPt.y);
					double dis2 = GetDistance(pt12.x, pt12.y, crossPt.x, crossPt.y);
					double dis = dis1; if (dis > dis2) dis = dis2;
					if (dis < extendDis)
					{
						if (bFirst1)
						{
							distan1 = dis;
							CrossPt1 = crossPt;
							index1 = j;
							bFirst1 = false;
						}
						else if (dis < distan1)
						{
							distan1 = dis1;
							CrossPt1 = crossPt;
							index1 = j;
						}
					}
				}
				// 记录等值线尾与断层相交
				if (LinePolyline(pt22, pt21, pFault, crossPt, true))
				{
					double dis1 = GetDistance(pt22.x, pt22.y, crossPt.x, crossPt.y);
					double dis2 = GetDistance(pt21.x, pt21.y, crossPt.x, crossPt.y);
					double dis = dis1; if (dis > dis2) dis = dis2;

					if (dis < extendDis)
					{
						if (bFirst2)
						{
							distan2 = dis;
							CrossPt2 = crossPt;
							index2 = j;
							bFirst2 = false;
						}
						else if (dis < distan2)
						{
							distan2 = dis;
							CrossPt2 = crossPt;
							index2 = j;
						}
					}
				}
			}

			// 判断为同一条断层
			if (index1 == index2 && index1 != -1)
			{
				MLPline* pFaultPline = (MLPline*)m_faultList.getPline(index1);
				
				// 取断层线两个节点之间的线
				MLPline faultPolyline = getPolyline(CrossPt1, CrossPt2, *pFaultPline);

				// 向等值线添加断层线
				if (!faultPolyline.isEmpty())
				{
					for (int k = faultPolyline.getCount() - 1; k >= 0; k--)
					{
						pContour->addTailPt(faultPolyline[k]);
					}
					// 面积过滤
					pContour->calculateArea();
					if (pContour->getArea() < minArea)
					{
						continue;
					}
					faultObjAry.addPline(pContour);
					m_contourList.removePline(pContour);
				}
			}
		}

		// 清空内部线
		//deleteInsidePline(faultObjAry);
		deleteInsidePlineArea(faultObjAry);

		m_faultObjPosiAry.clearPline();
		m_faultObjNegaAry.clearPline();

		if (bReadGrid)
		{
			for (int i = 0; i < faultObjAry.getCount(); i++)
			{
				MLPline* faultPline = faultObjAry.getPline(i);
				double dPlValue = atof(faultPline->getName());
				double dAveValue = getGridPolygonValue(faultPline, m_dimsIter);

				if (dPlValue > 0)
				{
					if (dAveValue <= dPlValue)
						m_faultObjPosiAry.addPline(faultPline->clone());
					else
						m_faultObjNegaAry.addPline(faultPline->clone());
				}
				else
				{
					if (dAveValue <= dPlValue)
						m_faultObjNegaAry.addPline(faultPline->clone());
					else
						m_faultObjPosiAry.addPline(faultPline->clone());
				}
			}
		}
	}

	// 鼻状圈闭***********************************************************************
	MLPlineList  noseObjAry;
	m_noseObjPosiAry.clearPline();
	m_noseObjNegaAry.clearPline();
	int mothed = 1;
	if (bNoseShape)
	{

		uint numThreads = QThread::idealThreadCount();
		int to = m_contourList.getCount() - 1;
		int from = 0;
		const int numPoints = (to - from + 1) / numThreads;
		QwtDotsCommand command;
		command.series = &m_contourList;
		command.offsetDis = offsetDis;
		command.closeDis = closeDis;
		command.minAngle = minAngle;
		command.redundant = redundant;
		command.minRadius = minRadius;
		command.outCircle = outCircle;
		initGEOS(0, 0);

		QList< QFuture<MLPlineList*> > futures;
		//// 测试
		//command.from = 0;
		//command.to = 10;
		//getOffsetPline(command);
		
		for (uint i = 0; i < numThreads; i++)
		{
			const int index0 = from + i * numPoints;
			if (i == numThreads - 1)
			{
				command.from = index0;
				command.to = to;
				futures += QtConcurrent::run(&getOffsetPline, command);
			}
			else
			{
				command.from = index0;
				command.to = index0 + numPoints - 1;
				futures += QtConcurrent::run(&getOffsetPline, command);
			}
		}
		for (int i = 0; i < futures.size(); i++)
			futures[i].waitForFinished();
			
		// 并行结果
		for (int i = 0; i < futures.size(); i++)
		{
			MLPlineList* pPlineList = futures[i].result();
			for (int j = 0; j < pPlineList->getCount(); j++)
			{
				noseObjAry.addPline(pPlineList->getPline(j));
			}
		}

		if (bReadGrid)
		{
			// 利用均值判断，是鼻是沟；
			for (int i = 0; i < noseObjAry.getCount(); i++)
			{
				MLPline* nosePline = noseObjAry.getPline(i);
				double dPlValue  = getGridPolylineValue(nosePline, m_dimsIter);
				double dAveValue = getGridPolygonValue(nosePline, m_dimsIter);

				if (dPlValue > 0)
				{
					if (dAveValue <= dPlValue)
						m_noseObjPosiAry.addPline(nosePline->clone());
					else
						m_noseObjNegaAry.addPline(nosePline->clone());
				}
				else
				{
					if (dAveValue <= dPlValue)
						m_noseObjNegaAry.addPline(nosePline->clone());
					else
						m_noseObjPosiAry.addPline(nosePline->clone());
				}
			}

			// 创建QT多边形
			QList<QPolygonF*> posiPolygonList;
			for (int i = 0; i < m_noseObjPosiAry.getCount(); i++)
			{
				MLPline* nosePline = m_noseObjPosiAry.getPline(i);
				posiPolygonList.append(new QPolygonF(nosePline->toQPolygonF()));
			}

			QList<QPolygonF*> negaPolygonList;
			for (int i = 0; i < m_noseObjNegaAry.getCount(); i++)
			{
				MLPline* nosePline = m_noseObjNegaAry.getPline(i);
				negaPolygonList.append(new QPolygonF(nosePline->toQPolygonF()));
			}

			// 合并多边形
			combinaPolygon(posiPolygonList);
				
			// 合并多边形
			combinaPolygon(negaPolygonList);

			m_noseObjPosiAry.clearPline();
			m_noseObjNegaAry.clearPline();

			// 用做删除处理
			QList<QPolygonF*> posiPolygonList2;
			QList<QPolygonF*> negaPolygonList2;

			geos::geom::PrecisionModel pm(1e+10);
			geos::geom::GeometryFactory::Ptr geometryFactory = geos::geom::GeometryFactory::create(&pm);

			// 求取最大多凸多边形
			for (int i = 0; i < posiPolygonList.count(); i++)
			{
				geos::geom::CoordinateArraySequence sequence;
				QPolygonF* pPolygonF = posiPolygonList[i];
				for (int j = 0; j < pPolygonF->count(); j++)
					sequence.add(Coordinate(pPolygonF->at(j).x(), pPolygonF->at(j).y()));

				LineString* pLineString = geometryFactory->createLineString(sequence);
				std::unique_ptr<Geometry> geom_convexHull = pLineString->convexHull();
				geos::geom::Polygon* geom_ = dynamic_cast<geos::geom::Polygon*> (geom_convexHull.get());
				if (geom_ && !geom_->isEmpty())
				{
					MLPline templine;
					for (int k = 0; k < geom_->getNumPoints(); k++)
					{
						templine.addTailPt(geom_->getCoordinates()->getX(k), geom_->getCoordinates()->getY(k));
					}

					// 光滑
					MLPline smoothPline;
					if (smooth)
					{
						smoothPoints(smoothPline, templine, templine.getCount() / 2, true);
						templine.copyPt(smoothPline);
					}
					// 偏移
					if (zoomin > 0)
					{
						// 格式转换
						geos::geom::CoordinateArraySequence sequence;
						for (int k = 0; k < templine.getCount(); k++)
						{
							MLPlNode node = templine.getAtPt(k);
							sequence.add(geos::geom::Coordinate(node.x, node.y));
						}
						sequence.add(geos::geom::Coordinate(templine.getHeadPt().x, templine.getHeadPt().y));
						// 创建多边形
						geos::geom::LinearRing* pLinearRing = geometryFactory->createLinearRing(sequence);
						geos::geom::Polygon* pPolygon = geometryFactory->createPolygon(pLinearRing, nullptr);

						std::unique_ptr<Geometry> buf = pPolygon->buffer(zoomin);

						if (!buf->isEmpty())
						{
							templine.removeAll();
							// 格式转换
							geos::geom::Polygon* pPolygonBuf = dynamic_cast<geos::geom::Polygon*> (buf.get());

							const geos::geom::LineString* pLineaBuf = pPolygonBuf->getExteriorRing();
							for (int i = 0; i < pLineaBuf->getNumPoints(); i++)
							{
								MLPoint dpt(pLineaBuf->getCoordinates()->getX(i), pLineaBuf->getCoordinates()->getY(i));
								templine.addTailPt(dpt);
							}
						}
						geometryFactory->destroyGeometry(pPolygon);
					}

					m_noseObjPosiAry.addPline(templine.clone());
					// 创建新的QPolygon
					QPolygonF* pNewPolygon = new QPolygonF;
					templine.toQPolygonF(*pNewPolygon);
					posiPolygonList2.push_back(pNewPolygon);

				}
				geometryFactory->destroyGeometry(pLineString);
			}
				
			// 求取最大多凹多边形
			for (int i = 0; i < negaPolygonList.count(); i++)
			{
				geos::geom::CoordinateArraySequence sequence;
				QPolygonF* pPolygonF = negaPolygonList[i];
				for (int j = 0; j < pPolygonF->count(); j++)
				{
					sequence.add(Coordinate(pPolygonF->at(j).x(), pPolygonF->at(j).y()));
				}

				LineString* pLineString = geometryFactory->createLineString(sequence);
				std::unique_ptr<Geometry> geom_convexHull = pLineString->convexHull();
				geos::geom::Polygon* geom_ = dynamic_cast<geos::geom::Polygon*> (geom_convexHull.get());
				if (geom_ && !geom_->isEmpty())
				{
					MLPline templine;
					for (int k = 0; k < geom_->getNumPoints(); k++)
					{
						templine.addTailPt(geom_->getCoordinates()->getX(k), geom_->getCoordinates()->getY(k));
					}

					// 光滑
					MLPline smoothPline;
					if (smooth)
					{
						smoothPoints(smoothPline, templine, templine.getCount() / 2, true);
						templine.copyPt(smoothPline);
					}

					// 偏移
					if (zoomin > 0)
					{
						// 格式转换
						geos::geom::CoordinateArraySequence sequence;
						for (int k = 0; k < templine.getCount(); k++)
						{
							MLPlNode node = templine.getAtPt(k);
							sequence.add(geos::geom::Coordinate(node.x, node.y));
						}
						sequence.add(geos::geom::Coordinate(templine.getHeadPt().x, templine.getHeadPt().y));
						// 创建多边形
						geos::geom::LinearRing* pLinearRing = geometryFactory->createLinearRing(sequence);
						geos::geom::Polygon* pPolygon = geometryFactory->createPolygon(pLinearRing, nullptr);

						std::unique_ptr<Geometry> buf = pPolygon->buffer(zoomin);

						if (!buf->isEmpty())
						{
							templine.removeAll();
							// 格式转换
							geos::geom::Polygon* pPolygonBuf = dynamic_cast<geos::geom::Polygon*> (buf.get());

							const geos::geom::LineString* pLineaBuf = pPolygonBuf->getExteriorRing();
							for (int i = 0; i < pLineaBuf->getNumPoints(); i++)
							{
								MLPoint dpt(pLineaBuf->getCoordinates()->getX(i), pLineaBuf->getCoordinates()->getY(i));
								templine.addTailPt(dpt);
							}
						}
						geometryFactory->destroyGeometry(pPolygon);
					}

					m_noseObjNegaAry.addPline(templine.clone());

					// 创建新的QPolygon
					QPolygonF* pNewPolygon = new QPolygonF;
					templine.toQPolygonF(*pNewPolygon);
					negaPolygonList2.push_back(pNewPolygon);

				}
				geometryFactory->destroyGeometry(pLineString);

				//noseObjNegaAry.addPline(new MLPline(*negaPolygonList[i]));
			}
				
			// 删除凸起和凹陷相交的多边形
			deletePolygon(posiPolygonList2, negaPolygonList2, unitSacle);

			// 删除原有的
			m_noseObjPosiAry.clearPline();
			m_noseObjNegaAry.clearPline();

			if (!posiPolygonList2.isEmpty())
			{
				for (int i = 0; i < posiPolygonList2.count(); i++)
				{
					QPolygonF* pPolygon = posiPolygonList2.at(i);
					MLPline* pPline = new MLPline(*pPolygon);
					pPline->calculateArea();
					m_noseObjPosiAry.addPline(pPline);
				}
			}

			if (!negaPolygonList2.isEmpty())
			{
				for (int i = 0; i < negaPolygonList2.count(); i++)
				{
					QPolygonF* pPolygon = negaPolygonList2.at(i);
					MLPline* pPline = new MLPline(*pPolygon);
					pPline->calculateArea();
					m_noseObjNegaAry.addPline(pPline);
				}
			}


			// delete Qt 多边形
			for (int i = 0; i < posiPolygonList.count(); i++)
				delete posiPolygonList[i];

			for (int i = 0; i < negaPolygonList.count(); i++)
				delete negaPolygonList[i];

			// delete 
			for (int i = 0; i < posiPolygonList2.count(); i++)
				delete posiPolygonList2[i];

			for (int i = 0; i < negaPolygonList2.count(); i++)
				delete negaPolygonList2[i];
		}		
	}

	// 重新计算面积、幅度差、长轴，短轴；
	if (bCloseShape)
	{
		// 凸闭合圈闭
		calPolygonInfo(m_closeObjPosiAry, m_dimsIter, "cp", dRadiusScale, minDepth, maxDepth);

		// 凹闭合圈闭
		calPolygonInfo(m_closeObjNegaAry, m_dimsIter, "cn", dRadiusScale, minDepth, maxDepth);
	}

	if (bFaultShape)
	{
		// 凸断层圈闭
		calPolygonInfo(m_faultObjPosiAry, m_dimsIter, "fp", dRadiusScale, minDepth, maxDepth);

		// 凹断层圈闭
		calPolygonInfo(m_faultObjNegaAry, m_dimsIter, "fn", dRadiusScale, minDepth, maxDepth);
	}

	if (bNoseShape)
	{
		// 凸鼻状圈闭
		calPolygonInfo(m_noseObjPosiAry, m_dimsIter, "np", dRadiusScale, minDepth, maxDepth);

		// 凹鼻状圈闭
		calPolygonInfo(m_noseObjNegaAry, m_dimsIter, "nn", dRadiusScale, minDepth, maxDepth);
	}


	// clear
	m_dimsIter->clearMemory();
	m_faultList.clearPline();
	m_contourList.clearPline();

	noseObjAry.clearPline();

	return true;
}


void MLMicroStructure::clearMemory()
{
	m_closeObjPosiAry.clearPline();
	m_closeObjNegaAry.clearPline();

	m_faultObjPosiAry.clearPline();
	m_faultObjNegaAry.clearPline();

	m_noseObjPosiAry.clearPline();
	m_noseObjNegaAry.clearPline();

	delete m_dimsIter;
}

/**/
int MLMicroStructure::readDfgBinary(const char* file)
{
	if (m_dimsIter)
	{
		m_dimsIter->readDfgBinary(file);
	}

	return 0;
}

//排列判断
bool compareBarData(MLPline* pPline1, MLPline* pPline2)
{
	double value1 = atof(pPline1->getName());
	double value2 = atof(pPline2->getName());

	value1 = fabs(value1);
	value2 = fabs(value2);

	if (value1 > value2)
	{
		return true;
	}
	return false;
}

//排列判断
bool compareBarData2(MLPline* pPline1, MLPline* pPline2)
{
	double value1 = atof(pPline1->getName());
	double value2 = atof(pPline2->getName());

	value1 = fabs(value1);
	value2 = fabs(value2);

	if (value1 < value2)
	{
		return true;
	}
	return false;
}



void sortContourPline(MLPlineList* pPlineList)
{
	// 对等值线排序列
	qSort(pPlineList->m_PlineList.begin(), pPlineList->m_PlineList.end(), compareBarData);
}

void sortContourPline2(MLPlineList* pPlineList)
{
	// 对等值线排序列
	qSort(pPlineList->m_PlineList.begin(), pPlineList->m_PlineList.end(), compareBarData2);
}

void sortContourPlineArea(MLPlineList& plineList)
{
	// 对等值线排序列
	qSort(plineList.m_PlineList.begin(), plineList.m_PlineList.end(), compareDataArea);
}

// 检查是否在线上
bool onPolyline(const MLPoint& point, const MLPline& polyline)
{
	for (int i = 0; i < polyline.getCount(); i++)
	{
		if (fabs(point.x - polyline[i].x) < 0.01 &&
			fabs(point.y - polyline[i].y) < 0.01)
		{
			return true;
		}

		if (i > 0)
		{
			MLPoint pt1 = polyline.getAtPt(i - 1);
			MLPoint pt2 = polyline.getAtPt(i);

			double dis = GetDistance(pt1, pt2);
			double dis1 = GetDistance(pt1, point);
			double dis2 = GetDistance(point, pt2);

			// 
			if (fabs(dis - (dis1 + dis2)) <= 0.01)
			{
				return true;
			}
		}
	}

	return false;
}

// 检查是否包含子线，点在线上不算
bool containsPts(const MLPline& polyline, const MLPline& subPolyline)
{
	MLPline newPolyline = polyline;
	for (int i = 0; i < subPolyline.getCount(); i++)
	{
		MLPlNode node = subPolyline.getAtPt(i);
		if (onPolyline(node, newPolyline))
			continue;

		if (newPolyline.contains(node))
		{
			return true;
		}
	}

	return false;
}

// 得到曲内网格平均值
double getGridPolygonValue(MLPline* polyline, GMLDimsIter* pDimsIter, double* minValue, double* maxValue)
{
	double x1 = pDimsIter->getXYRange()[0];
	double x2 = pDimsIter->getXYRange()[1];
	double y1 = pDimsIter->getXYRange()[2];
	double y2 = pDimsIter->getXYRange()[3];

	int i, j, k;
	int num = 0;
	double zz = 0.0;
	double average = 0.0;
	int n = pDimsIter->getGridY();
	int m = pDimsIter->getGridX();

	double minV = 0;
	double maxV = 0;
	double firstV = true;

	MLRect dRt = polyline->calculateBox();

	int start_j = pDimsIter->getIndexFrY(dRt.bottom)-1;
	int end_j = pDimsIter->getIndexFrY(dRt.top)+1;
	if (start_j < 0) start_j = 0;
	if (end_j > pDimsIter->getGridY()) end_j = pDimsIter->getGridY();

	int start_i = pDimsIter->getIndexFrX(dRt.left)-1;
	int end_i = pDimsIter->getIndexFrX(dRt.right)+1;
	if (start_i < 0) start_i = 0;
	if (end_i > pDimsIter->getGridX()) end_i = pDimsIter->getGridX();


	for (j = start_j; j <end_j; ++j)
	{
		for (i = start_i; i < end_i; ++i)
		{
			k = i + m * j;
			double x = pDimsIter->getX(i);
			double y = pDimsIter->getY(j);
			double z = pDimsIter->getZValue(i, j);

			if (z < -99999999.0 ||
				z > 99999999.0)
				continue;

			//if (!dRect.contains(x, y))
			//	continue;

			if (polyline->contains(x, y))
			{
				zz += z;
				num++;

				if (firstV)
				{
					minV = z;
					maxV = z;
					firstV = false;
				}
				else
				{
					if (minV > z) minV = z;
					if (maxV < z) maxV = z;
				}
			}
		}
	}

	if (num > 0)
		average = zz / num;

	if (minValue)
	{
		*minValue = minV;
	}
	if (maxValue)
	{
		*maxValue = maxV;
	}


	return average;
}


double getGridPolylineValue(MLPline* polyline, GMLDimsIter* pDimsIter, double* minValue, double* maxValue)
{
	MLRect dRt = polyline->calculateBox();


	double minV = 0;
	double maxV = 0;
	double firstV = true;

	double plAverage = 0;
	double inAverage = 0;
	int num = 0;
	for (int i = 0; i < polyline->getCount(); i++)
	{
		MLPlNode node = polyline->getAtPt(i);
		double z = pDimsIter->getZValue(node.x, node.y);
		if (z < -99999999.0 ||
			z > 99999999.0)
			continue;

		plAverage += z;
		num++;	
		
		if (firstV)
		{
			minV = z;
			maxV = z;
			firstV = false;
		}
		else
		{
			if (minV > z) minV = z;
			if (maxV < z) maxV = z;
		}
	}

	if (num > 0)
		plAverage = plAverage / num;

	if (minValue)
	{
		*minValue = minV;
	}
	if (maxValue)
	{
		*maxValue = maxV;
	}

	return plAverage;
}

// 删除圈闭内的线
void deleteInsidePline(MLPlineList* pPlineList)
{
	// 按等值线值排序， 小在前，大在后
	sortContourPline2(pPlineList);

	MLPlineList delPlineList;

	int num = pPlineList->getCount();
	// 闭合圈闭正
	for (int i = pPlineList->getCount() - 1; i >= 0; i--)
	{
		MLPline* pContour1 = pPlineList->getPline(i);
		if (pContour1 == nullptr)
			continue;

		double value1 = atof(pContour1->getName());
		value1 = fabs(value1);

		for (int j = i - 1; j >= 0; j--)
		{
			MLPline* pContour2 = pPlineList->getPline(j);
			if (pContour2 == nullptr)
				continue;

			double value2 = atof(pContour2->getName());
			value2 = fabs(value2);

			if (value2 > value1)
				continue;

			if (Equ(value1, value2))
				continue;

			if (containsPts(*pContour1, *pContour2))
			{
				pPlineList->removePline(pContour2);
				delPlineList.addPline(pContour2);
			}
		}
	}

	// 大在前，小在后
	sortContourPline(pPlineList);
	num = pPlineList->getCount();
	// 闭合圈闭反
	for (int i = pPlineList->getCount() - 1; i >= 0; i--)
	{
		MLPline* pContour1 = pPlineList->getPline(i);
		if (pContour1 == nullptr)
			continue;

		double value1 = atof(pContour1->getName());
		value1 = fabs(value1);

		for (int j = i - 1; j >= 0; j--)
		{
			MLPline* pContour2 = pPlineList->getPline(j);
			if (pContour2 == nullptr)
				continue;

			double value2 = atof(pContour2->getName());
			value2 = fabs(value2);
			if (value2 < value1)
				continue;

			if (Equ(value1, value2))
				continue;

			if (containsPts(*pContour1, *pContour2))
			{
				pPlineList->removePline(pContour2);
				delPlineList.addPline(pContour2);
			}
		}
	}

	delPlineList.clearPline();
}


void deleteInsideSubPline(MLPlineList& plineList)
{
	
	for (int i = 0;i< plineList.getCount();i++)
	{
		MLPline* pContour1 = plineList.getPline(i);
		if (pContour1 == nullptr)
			continue;

		pContour1->calculateBox();

		bool isContaines = false;

		for (int j = i + 1; j <plineList.getCount(); j++)
		{
			MLPline* pContour2 = plineList.getPline(j);
			if (pContour2 == nullptr)
				continue;
			
			pContour2->calculateBox();

			// 不相交
			if (!CrossRtRt(pContour1->getBox(), pContour2->getBox()))
			{
				continue;
			}

			// 曲线1包含曲线2 
			if (containsPts(*pContour1, *pContour2))
			{
				plineList.removePline(pContour2);
				delete pContour2;

				isContaines = true;
			}

		}

		if (isContaines)
		{
			deleteInsideSubPline(plineList);
			goto exitt;
		}
	}
exitt:
	return;
}


void deleteInsidePline(MLPlineList& plineList)
{
	// 大在前，小在后
	sortContourPlineArea(plineList);
	int num = plineList.getCount();

	deleteInsideSubPline(plineList);
}

int LinePolyline(MLPlNode& data1, MLPlNode& data2, MLPline* curve, MLPlNode& data, bool bExtend)
{
	/*
	 * data2 为最近相交点
	 **/

	int nCount = 0;
	int num = curve->getCount();
	MLPlNode* pPtDest = new MLPlNode[num];
	int* pIdx = new int[num];

	double minx, maxx;
	double miny, maxy;
	bool first = true;
	for (int i = 0; i < num; i++)
	{
		if (first)
		{
			minx = curve->getAtPt(i).x;
			maxx = curve->getAtPt(i).x;
			miny = curve->getAtPt(i).y;
			maxy = curve->getAtPt(i).y;
			first = false;
		}
		else
		{
			if (minx > curve->getAtPt(i).x) minx = curve->getAtPt(i).x;
			if (maxx < curve->getAtPt(i).x) maxx = curve->getAtPt(i).x;
			if (miny > curve->getAtPt(i).y) miny = curve->getAtPt(i).y;
			if (maxy < curve->getAtPt(i).y) maxy = curve->getAtPt(i).y;
		}
	}

	int j = 0;
	for (int i = 1; i < num; i++)
	{
		double L2x1, L2y1, L2x2, L2y2;

		L2x1 = curve->getAtPt(i - 1).x;
		L2y1 = curve->getAtPt(i - 1).y;

		L2x2 = curve->getAtPt(i).x;
		L2y2 = curve->getAtPt(i).y;

		double dis1 = GetDistance(data2, curve->getAtPt(i - 1));
		double dis2 = GetDistance(data2, curve->getAtPt(i));
		double dis3 = GetDistance(curve->getAtPt(i - 1), curve->getAtPt(i));
		// 在线上
		if (fabs(dis3 - (dis1 + dis2)) < 0.01)
		{
			pPtDest[j].x = data2.x;
			pPtDest[j].y = data2.y;
			pIdx[j] = i;
			j++;
		}
		// 相交
		else if (LineLine(data1.x, data1.y, data2.x, data2.y, &L2x1, &L2y1, &L2x2, &L2y2))
		{
			pPtDest[j].x = L2x1;
			pPtDest[j].y = L2y1;
			pIdx[j] = i;
			j++;
		}
		else if (LineLine(data1.x, data1.y, data2.x, data2.y, &L2x1, &L2y1, &L2x2, &L2y2, bExtend))
		{
			double dis11 = GetDistance(data2, MLPlNode(L2x1, L2y1));
			double dis12 = GetDistance(data1, MLPlNode(L2x1, L2y1));
			// 如果离线近的点，离交点的距离反而远了。
			if (dis11 > dis12)
			{
				continue;
			}
			if (L2x1 >= minx && L2x1 <= maxx && L2y1 >= miny && L2y1 <= maxy)
			{
				pPtDest[j].x = L2x1;
				pPtDest[j].y = L2y1;
				pIdx[j] = i;
				j++;
			}
		}
	}

	if (j == 1)
	{
		data = pPtDest[0];
		int idx = pIdx[0];

		delete[] pPtDest;
		delete[] pIdx;

		double L2x1 = curve->getAtPt(idx - 1).x;
		double L2y1 = curve->getAtPt(idx - 1).y;

		double L2x2 = curve->getAtPt(idx).x;
		double L2y2 = curve->getAtPt(idx).y;

		if ((L2x1 < L2x2) && (L2x1 <= data.x && data.x <= L2x2))
			return 1;
		if ((L2x1 > L2x2) && (L2x2 <= data.x && data.x <= L2x1))
			return 1;
		if ((L2y1 < L2y2) && (L2y1 <= data.y && data.y <= L2y2))
			return 1;
		if ((L2y1 > L2y2) && (L2y2 <= data.y && data.y <= L2y1))
			return 1;

		return 0;
	}

	if (j > 1)
	{
		double dis = GetDistance(data2, pPtDest[0]);
		data = pPtDest[0];
		int idx = pIdx[0];

		for (int i = 1; i < j; i++)
		{
			double leng = GetDistance(data2, pPtDest[i]);
			if (leng < dis)
			{
				dis = leng;
				data = pPtDest[i];
				idx = pIdx[i];
			}
		}

		delete[] pPtDest;
		delete[] pIdx;

		double L2x1 = curve->getAtPt(idx - 1).x;
		double L2y1 = curve->getAtPt(idx - 1).y;

		double L2x2 = curve->getAtPt(idx).x;
		double L2y2 = curve->getAtPt(idx).y;

		if ((L2x1 < L2x2) && (L2x1 <= data.x && data.x <= L2x2))
			return 1;
		if ((L2x1 > L2x2) && (L2x2 <= data.x && data.x <= L2x1))
			return 1;
		if ((L2y1 < L2y2) && (L2y1 <= data.y && data.y <= L2y2))
			return 1;
		if ((L2y1 > L2y2) && (L2y2 <= data.y && data.y <= L2y1))
			return 1;

		return 0;
	}
	delete[] pPtDest;
	return 0;
}

int findIndex(const MLPoint& point, const MLPline& polyline)
{
	int idx = -1;
	for (int i = 1; i < polyline.getCount(); i++)
	{
		MLPoint pt1 = polyline.getAtPt(i - 1);
		MLPoint pt2 = polyline.getAtPt(i);

		double dis  = GetDistance(pt1, pt2);
		double dis1 = GetDistance(pt1, point);
		double dis2 = GetDistance(point, pt2);

		// 
		if (fabs(dis - (dis1 + dis2)) <= 0.01)
		{
			return i;
		}
	}
	return idx;
}

MLPline getPolyline(const MLPoint& pt1, const MLPoint& pt2, const MLPline& polyline)
{
	MLPline newPolyline;
	MLPline newPolyline1, newPolyline2;
	int idx1 = findIndex(pt1, polyline);
	int idx2 = findIndex(pt2, polyline);
	int count = polyline.getCount();

	if (idx1 <= 0 || idx2 <= 0)
		return newPolyline;

	if (idx1 == idx2)
		return newPolyline;

	// 线首尾点距离
	double plDis = polyline.getHeadTailDistance();
	if (idx1 < idx2)
	{
		// 为单线
		if (GetDistance(pt1, pt2) < plDis)
		{
			// 1
			newPolyline1.addTailPt(pt1);
			for (int i = idx1; i < idx2 - 1; i++)
			{
				newPolyline1.addTailPt(polyline[i]);
			}
			newPolyline1.addTailPt(pt2);
			return newPolyline1;
		}
		else
		{
			// 1
			newPolyline1.addTailPt(pt1);
			for (int i = idx1; i < idx2 - 1; i++)
			{
				newPolyline1.addTailPt(polyline[i]);
			}
			newPolyline1.addTailPt(pt2);
			newPolyline1.calculateLength();
			double length1 = newPolyline1.getLength();

			// 2
			newPolyline2.addTailPt(pt1);
			for (int i = idx1; i >= 0; i--)
			{
				newPolyline2.addTailPt(polyline[i]);
			}
			for (int i = polyline.getCount() - 1; i >= idx2; i--)
			{
				newPolyline2.addTailPt(polyline[i]);
			}
			newPolyline2.addTailPt(pt2);
			newPolyline2.calculateLength();
			double length2 = newPolyline2.getLength();

			// 取两节点最短的线段
			if (length1 > length2)
			{
				return newPolyline2;
			}
			else
			{
				return newPolyline1;
			}
		}

	}
	if (idx1 > idx2)
	{
		// 为单线
		if (GetDistance(pt1, pt2) < plDis)
		{
			// 1
			newPolyline1.addTailPt(pt1);
			for (int i = idx1; i >= idx2; i--)
			{
				newPolyline1.addTailPt(polyline[i]);
			}
			newPolyline1.addTailPt(pt2);
			return newPolyline1;
		}
		else
		{
			// 1
			newPolyline1.addTailPt(pt1);
			for (int i = idx1 - 1; i >= idx2; i--)
			{
				newPolyline1.addTailPt(polyline[i]);
			}
			newPolyline1.addTailPt(pt2);
			newPolyline1.calculateLength();
			double length1 = newPolyline1.getLength();

			//2
			newPolyline2.addTailPt(pt1);
			for (int i = idx1; i < count; i++)
			{
				newPolyline2.addTailPt(polyline[i]);
			}
			for (int i = 0; i < idx2; i++)
			{
				newPolyline2.addTailPt(polyline[i]);
			}
			newPolyline2.addTailPt(pt2);
			newPolyline2.calculateLength();
			double length2 = newPolyline2.getLength();

			if (length1 > length2)
			{
				return newPolyline2;
			}
			else
			{
				return newPolyline1;
			}
		}
	}
	return newPolyline;
}

void Switch(double &dVal1, double &dVal2)
{
	double v = dVal1;
	dVal1 = dVal2;
	dVal2 = v;
}


MLPlineList* getOffsetPline(QwtDotsCommand command)
{
	MLPlineList* pPlineLise = new MLPlineList;

	geos::geom::PrecisionModel pm(1e+10);
	geos::geom::GeometryFactory::Ptr factory = geos::geom::GeometryFactory::create(&pm);

	for (int i = command.from; i < command.to; i++)
	{
		MLPline* pContour = command.series->getPline(i);
		pContour->redundant(3.0);
		if (pContour->getHeadPt().y > pContour->getTailPt().y)
		{
			pContour->reversePt();
			pContour->calculateLength();
		}

		GEOSGeometry* geom_ = nullptr;
		GEOSGeometry* geomLeft_ = nullptr;
		GEOSGeometry* geomRight_ = nullptr;

		const size_t size = pContour->getCount();
		geos::geom::CoordinateArraySequence sequence(size);
		for (int j = 0; j < size; j++)
		{
			MLPlNode node = pContour->getAtPt(j);
			sequence.setAt(geos::geom::Coordinate(node.x, node.y), j);
		}

		// 原等值线
		geom_ = factory->createLineString(sequence);
		geomLeft_ = GEOSOffsetCurve(geom_, command.offsetDis, GEOSBUF_CAP_FLAT, GEOSBUF_JOIN_BEVEL, 0);
		geomRight_ = GEOSOffsetCurve(geom_, -command.offsetDis, GEOSBUF_CAP_FLAT, GEOSBUF_JOIN_BEVEL, 0);
		
		int numGeo1 = 0;
		if (geomLeft_)
			numGeo1 = geomLeft_->getNumGeometries();

		int numGeo2 = 0;
		if (geomRight_)
			numGeo2 = geomRight_->getNumGeometries();
		
		// 判断左偏移等值线
		if (numGeo1 >= 1)
		{
			for (int ig = 0; ig < numGeo1; ig++)
			{
				const Geometry *geom_sub = geomLeft_->getGeometryN(ig);
				int count = geom_sub->getNumPoints();
				if (count < 3)
					continue;

				MLPline* temPl = new MLPline;
				for (int k = 0; k < count; k++)
				{
					temPl->addTailPt(geom_sub->getCoordinates()->getX(k), geom_sub->getCoordinates()->getY(k));
				}

				temPl->redundant(command.redundant);
				temPl->calculateAngle();

				// 生成圆多边形
				MLPlineList ellipsePlineList;
				for (int k = 0; k < temPl->getCount(); k++)
				{
					// 角度
					double angle = temPl->getAtPt(k).a * RHO;
					MLPlNode node = temPl->getAtPt(k);

					// 如果角度小于规定角度
					if (angle < command.minAngle)
					{
						MLPline* pPline = new MLPline;
						pPline->createEllipse(node, command.minRadius);
						pPline->calculateLength();
						ellipsePlineList.addPline(pPline);
					}
				}

				// 计算圆与原等值线相关，并取原等值
				MLPlineList  newPlineList;
				for (int k = 0; k < ellipsePlineList.getCount(); k++)
				{
					MLPline* pEllipsePline = ellipsePlineList.getPline(k);
					QVector<MLPlNode> dPointAry;

					//计算交点,并按距离排序
					GetCrossPt(*pEllipsePline, *pContour, dPointAry);

					if (dPointAry.count() >= 2)
					{
						QVector <MLPlNode> dp;
						double dbx1 = dPointAry.first().l;
						double dbx2 = dPointAry.last().l;

						// 如果线头被包含
						if (pEllipsePline->contains(pContour->getHeadPt()))
							dbx1 = 0;
						// 如果线尾被包含
						else if (pEllipsePline->contains(pContour->getTailPt()))
							dbx2 = pContour->getLength() - 1;
						else if (PtAtPolyline(pContour->getHeadPt(), *pEllipsePline))
							dbx1 = 0;
						else if (PtAtPolyline(pContour->getTailPt(), *pEllipsePline))
							dbx2 = 0;

						// 取线
						getCurve(dbx1, dbx2, dp, *pContour, 0, 0);

						// 赋值
						if (dp.size() > 1)
						{
							MLPline* pNewPline = new MLPline;
							newPlineList.addPline(pNewPline);
							for (int m = 0; m < dp.size(); m++)
								pNewPline->addTailPt(dp.at(m));
						}
					}
					else if (dPointAry.count() == 1)
					{
						double dbx1 = dPointAry.first().l;
						bool headContains = pEllipsePline->contains(pContour->getHeadPt());
						bool tailContains = pEllipsePline->contains(pContour->getTailPt());
						QVector <MLPlNode> dp;
						if (headContains && tailContains)
						{

						}
						else if (headContains)
						{
							// 取线
							getCurve(0, dbx1, dp, *pContour, 0, 0);
						}
						else if (tailContains)
						{
							// 取线
							double length = pContour->getLength();
							getCurve(dbx1, length, dp, *pContour, 0, 0);
						}

						// 赋值
						if (dp.size() > 1)
						{
							MLPline* pNewPline = new MLPline;
							newPlineList.addPline(pNewPline);
							for (int m = 0; m < dp.size(); m++)
								pNewPline->addTailPt(dp.at(m));
						}
					}
					else
					{
						// 20220605 删除掉，大庆不需要圆圈
						// if (command.outCircle)
						// {
						//	 newPlineList.addPline(pEllipsePline->clone());
						// }
					}
				}

				for (int k = 0; k < newPlineList.getCount(); k++)
				{
					pPlineLise->addPline(newPlineList.getPline(k)->clone());
				}

				newPlineList.clearPline();
				ellipsePlineList.clearPline();
				delete temPl;
			}
		}

		// 判断右偏移等值线
		if (numGeo2 >= 1)
		{
			for (int ig = 0; ig < numGeo2; ig++)
			{
				const Geometry *geom_sub = geomRight_->getGeometryN(ig);
				int count = geom_sub->getNumPoints();
				if (count < 3)
					continue;

				MLPline* temPl = new MLPline;
				for (int k = 0; k < count; k++)
				{
					temPl->addTailPt(geom_sub->getCoordinates()->getX(k), geom_sub->getCoordinates()->getY(k));
				}
				temPl->redundant(command.redundant);
				temPl->calculateAngle();

				// 生成圆多边形
				MLPlineList ellipsePlineList;
				for (int k = 0; k < temPl->getCount(); k++)
				{
					double angle = temPl->getAtPt(k).a*RHO;
					MLPlNode node = temPl->getAtPt(k);

					// 如果角度小于规定角度
					if (angle < command.minAngle)
					{
						MLPline* pPline = new MLPline;
						pPline->createEllipse(node, command.minRadius);
						pPline->calculateLength();
						ellipsePlineList.addPline(pPline);
						//pPlineLise->addPline(pPline);
					}
				}

				// 计算圆与原等值线相关，并取原等值
				MLPlineList  newPlineList;
				for (int k = 0; k < ellipsePlineList.getCount(); k++)
				{
					MLPline* pEllipsePline = ellipsePlineList.getPline(k);
					QVector<MLPlNode> dPointAry;

					//计算交点,并按距离排序
					GetCrossPt(*pEllipsePline, *pContour, dPointAry);

					if (dPointAry.count() >= 2)
					{
						QVector <MLPlNode> dp;
						double dbx1 = dPointAry.first().l;
						double dbx2 = dPointAry.last().l;

						// 如果线头被包含
						if (pEllipsePline->contains(pContour->getHeadPt()))
							dbx1 = 0;
						// 如果线尾被包含
						else if (pEllipsePline->contains(pContour->getTailPt()))
							dbx2 = pContour->getLength() - 1;
						else if (PtAtPolyline(pContour->getHeadPt(), *pEllipsePline))
							dbx1 = 0;
						else if (PtAtPolyline(pContour->getTailPt(), *pEllipsePline))
							dbx2 = 0;

						// 取线
						getCurve(dbx1, dbx2, dp, *pContour, 0, 0);

						// 赋值
						if (dp.size() > 1)
						{
							MLPline* pNewPline = new MLPline;
							newPlineList.addPline(pNewPline);
							for (int m = 0; m < dp.size(); m++)
								pNewPline->addTailPt(dp.at(m));
						}
					}
					else if (dPointAry.count() == 1)
					{
						double dbx1 = dPointAry.first().l;
						bool headContains = pEllipsePline->contains(pContour->getHeadPt());
						bool tailContains = pEllipsePline->contains(pContour->getTailPt());
						QVector <MLPlNode> dp;
						if (headContains && tailContains)
						{

						}
						else if (headContains)
						{
							// 取线
							getCurve(0, dbx1, dp, *pContour, 0, 0);
						}
						else if (tailContains)
						{
							// 取线
							double length = pContour->getLength();
							getCurve(dbx1, length, dp, *pContour, 0, 0);
						}

						// 赋值
						if (dp.size() > 1)
						{
							MLPline* pNewPline = new MLPline;
							newPlineList.addPline(pNewPline);
							for (int m = 0; m < dp.size(); m++)
								pNewPline->addTailPt(dp.at(m));
						}
					}
					else
					{	// 20220605 删除掉，大庆不需要圆圈
						// if (command.outCircle)
						// {
						// 	newPlineList.addPline(pEllipsePline->clone());
						// }
					}
				}

				for (int k = 0; k < newPlineList.getCount(); k++)
				{
					pPlineLise->addPline(newPlineList.getPline(k)->clone());
				}

				newPlineList.clearPline();
				ellipsePlineList.clearPline();
				delete temPl;
			}
		}
		if (geom_) {
			factory->destroyGeometry(geom_);
		}
		if (geomLeft_)
		{
			factory->destroyGeometry(geomLeft_);
		}
		if (geomRight_)
		{
			factory->destroyGeometry(geomRight_);
		}
	}

	return pPlineLise;
}

void combinaPolygon(QList<QPolygonF*>& PolygonList)
{
	for (int i = 0; i < PolygonList.count(); i++)
	{
		QPolygonF* circlePolygon1 = PolygonList[i];

		for (int j = i + 1; j < PolygonList.count(); j++)
		{
			QPolygonF* circlePolygon2 = PolygonList[j];

			// 检测两个多边形是否相交
			if (!checkPolygonCross(*circlePolygon1, *circlePolygon2))
			{
				continue;
			}

			QPolygonF resPolygon = circlePolygon1->united(*circlePolygon2);
			if (!resPolygon.isEmpty())
			{
				QPolygonF* newPolygon = new QPolygonF(resPolygon);
				PolygonList.removeOne(circlePolygon1);
				PolygonList.removeOne(circlePolygon2);
				delete circlePolygon1;
				delete circlePolygon2;
				PolygonList.push_back(newPolygon);

				combinaPolygon(PolygonList);
				goto goto_pos;
			}
		}
	}
goto_pos:
	return;

}

// 删除相交的多边形(因为凹多边形与凸多边形有叠合)
void deletePolygon(QList<QPolygonF*>& PolygonList1, QList<QPolygonF*>& PolygonList2, double unitSacle)
{
	for (int i = 0; i < PolygonList1.count(); i++)
	{
		QPolygonF* polygon1 = PolygonList1[i];

		for (int j = 0; j < PolygonList2.count(); j++)
		{
			QPolygonF* polygon2 = PolygonList2[j];

			// 检测两个多边形是否相交
			QPolygonF desPolygon;
			if (!checkPolygonCross(*polygon1, *polygon2, desPolygon))
			{
				continue;
			}

			double dArea1 = calculateArea(*polygon1);
			double dArea2 = calculateArea(*polygon2);
			double dAreaDes = calculateArea(desPolygon);

			if (dArea1 > dArea2)
			{
				// 相交面积大于0.7，删除小面积的
				double scale1 = dAreaDes / dArea2;
				if (scale1 >= unitSacle)
				{
					PolygonList2.removeOne(polygon2);
					delete polygon2;
					deletePolygon(PolygonList1, PolygonList2, unitSacle);
					goto goto_pos;
				}
			}
			else if (dArea1 < dArea2)
			{
				// 相交面积大于0.7，删除小面积的
				double scale2 = dAreaDes / dArea1;
				if (scale2 >= unitSacle)
				{
					PolygonList1.removeOne(polygon1);
					delete polygon1;
					deletePolygon(PolygonList1, PolygonList2, unitSacle);
					goto goto_pos;
				}
			}
			else
			{

			}
		}
	}
goto_pos:
	return;
}

// 检测两个多边形是否相交,并返回相交多边形
bool checkPolygonCross(const QPolygonF& polygon1, const QPolygonF& polygon2)
{
	if (polygon1.isEmpty() || polygon2.isEmpty())
	{
		return false;
	}

	if (polygon1.count() == polygon2.count())
	{
		if (polygon1.first().toPoint() == polygon2.first().toPoint() &&
			polygon1.last().toPoint() == polygon2.last().toPoint() &&
			polygon1[polygon1.count() / 2].toPoint() == polygon2[polygon2.count() / 2].toPoint())
		{
			return false;
		}
	}

	QPolygonF polygon = polygon1.intersected(polygon2);
	if (!polygon.isEmpty())
	{
		return true;
	}
	return false;
}

bool checkPolygonCross(const QPolygonF& polygon1, const QPolygonF& polygon2, QPolygonF& polygonDes)
{

	if (polygon1.isEmpty() || polygon2.isEmpty())
	{
		return false;
	}

	if (polygon1.count() == polygon2.count())
	{
		if (polygon1.first().toPoint() == polygon2.first().toPoint() &&
			polygon1.last().toPoint() == polygon2.last().toPoint() &&
			polygon1[polygon1.count() / 2].toPoint() == polygon2[polygon2.count() / 2].toPoint())
		{
			return false;
		}
	}

	polygonDes = polygon1.intersected(polygon2);
	if (!polygonDes.isEmpty())
	{
		return true;
	}
	return false;
}

QPointF getCentroid(const QPolygonF& polygon)
{
	/* Compute polygon centroid location */
	int i, last;
	double A, d, xold, yold;
	A = calculateArea(polygon);
	last = polygon.count();

	double Cx = 0.0, Cy = 0.0;
	xold = polygon[last - 1].x();
	yold = polygon[last - 1].y();
	for (i = 0; i < last; i++)
	{
		d = (xold * polygon[i].y() - polygon[i].x() * yold);
		Cx += (polygon[i].x() + xold) * d;
		Cy += (polygon[i].y() + yold) * d;
		xold = polygon[i].x();
		yold = polygon[i].y();
	}

	Cx /= (6.0 * A);
	Cy /= (6.0 * A);

	return QPointF(Cx, Cy);
	//return ((A < 0.0) ? -1 : +1);	/* -1 means CCW, +1 means CW */
}

double calculateArea(const QPolygonF& polygon)
{
	double area = 0.;
	int i, j;
	int n = polygon.count();
	QPointF dPt1, dPt2;

	double ai = 0.;
	for (i = n - 1, j = 0; j < n; i = j, j++)
	{
		dPt1 = polygon[i];
		dPt2 = polygon[j];

		ai = dPt1.x() * dPt2.y() - dPt2.x() * dPt1.y();
		area += ai;
	}
	return area = fabs(area / 2.0);
}

MLPline* getOffsetPl(MLPline* pPolyline, double dDistance)
{
	MLPline* pNewPolyline = new MLPline;

	int count = pPolyline->getCount();
	for (int i = 1; i < count; i++)
	{
		MLPoint dPt1 = pPolyline->getAtPt(i - 1);
		MLPoint dPt2 = pPolyline->getAtPt(i);

		double dscale = 1.0;// (dDepth - dPt1.cz) / (dPt2.cz - dPt1.cz);
		double dxa = dPt2.x - dPt1.x;
		double dya = dPt2.y - dPt1.y;
		double drr = sqrt(dxa * dxa + dya * dya);

		double dis = dDistance;
		double dsize = drr * dscale;

		double dSin = dya / drr;
		double dCos = dxa / drr;

		MLPoint dPt;
		dPt.x = dPt1.x + dsize * dCos + dis * dSin;
		dPt.y = dPt1.y + dsize * dSin - dis * dCos;
		dPt.l = dPt2.l;
		pNewPolyline->addHeadPt(dPt);
	}
	return pNewPolyline;
}


int GetBXY(double *X, double *Y, int isClose, MLPline& dPline)
{
	int i, n;
	int num = dPline.getCount();
	n = num + 4;

	for (i = 2; i < n - 2; ++i)
	{
		X[i] = dPline[i - 2].x;
		Y[i] = dPline[i - 2].y;
	}
	if (!isClose)
	{
		X[0] = X[2]; X[1] = X[2];
		Y[0] = Y[2]; Y[1] = Y[2];
		X[n - 2] = X[n - 3]; X[n - 1] = X[n - 3];
		Y[n - 2] = Y[n - 3]; Y[n - 1] = Y[n - 3];
	}
	else
	{
		X[0] = X[n - 4]; X[1] = X[n - 3];
		Y[0] = Y[n - 4]; Y[1] = Y[n - 3];
		X[n - 2] = X[2]; X[n - 1] = X[3];
		Y[n - 2] = Y[2]; Y[n - 1] = Y[3];
		return 1;
	}
	return 0;
}

void GetB(double t, double *B)
{
	double t2;
	t2 = 1.0 - t;
	B[2] = t2;
	B[0] = t2 * t2*t2*OS;
	t2 = t * t;
	B[1] = t2 * (0.5*t - 1.0) + TT_;
	B[2] = 0.5*t2*B[2] + 0.5*t + OS;
	B[3] = OS * t*t2;
}

double VectorM(int n, double *v1, double *v2)
{
	double s;
	s = 0.0;
	while (--n >= 0)
	{
		s += v1[n] * v2[n];
	}
	return s;
}

void GetBezierData(int bIsClose, double sd, MLPline& OrgPline, MLPline& NewPline)
{
	int i, j, k;
	int IsDraw;
	double B[4];
	double xx, yy, s, xp, yp;
	int nn, n;
	double *X, *Y;
	int num = OrgPline.getCount();
	n = num + 4;
	X = new double[n + n + 4];
	Y = X + n + 2;

	GetBXY(X, Y, bIsClose, OrgPline);
	GetB(0.0, B);

	xp = VectorM(4, X, B);
	yp = VectorM(4, Y, B);

	IsDraw = 1;
	s = 0.0;
	k = 0;

	if (sd < 1.0) sd = 1.0;

	MLPlNode dPoint;
	dPoint.x = xp;
	dPoint.y = yp;
	//NewPline.addTailPt(dPoint);

	for (i = 0; i < n - 4; ++i)
	{
		nn = (int)(sqrt((X[i + 2] - X[i + 1])*(X[i + 2] - X[i + 1]) + (Y[i + 2] - Y[i + 1])*(Y[i + 2] - Y[i + 1])) / sd);

		if (nn < 0)
			nn = -nn;
		if (nn < 2)
			nn = 2;

		for (j = 0; j < nn; ++j)
		{
			GetB((double)j / (double)nn, B);

			xx = VectorM(4, X + i, B);
			yy = VectorM(4, Y + i, B);

			if (IsDraw)
			{
				MLPlNode dPoint;
				dPoint.x = xx;
				dPoint.y = yy;
				NewPline.addTailPt(dPoint);
			}

			s += sqrt((xx - xp)*(xx - xp) + (yy - yp)*(yy - yp));
			xp = xx;
			yp = yy;
		}
	}

	if (!bIsClose)
	{
		dPoint = OrgPline.getTailPt();
		NewPline.addTailPt(dPoint);
	}
	else
	{
		NewPline.addTailPt(NewPline.getHeadPt());
	}

	delete[] X;
	X = NULL;
}


int Intersection(MLPlNode p1, MLPlNode p2, MLPlNode p3, MLPlNode p4, MLPlNode &Int)
{
	//保证参数p1!=p2，p3!=p4
	if (p1 == p2 || p3 == p4)
	{
		return -1; //返回-1代表至少有一条线段首尾重合，不能构成线段
	}

	//为方便运算，保证各线段的起点在前，终点在后。

	if (p1 > p2)
	{
		std::swap(p1, p2);
	}

	if (p3 > p4)
	{
		std::swap(p3, p4);
	}

	//判定两线段是否完全重合

	if (p1 == p3 && p2 == p4)
	{
		return 6;
	}

	//求出两线段构成的向量

	MLPlNode v1, v2;// = {p2.x - p1.x, p2.y - p1.y}, v2 = {p4.x - p3.x, p4.y - p3.y};
	v1.x = p2.x - p1.x;
	v1.y = p2.y - p1.y;
	v2.x = p4.x - p3.x;
	v2.y = p4.y - p3.y;


	//求两向量外积，平行时外积为0
	float Corss = v1 ^ v2;

	//如果起点重合
	if (p1 == p3)
	{
		Int = p1;
		//起点重合且共线(平行)返回5；不平行则交于端点，返回3
		return (Equ(Corss, 0) ? 5 : 3);
	}

	//如果终点重合
	if (p2 == p4)
	{
		Int = p2;
		//终点重合且共线(平行)返回5；不平行则交于端点，返回3
		return (Equ(Corss, 0) ? 5 : 3);
	}

	//如果两线端首尾相连
	if (p1 == p4)
	{
		Int = p1;
		return 3;
	}

	if (p2 == p3)
	{
		Int = p2;
		return 3;
	}//经过以上判断，首尾点相重的情况都被排除了

	//将线段按起点坐标排序。若线段1的起点较大，则将两线段交换

	if (p1 > p3)
	{
		std::swap(p1, p3);
		std::swap(p2, p4);

		//更新原先计算的向量及其外积
		std::swap(v1, v2);
		Corss = v1 ^ v2;
	}

	//处理两线段平行的情况
	if (Equ(Corss, 0))
	{
		//做向量v1(p1, p2)和vs(p1,p3)的外积，判定是否共线
		MLPlNode vs;// = {p3.x - p1.x, p3.y - p1.y};
		vs.x = p3.x - p1.x;
		vs.y = p3.y - p1.y;

		//外积为0则两平行线段共线，下面判定是否有重合部分

		if (Equ(v1 ^ vs, 0))
		{
			//前一条线的终点大于后一条线的起点，则判定存在重合
			if (p2 > p3)
			{
				Int = p3;
				return 4; //返回值4代表线段部分重合
			}

		}//若三点不共线，则这两条平行线段必不共线。

		//不共线或共线但无重合的平行线均无交点
		return 0;

	} //以下为不平行的情况，先进行快速排斥试验

	//x坐标已有序，可直接比较。y坐标要先求两线段的最大和最小值

	float ymax1 = p1.y, ymin1 = p2.y, ymax2 = p3.y, ymin2 = p4.y;

	if (ymax1 < ymin1)
	{
		std::swap(ymax1, ymin1);
	}

	if (ymax2 < ymin2)
	{
		std::swap(ymax2, ymin2);
	}

	//如果以两线段为对角线的矩形不相交，则无交点

	if (p1.x > p4.x || p2.x < p3.x || ymax1 < ymin2 || ymin1 > ymax2)
	{
		return 0;

	}//下面进行跨立试验

	MLPlNode vs1, vs2;//= {p1.x - p3.x, p1.y - p3.y}, vs2 = {p2.x - p3.x, p2.y - p3.y};
	vs1.x = p1.x - p3.x;
	vs1.y = p1.y - p3.y;
	vs2.x = p2.x - p3.x;
	vs2.y = p2.y - p3.y;

	MLPlNode vt1, vt2;// = {p3.x - p1.x, p3.y - p1.y}, vt2 = {p4.x - p1.x, p4.y - p1.y};
	vt1.x = p3.x - p1.x;
	vt1.y = p3.y - p1.y;
	vt2.x = p4.x - p1.x;
	vt2.y = p4.y - p1.y;

	float s1v2, s2v2, t1v1, t2v1;

	//根据外积结果判定否交于线上
	if (Equ(s1v2 = vs1 ^ v2, 0) && p4 > p1 && p1 > p3)
	{
		Int = p1;
		return 2;
	}

	if (Equ(s2v2 = vs2 ^ v2, 0) && p4 > p2 && p2 > p3)
	{
		Int = p2;
		return 2;
	}

	if (Equ(t1v1 = vt1 ^ v1, 0) && p2 > p3 && p3 > p1)
	{
		Int = p3;
		return 2;
	}

	if (Equ(t2v1 = vt2 ^ v1, 0) && p2 > p4 && p4 > p1)
	{
		Int = p4;
		return 2;
	} //未交于线上，则判定是否相交

	if (s1v2 * s2v2 > 0 || t1v1 * t2v1 > 0)
	{
		return 0;

	} //以下为相交的情况，算法详见文档

	//计算二阶行列式的两个常数项

	float ConA = p1.x * v1.y - p1.y * v1.x;
	float ConB = p3.x * v2.y - p3.y * v2.x;

	//计算行列式D1和D2的值，除以系数行列式的值，得到交点坐标

	Int.x = (ConB * v1.x - ConA * v2.x) / Corss;
	Int.y = (ConB * v1.y - ConA * v2.y) / Corss;
	//正交返回1

	return 1;
}

//按点长度插入
void	insertPt(QVector<MLPlNode> &xy, MLPlNode &Pt)
{
	int i, num;
	MLPlNode t;
	num = (int)xy.count();
	if (num < 1)
	{
		xy.append(Pt);
		return;
	}

	t = xy.at(0);
	if (Pt.l < t.l)
	{
		xy.insert(0, Pt);
		return;
	}

	if (num == 1)
	{
		xy.append(Pt);
		return;
	}

	for (i = 0; i < num; ++i)
	{
		t = xy.at(i);
		if (Pt.l < t.l)
		{
			xy.insert(i, Pt);
			return;
		}
	}
	xy.append(Pt);
}


int	GetCrossPt(MLPlNode& P1, MLPlNode& P2, MLPlNode& P3, MLPlNode& P4, QVector<MLPlNode> &xy)
{
	MLPlNode pt;
	double x, y, l, l2;
	double dbL1x1, dbL1y1, dbL1x2, dbL1y2;
	double dbL2x1, dbL2y1, dbL2x2, dbL2y2;

	dbL1x1 = P1.x;
	dbL1y1 = P1.y;
	dbL1x2 = P2.x;
	dbL1y2 = P2.y;

	dbL2x1 = P3.x;
	dbL2y1 = P3.y;
	dbL2x2 = P4.x;
	dbL2y2 = P4.y;

	x = dbL2x1;
	y = dbL2y1;
	l = P3.l;
	l2 = P1.l;

	int nRes = Intersection(P1, P2, P3, P4, pt);
	if (nRes == 1 || nRes == 2)
	{
		double dd = GetDistance(pt.x, pt.y, dbL2x1, dbL2y1);
		double dd2 = GetDistance(pt.x, pt.y, dbL1x1, dbL1y1);
		pt.l = l + dd;
		pt.z = l2 + dd2;
		insertPt(xy, pt);
		return 1;
	}
	return 0;
}

//得到第一条折线切第二条折线,得到距离点保存在xy中
int   GetCrossPt(MLPline &c1, MLPline &c2, QVector<MLPlNode> &xy, bool bAddTailPt)
{
	int i, j;
	bool bCross = false;	//设置曲线是否有交点
	if (c2.getCount() < 2) return 0;

	if (c1.getCount() == c2.getCount() &&
		c1[0].x == c2[0].x &&
		c1[1].x == c2[1].x &&
		c1[c1.getCount() - 1].x == c2[c2.getCount() - 1].x)
		return 0;

	for (i = 1; i < c1.getCount(); i++)
	{
		MLPlNode P1, P2;
		P1 = c1[i - 1];
		P2 = c1[i];
		if (P1 == P2)
			continue;

		for (j = 1; j < c2.getCount(); j++)
		{
			MLPlNode P3, P4;
			P3 = c2[j - 1];
			P4 = c2[j];
			if (P3 == P4)
				continue;
			int nRes = GetCrossPt(P1, P2, P3, P4, xy);
			if (nRes == 1)
				bCross = true;
		}
	}

	if (bCross && bAddTailPt)
	{
		c2[0].z = 0.0;
		xy.insert(0, c2[0]);
		c2[c2.getCount() - 1].z = c2[c2.getCount() - 1].l;
		xy.append(c2[c2.getCount() - 1]);
	}
	return 1;
}

int getCurve(double l1, double l2, QVector<MLPlNode> &dp, MLPline& dPline, int bDoubleHeadTail/*=1*/, bool bNoLineValue/*=false*/)
{
	int num = dPline.getCount();
	int n = (int)dp.count();
	if (n > 0)	dp.clear();

	int i;
	MLPlNode t;
	if (dPline.getHeadPt().l < dPline.getTailPt().l)
	{
		if (l1 < dPline.getHeadPt().l)
		{
			l1 = dPline.getHeadPt().l;
			//return 1;
		}
		if (l1 > dPline.getTailPt().l)
		{
			l1 = dPline.getTailPt().l;
			//return 1;
		}
		if (l2 < dPline.getHeadPt().l)
		{
			l2 = dPline.getHeadPt().l;
			//return 1;
		}
		if (l2 > dPline.getTailPt().l)
		{
			l2 = dPline.getTailPt().l;
			//return 1;
		}
	}
	else
	{
		if (l1 > dPline.getHeadPt().l || l1 < dPline.getTailPt().l)
			return 1;
		if (l2 > dPline.getHeadPt().l || l2 < dPline.getTailPt().l)
			return 1;
	}

	i = bs(l1, dPline);
	t.x = cz(l1, i, dPline, 3, 0);
	t.y = cz(l1, i, dPline, 3, 1);
	t.z = dPline[i].z;
	t.l = l1;

	if (!bNoLineValue)
	{
		dp.append(t);
		if (bDoubleHeadTail)
			dp.append(t);
	}
	else
	{
		t.x = dPline[i].x;
		t.y = dPline[i].y;
		t.z = dPline[i].z;
		t.l = dPline[i].l;
		if (fabs(l1 - dPline[i].l) < fabs(dPline[i + 1].l - l1))
			dp.append(t);
	}
	double a = dPline[0].l;
	double b = dPline[num - 1].l;

	//if(dPline[0].l < dPline[num-1].l)
	if (a < b)
	{
		if (l1 < l2)
		{
			while (++i <= num)
			{
				if (dPline[i].l >= l2)
					break;
				t.x = dPline[i].x;
				t.y = dPline[i].y;
				t.z = dPline[i].z;
				t.l = dPline[i].l;
				dp.append(t);
			}
		}
		else
		{
			++i;
			while (--i >= 0)
			{
				if (dPline[i].l <= l2)
					break;

				t.x = dPline[i].x;
				t.y = dPline[i].y;
				t.z = dPline[i].z;
				t.l = dPline[i].l;
				dp.append(t);
			}
		}
	}
	else
	{
		//double aa = dPline[0].l;
		//double bb = dPline[num-1].l;
		if (l1 > l2)
		{
			while (++i <= num)
			{
				if (dPline[i].l <= l2)
					break;

				t.x = dPline[i].x;
				t.y = dPline[i].y;
				t.z = dPline[i].z;
				t.l = dPline[i].l;
				dp.append(t);
			}
		}
		else
		{
			++i;
			while (--i >= 0)
			{
				if (dPline[i].l >= l2)
					break;

				t.x = dPline[i].x;
				t.y = dPline[i].y;
				t.z = dPline[i].z;
				t.l = dPline[i].l;
				dp.append(t);
			}
		}
	}

	i = bs(l2, dPline);
	t.x = cz(l2, i, dPline, 3, 0);
	t.y = cz(l2, i, dPline, 3, 1);
	t.z = dPline[i].z;
	t.l = l2;

	if (!bNoLineValue)
	{
		dp.append(t);
		if (bDoubleHeadTail)
			dp.append(t);
	}
	else
	{
		t.x = dPline[i + 1].x;
		t.y = dPline[i + 1].y;
		t.z = dPline[i + 1].z;
		t.l = dPline[i + 1].l;
		if (fabs(l2 - dPline[i].l) > fabs(dPline[i + 1].l - l2))
			dp.append(t);
	}
	return 0;
}