/**************************************************************************************
文 件 名：BaseFunction.h

主要功能:
基础函数类，包括基础算术运算，几何运算等
主要函数列表：


简述：	增加函数
//空间点到空间线段的最短距离
double PointSegmentDistance3D(double x0, double y0, double z0, double x1, double y1,double z1, double x2, double y2, double z2);
//两向量A(x1,y1),B(x2,y2)的点积(内积)
double DotProduct(double x1,double y1,double x2,double y2);
//两向量A(x1,y1),B(x2,y2)的叉积(外积)
double CrossProduct(double x1, double y1, double x2, double y2);
//由三边边长得到三角形的面积
double TriArea(double a, double b, double c);
//计算三角形A(x1,y1) B(x2,y2) C(x3,y3)，顶点B的角平分线与AC边交点(x0,y0)如果ABC共线，求角平分线上距离为1任意一点
bool GetAngularBisector(double x1, double y1, double x2, double y2, double x3, double y3, double& x0, double& y0);
//判断两条线段(x1,y1)-(x2,y2) ,(x3,y3)-(x4,y4)是否相交,返回1 交叉相交，返回0 不相交， 返回2 共线相交
int IsSegmentCross(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4);
//两条直线的交点,k1,k2为两条直线的斜率，若k值 > 1e10 表示垂直于x轴 返回0表示无交点，返回1表示存在唯一交点，返回2表示两直线重合
int LineCrossPoint(double x1,double y1, double k1, double x2,double y2, double k2, double& x0, double& y0 );
//五点三次平滑 --- wangcw
bool Smooth53(double* val, int n, int stimes = 100);
//对散点数据，获得其外轮廓曲线，返回为轮廓点个数，坐标保存在参数x、y中
int GetOutline(int num, double *x, double *y);
// 得到散点的凸包，传入原始点集p大小为n，返回值为凸包大小,凸包点在convex上
int GetConvexHull(int n, CPoint2D* s_points,CPoint2D* convex, int maxsize = 1, int dir = 1 );
//x1,y1,x2,y2,x3,y3为三角形的三个顶点坐标，x,y,r中返回的是三角形外接圆的圆心坐标及半径
BOOL GetCircumcenter(double &x, double &y, double &r,
double x1, double y1,
double x2, double y2,
double x3, double y3);

**************************************************************************************/

#pragma once
#ifndef AFX_EXT_CLASS
#define AFX_EXT_CLASS  Q_DECL_IMPORT
#endif

#include "math.h"
#include "Point2D.h"
#include <vector>
//
#ifndef PI
#define PI		3.1415926535897932384626433832795
#endif

#ifndef RHO
#define RHO		57.295779513082320876798154814114		//(180.0/PI)
#endif
#ifdef _QT_VERSION
//
//  Code Page Default Values.
//
#define CP_ACP                    0           // default to ANSI code page
#define CP_OEMCP                  1           // default to OEM  code page
#define CP_MACCP                  2           // default to MAC  code page
#define CP_THREAD_ACP             3           // current thread's ANSI code page
#define CP_SYMBOL                 42          // SYMBOL translations

#define CP_UTF7                   65000       // UTF-7 translation
#define CP_UTF8                   65001       // UTF-8 translation

#endif //_QT_VERSION
namespace GBase
{
	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	//编码类型定义
#define CODE_GB2312		0x00000000	//gb2312编码
#define CODE_UTF8		0x00000001	//utf-8编码
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	class AFX_EXT_CLASS CBaseFunction
	{
	public:
		CBaseFunction(void);
		virtual ~CBaseFunction(void);

		//双精度数转换为字符串
		void	FloatToString(CString& result, double dValue);
		void	FloatToString(CString& result, double dValue, int n);
		void	FloatToString(char* result, double dValue);
		void	FloatToString(char *result, double dValue, int n);
		CString	FloatToString(double dValue);			//将结果输出到m_tempLine中，可以用GetTempString()获得
		CString	FloatToString(double dValue, int n);
		CString ToString(double dValue, int n = 6);

		CString Bool2Str(bool boolVal);
		CString Bool2Str(BOOL boolVal);

		long	FloatToLong(double value);

		////输出数组到字符串中，用户可以自定义间隔符号（缺省是‘，’）
		void	PrintXYZ(char* string, double *v, int num, int digits, char split = ',');
		//void	PrintXYZ(CString& result,	double *v, int num, int digits, char split=',');
		void	PrintXYZ(char* result, double *v, int num, char split = ',');
		//void	PrintXYZ(CString& result,	double *v, int num, char split=',');

	public:
		//获得/设置小数位保留位数
		void	SetDecimalDigits(int digits);
		int		GetDecimalDigits(void);

		int		IsDigit(CString &line);
		int		IsDigit(char* line);

		bool	IsKey(const CString& key, LPCTSTR lpszKeyString);
		bool	IsZero(const double& val);					//判断val是否是零
		bool	IsZero(const double& val, double deps);		//判断val是否是零
		bool	IsEqual(const double& x, const double& y, double deps = 1e-8); //判断两个值是否相等
		bool    IsEqual(const CPoint2D& pt1, const CPoint2D& pt2, double deps = 1e-6); //判断两个点是否重合
		//获取最高位和整数位数 位数存入plen
		int	GetTopDigit(int scrV, int* plen);
		//保留最高位，其余替换为0
		int ReplaceDigitWithZero(int scrV);

	public:
		int		GetArgument(CString cmd, CStringList &list);

		//获得以关键字（空格、逗号、TAB键）间隔的串,引号内部的关键字不起作用
		int		ScanfString(CStringArray &m_type, char* cmd);
		//获得split间隔的串,引号内部的split不起作用
		int		ScanfString1(CStringArray &m_type, char* cmd, int n, char split);
		//获得split间隔的串,引号内部的split不起作用
		int		ScanfString1(CStringArray &m_type, CString cmd, char split);
		int		ScanfString(CStringArray &m_type, CString cmd, char split, bool bWithQuotation = false);
		//获得split间隔的串,bWithQuotation==true表示引号内部的关键字不起作用
		int		ScanfString(CStringArray &m_type,
			char* cmd, int nCmdNum,
			char* splitChar, int nSplitNum,
			bool bWithQuotation = true);

		int		ScanDouble(char *line, double *x, int n, int m);
		int		ScanDouble1(char *line, double *x, int n, int m);
		//得到文件的行数 added ww 2015-1-26
		int		GetFileLineNum(const char* strFile);

	public:
		//二分法搜索及插值，*x中的为排序数据(由小到大/由大到小)
		int		BinarySearch(double key, int num, double *x);
		double	LineValue(double x0, double *x, double *y);
		double	LineValue(double x0, double x1, double x2, double y1, double y2);
		double	LineValue(double m, double n, double z1, double z2, double z3, double z4);


		/////< 对应Pline.h中的DflineValue函数
		//先二分法搜索，然后再线性插值
		//参数*x中的为排序数据(由小到大/由大到小)
		double	LineValue(double *x, double *y, int num, double x0);
		//根据Z值线性插值XY，成功返回true
		//  参数*z中的为排序数据(由小到大/由大到小)
		//  bExtend＝1外推，bExtend=0不外推
		bool	LineValue(OUT CPoint2D& pt, double *x, double *y, double *z, int num, double z0, BOOL bExtend);
		//线性插值，成功返回true，
		//  参数*y中的为排序数据(由小到大/由大到小)
		//  bExtend＝1外推，bExtend=0不外推，
		//  当bExtend=0时，bSetValue=1在范围外等于两头的值，bSetValue=0在范围外无值
		bool	LineValue(OUT double &y0, double *x, double *y, int num, double x0, BOOL bExtend, BOOL bSetValue);


		//坐标旋转
		void	Rotate(double &x0, double &y0, double radians);
		void	Rotate(double &x, double &y, double cosa, double sina);
		void	Rotate(double &x0, double &y0, double &z0, double alfa, double beta);

		//算术运算，参数mode=0代表+ ，1为减，2为乘，3为除
		void	Arithmetic(double& val, double factor, int mode);

		void	SortCoordinate(double* x, double* y, int n);	//根据坐标按照最小距离排序, 曲线拟合
		int		GetMinValueIndex(double* a, int n);				//获得数组中最小值的索引号

		double	TotalDistance(double *a, double *b, int n);	//获得总的距离和
		double	Distance2(double x1, double y1, double x2, double y2);
		double	Distance(double x1, double y1, double x2, double y2);
		double	Distance3D(double x1, double y1, double z1, double x2, double y2, double z2);

		//点(x0,y0)到直线kx+b的距离
		double	PointLineDistance(double x0, double y0, double k, double b);
		// 点(x0,y0)到线段的最短距离 
		double	PointLineDistance(double x0, double y0, double x1, double y1, double x2, double y2);
		// 点(x0,y0)到线段的最短距离 a- 0到1 的距离， b 0到2  的距离， c 1到2的距离
		double PointLineDistance(double x0, double y0, double x1, double y1, double x2, double y2, double a, double b, double c);

		//空间点(x0,y0,z0)到空间线段的最短距离 --Wangcw
		double	PointLineDistance3D(double x0, double y0, double z0, double x1, double y1, double z1, double x2, double y2, double z2);

		///////////////////////////////////////////////////////////////////////
		//
		//                1 上侧
		//      p1--------------------p2
		//                2 下侧
		//
		//
		//                p2
		//                |
		//                |
		//         1 左侧 | 2 右侧
		//                |
		//                |
		//                p1
		//
		// 判断点在直线的哪侧   	1-- 左侧  0--线上  2---右侧
		int		PointInLine(double x0, double y0, double x1, double y1, double x2, double y2);
		//判断点是否在线段上
		bool     IsPointOnSegment(double x0, double y0, double x1, double y1, double x2, double y2);

		//判断两条线段(x1,y1)-(x2,y2) ,(x3,y3)-(x4,y4)是否相交,返回1 交叉相交，返回0 不相交， 返回2 共线相交
		int		IsSegmentCross(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4);
		//两条直线的交点,k1,k2为两条直线的斜率，若k值 > 1e10 表示垂直于x轴 返回0表示无交点，返回1表示存在唯一交点，返回2表示两直线重合
		int		LineCrossPoint(double x1, double y1, double k1, double x2, double y2, double k2, double& x0, double& y0);
		int		LineCrossPoint(const CPoint2D& pt1, const CPoint2D& pt2, const CPoint2D& pt3, const CPoint2D& pt4, double& x0, double& y0);

		//判断点是否在多边形内部 1为内部 0为外部， x,y为多边形数组，m为点个数 ww 2016-11-01
		int		IsPtInPolygon(double x0, double y0, double* x, double* y, int m);

		//两向量A(x1,y1),B(x2,y2)的点积(内积) 
		double	DotProduct(double x1, double y1, double x2, double y2);
		//两向量A(x1,y1),B(x2,y2)的叉积(外积) 
		double	CrossProduct(double x1, double y1, double x2, double y2);

		int		Offset(double k, double z, double &delt, double &h, BOOL bOffset);		//曲线上的点偏移或反偏移，k为斜率
		// dx = -z*dx; dy = -z*dy; z = -z*sqrt(1 - (dx^2 + dy^2) )
		int		Offset(double &dx, double &dy, double &z, BOOL bOffset);				//曲面上的点偏移或反偏移，dx、dx为偏导
		//bOffset==TRUE时调用Offset2D，为FALSE时调用UnOffset2D
		int		Offset2D(double k, double z, double &delt, double &h);					//曲面上的点偏移
		int		UnOffset2D(double k, double h, double &delt, double &z);				//曲面上的点反偏移

	public:
		double	GetAngle(double x1, double y1, double x2, double y2, double x3, double y3);	//获得两直线之间的夹角
		double	GetAngle(double x1, double y1, double x2, double y2);					//获得直线与正X轴之间的夹角
		double	GetAngle(double x, double y);
		double	GetAzimuth(double x1, double y1, double x2, double y2);					//计算方位角

		double	ToDegree(double dms);	//将度分秒转换为度
		double	ToDMS(double degree);	//将度转换为度分秒

		void	GetKB(double x1, double y1, double x2, double y2, double &k, double &b);//获得直线方程参数
		BOOL	GetKB(int num, double *x, double *y, double &k, double &b);				//最小二乘法直线拟合, num>2, 拟合直线方程(Y=kX+b)
		//最小二乘法平面插值，返回高程 ww 2021.4.22
		double LeastSquareFit(std::vector<CPoint3D>& points, double x0, double y0);
		//最小二乘法平面fitting by a plane h(x,y) = barH + barA0*(x-barX) + barA1*(y-barY) -- ww 2021.4.22 
		bool	LeastSquarePlane(std::vector<CPoint3D>& points, double& barX, double& barY, double& barH,
			double& barA0, double& barA1);
		int		Gauss(int n, double *a, double *c);
		double	GetAreaTrue(int num, double* x, double* y);								//求闭合区域面积，面积可能是正值也可能是负值
		double	GetArea(int num, double *x, double *y);									//求闭合区域面积（绝对值）,GetArea()=fabs(GetAreaTrue())
		//得到向量pt1,pt2 与pt2, pt3之间的夹角cos值 
		double	GetCosinValue(CPoint2D& pt1, CPoint2D& pt2, CPoint2D& pt3);

		//由三边边长得到三角形的面积 
		double	TriArea(double a, double b, double c);
		//计算三角形A(x1,y1) B(x2,y2) C(x3,y3)，顶点B的角平分线与AC边交点(x0,y0)如果ABC共线，求角平分线上距离为1任意一点 ww
		bool	GetAngularBisector(double x1, double y1, double x2, double y2, double x3, double y3, double& x0, double& y0);
		//x1,y1,x2,y2,x3,y3为三角形的三个顶点坐标，x,y,r中返回的是三角形外接圆的圆心坐标及半径
		BOOL	GetCircumcenter(double &x, double &y, double &r,
			double x1, double y1,
			double x2, double y2,
			double x3, double y3);

		double	GetFirstValue(double x, double step);
		double	GetCanonicalStep(double step);				//获得规范化的步长，如参数为12返回10、0.13=0.1
		double	ContourStep(double m_step);
		int		GetCycValue(int i, int T);

		//获取多边形重心(内部中心位置） (x0,y0)为重心坐标 ww 2019.7.3
		void GetGravityCenter(double* xx, double* yy, int num, double& x0, double& y0);

		//获得等边多边形的顶点坐标
		// centerPoint 中心点坐标
		// endPoint 结束点坐标，该点为多边形的起点
		// polyNum 等边多边形的边数
		void	GetEquilateralPolyPoints(CPointList& pl, dfPoint &centerPoint, dfPoint &endPoint, int polyNum);
		//根据角度获得圆上的点的坐标
		dfPoint GetPointOnCircle(dfPoint& centerPoint, double r, double angle);
		//获取线段S(x1,y1)(x2,y2)的中垂线 r为中垂线端点到线段S的距离 ww dstPts[0] = left  dstPts[1] = right
		bool	GetMidPerpendicular(const CPoint2D& pt1, const CPoint2D& pt2, double r, std::vector<CPoint2D>& dstPts);
		//根据角度获得椭圆上的点坐标
		bool    GetPointOnEllipse(double &x, double& y, const CSize8& szRadius, double angle);
		bool    GetPointOnEllipse(double &x, double& y, const CPoint2D& centerPoint, const CSize8& szRadius, double angle);
		//获取椭圆上点的切线斜率 centerpoint = 中心点坐标 ，szRadius = 长短轴长度 （x0,y0) = 中心点坐标 若为垂线，返回值大于1e20
		double  GetKOnEllipse(double x0, double y0, const CPoint2D& centerPoint, const CSize8& szRadius);

		//五点三次平滑 --- wangcw
		bool	Smooth53(double* val, int n, int stimes = 1);
		//h0 为输入，m点个数，h1输出，n=几点平滑，time=平滑次数  多点滑动取平均
		double	PointSmooth(double *h0, int m, double *h1, int n, int time);

		//反距离加权校正公式。输入x,y,z,m为数组元素个数，x0,y0为所求点坐标，k通常为2
		double	Weight2D(double x0, double y0, int m, double *x, double *y, double *z, double k);
		//三维反距离加权校正公式
		double	Weight3D(double x0, double y0, double t0, int m, double *x, double *y, double *t, double *z, int k);
		//判断多边形是否为顺时钟方向
		bool	IsClockWise(double* x, double* y, int num);
		//判断一组坐标是否共线 如果是 返回true 否 返回false ww
		bool	IsCollinear(double*x, double* y, int num, double prec = 1e-10);
		//自动调整坐标轴范围和刻标个数 ww 2019.7.9
		void	AdjustAxis(double& minV, double& maxV, int& numTicks);

		//根据p1、p2指定的直线获得组合为箭头的三个坐标点(szLength.cy是箭头长度，cx是箭头宽度)
		BOOL	GetArrowPoint3(CPoint2D p1, CPoint2D p2, CPoint2D* pOutPoint3, CSize8 szLength);
		//根据ptStart、ptEnd定义的直线，获得curPoint与该直线形成angle的坐标点
		void	GetAnglePoint(CPoint2D& curPoint, CPoint2D ptStart, CPoint2D ptEnd, double angle);

	public:
		///>  dec=0升序排列，dec＝1降序排列
		void	SortDouble(int num, double *x, int dec = 0);	//快速排序
		///>对指定的坐标对进行快速排序
		///>  num为数组大小
		///>  col列选择，0按x排，1按y排，2按z排
		///>  dec=0升序排列，dec＝1降序排列
		void	SortXYZ(double *x, double *y, double *z, int num, int colSort, int dec);
		void	SortXY(double *x, double *y, int num, int colSort, int dec);

	public:
		//ASCII码文件的读写
		//int		ReadString(CFile& fr, CString& str);
		//int		GetString(CFile& fr, CString& str);
		BOOL	IsLineEnd_GetString(int result);		//判断GetString返回的值是否表示一行的结束
		//int		ReadString(CFile & fr, char* str);		//读取一行字符串
		//int		GetString(CFile& fr, char* str);		//读取一段字符串（以空格或回车为终止符）
		//int		ReadString(CFile & fr);					//读取一行字符串到临时数组中
		//int		GetString(CFile& fr);					//读取一段字符串（以空格或回车为终止符）到临时数组中

		//char*	GetTempString(void);					//获得临时数组
		//int		GetTempStringLength(void);			//获得临时数组长度
		//void	ZeroTempString(void);					//清空临时数组

		void	ReverseString(char *string, int n);
		int		ReplaceChar(char* pString, char old_char, char new_char);
		int		FindString(char* pString, char* pSearchString, int nStartPos = 0);
		int		ReverseFind(const char* pString, char cFind);	//反向查找指定的字符
		//void	SerializeString(CArchive& ar, CString& str, const short& ver);
		//void	WriteChar(CFile &fw, LPCTSTR lpstr, int nTimes=1);		//写入nTimes次字符串进文件
		//void	WriteLine(CFile &fw, LPCTSTR lpstr, int nTabNum);		//进行nTabNum次tab操作，再写一行字符串	
		//void	WriteLine(CFile &fw, CString str);						//写一行数据(包括回车),是WriteString与WriteReturn的组合
		//void	WriteString(CFile &fw, CString str, int nTabNum=0);	//写一串数据
		//void	WriteString(CFile &fw, double value, int n=6);			//写一个双精度数据
		//void	WriteString(CFile &fw, long value);					//写一个长整形数据
		//void	WriteReturn(CFile& fw);								//写一个回车
		//void	WriteXY(CFile& fw, double x, double y, char cSplit=',');	//写X,Y数据
		//void	WriteXY(CFile& fw, double& x, double& y, double& z, char cSplit);

		//BOOL	WriteFile(LPCTSTR lpSaveFileName, void* pBuffer, DWORD nBufferSize);	//快速保存指定内容

		////获得设置临时错误信息
		//void	SetErrorInfo(LPCTSTR lpszErrorInfo);
		//CString GetErrorInfo(void);

	public:
		void	ExchangeXY(double& x, double& y);	//x,y交换位置
		void	Swap(double& x, double& y);	//x,y交换位置
		void	Swap(float& x, float& y);		//x,y交换位置

		////为了写元素类型(int 或 short)型
		//void	WriteElementType(CArchive& ar, int nType, const short& ver);
		//void	ReadElementType(CArchive& ar, int &nType, const short& ver);

	//	//Progress
	//	void	SetProgress(CProgressCtrl* pProgress);
	//	CProgressCtrl* GetProgress(void);
	//	void	SetProgressPos(int nPos);
		//Convert a string to uppercase
		static char* StrUpr(char* str);

		CString GetSplitPath(/*const*/ CString sFullPathName, CString context = _T("ext"));

		//split the path into given strings
#ifdef _QT_VERSION
		static bool SplitPath(const char* fullPath, char* drive, char* dir, char* fname, char* ext);
		static bool SplitPath(const wchar_t* fullPath, wchar_t* drive, wchar_t* dir, wchar_t* fname, wchar_t* ext);
		// static QColor ulongToQColor(unsigned long color);
#endif

	//对散点数据，获得其外轮廓曲线，返回为轮廓点个数，坐标保存在参数x、y中
		int		GetOutline(int num, double *x, double *y);
		// 得到散点的凸包，传入原始点集p大小为n，返回值为凸包大小,凸包点在convex上
		int		GetConvexHull(int n, CPoint2D* s_points, CPoint2D* convex, int maxsize = 1, int dir = 1);
		//计算直线与线段的交点，成功返回1，若无，返回0，若重合，返回2. ww 2015-10-27
		//参数 a,b为直线向量，lx0,ly0为直线上一点坐标，（sx1,sy1)(sx2,sy2)为线段两端点，若存在交点(cx,cy)为交点坐标
		int		SegLineCrossPoint(double a, double b, double lx0, double ly0,
			double sx1, double sy1, double sx2, double sy2, double& cx, double& cy);

		////xml格式版本号
		//void	SetXmlVersion(double dVer);
		//double	GetXmlVersion();

		//编码方式
		//void	ConvertGBKToUTF8(CString& strGBK, bool checkCodec = true);
		//void	SetCodeType(DWORD nType);
		//DWORD	GetCodeType();

		//打印旋转
		void	SetPrintRotatePt(CPoint pt);
		CPoint	GetPrintRotatePt();
		void	SetPrintRotateAngle(double angle);
		double	GetPrintRotateAngle();

		//空符号显示样式
		void	SetInsertDrawMode(DWORD mode);
		DWORD	GetInsertDrawMode();

		//点字小数位数，-1为不控制位数
		void	SetTxtDecimalDgts(int i);
		int		GetTxtDecimalDgts();

		//保存缩略图
		void	EnableSaveThumbImage(BOOL bSave);
		BOOL	IsSaveThumbImage();

		//反走样开关
		void EnalbeAntialias(BOOL bAntialias);
		BOOL IsAntialias();

		//执行指定命令
		HANDLE	ExecuteCommand(LPCTSTR lpFileCommand, LPCTSTR lpFileParameters, LPCTSTR lpFileDirectory, int nWinShow = SW_SHOW);

		//获取模块路径
		CString	GetModulePath();

		int	GetDPIX(int x);
		int	GetDPIY(int y);
		CPoint GetDPIPoint(CPoint pt);
		CRect GetDPIRect(CRect rt);
		CSize GetDPISize(CSize sz);
	public:
		///move from Pline.h
		void	enspl(double *x, double *y, int n, int k, double t, double *s);	//光滑不等距插值；k=-1,t插值点的x坐标，s为多项式系数长度为5，s[0]，s[1]，s[2]，s[3]为插值点所在子区间多项式系数，s[4]为返回的y值  （最优）
		double	enlgr(double *x, double *y, int n, double t);				//一元全区间不等距（拉格朗日）（少用）
		double	enlg3(double *x, double *y, int n, double t);				//一元三点不等距（拉格朗日）（少用）
		double	enpqs(double *x, double *y, int n, double t);				//连分式不等距（少用）
		double	enhmt(double *x, double *y, double *dy, int n, double t);	//埃尔米特不等距插值，dy为n个不等距节点上的一阶导数值
		double	enatk(double *x, double *y, int n, double t, double dEps);	//埃特金不等距插值 dEps插值精度,（少用）

		double	espl1(double *x, double *y, int n, double *dy, double *ddy, double *t, int m, double *z, double *dz, double *ddz);//第一种边界条件的三次样条插值
		//三次样条插值说明：x,y,dy,ddy数组长度为n，dy[0]存放左端点的一阶导数，dy[n-1]存放右端点的一阶导数，返回n个节点的一阶倒数，ddy为二阶导数，t为要插值的节点值，长度为m，返回z，dz，ddz分别为节点处插值，一阶导数和二阶导数。
		double	espl2(double *x, double *y, int n, double *dy, double *ddy, double *t, int m, double *z, double *dz, double *ddz);//第二种边界条件的三次样条插值，ddy[0]存放左端点的一阶导数，ddy[n-1]存放右端点的二阶导数
		double	espl3(double *x, double *y, int n, double *dy, double *ddy, double *t, int m, double *z, double *dz, double *ddz);//第三种边界条件的三次样条插值，条件满足y[0]=y[n-1];

		///////////////////////////////////////曲线拟合
		//拟合出的曲线计算：yy=a[0]+a[1]*xx+a[2]*xx*xx+a[3]*xx*xx*xx+a[4]*xx*xx*xx*xx;
		void	hpir1(double *x, double *y, int n, double *a, int m, double *dt);//最小二乘法曲线拟合,n为已知数据点个数，m为多项式项数，即最高x的（m－1）次方，m<n,m<20,a为返回的多项式系数长度为m，dt为长度为3的数组，返回误差。
		void	hchir(double *x, double *y, int n, double *a, int m);			//切比雪夫曲线拟合，n为已知数据点个数，m为多项式项数，m<n,m<20,a为返回的多项式系数，长度为m+1,a[m]返回多项式偏差的最大值。

		//对（x，y）序列数据做y=ax+b线性回归
		void	isqt1(double *x, double *y, int n, double *a, double *dt);	//一元线性回归，返回b=a[0],a=a[1]；dt[0]:返回偏差平方和；dt[1]平均标准偏差；dt[2]回归平方和；dt[3]最大偏差；dt[4]最小偏差；dt[5]偏差平均值；

		void	ilog1(int n, double *x, double *y, double t, double *a);	//半对数拟合，要求y[i]>0，t为对数的底数t>0，a数组长度为7，a[0]:拟合函数y=b*pow(t,ax)中的b，a[1]为拟合式中的a，a[2]为偏差平方和,a[3]为平均标准偏差,a[4]为最大偏差,a[5]为最小偏差,a[6]偏差平均值
		void	ilog2(int n, double *x, double *y, double *a);				//对数拟合，要求x[i]>0;y[i]>0，a数组长度为7，a[0]为拟合函数y=b*pow(x,a)中的b，a[1]为拟合式中的a，a[2]为偏差平方和,a[3]为平均标准偏差,a[4]为最大偏差,a[5]为最小偏差,a[6]偏差平均值

		__int64 IntegerTransfer(__int64 vv);
	protected:
		static int _compare_double_asc(const void *d1, const void *d2);		//升序排列
		static int _compare_double_dec(const void *d1, const void *d2);		//降序排列
		//二维指针数组排序函数 ww 2017-6-29
		static int _compare_double_pointer_asc(const void *d1, const void *d2);		//指针数组升序排列
		static int _compare_double_pointer_dec(const void *d1, const void *d2);		//指针数组降序排列
	};
};
using namespace GBase;
extern GBase::CBaseFunction Gbf;

extern "C"	AFX_EXT_API GBase::CBaseFunction*	WINAPI GGetBaseFunction();
extern "C"	AFX_EXT_API GBase::CBaseFunction*	GGetPublicFunction();
extern "C"  AFX_EXT_API BOOL*			WINAPI AfxGetNo_Trim_Zero();
extern "C"	AFX_EXT_API void			WINAPI SetVert(TRIVERTEX &v, int x, int y, COLORREF cr);

//extern CString	m_strPathModule;	//当前模块路径
//extern HWND		m_hWndModule;		//当前模块主窗口句柄
extern "C"	AFX_EXT_API void			WINAPI AfxSetModulePath(CString strPath);
extern "C"	AFX_EXT_API HWND			WINAPI AfxGetModuleHwnd();
extern "C"	AFX_EXT_API void			WINAPI AfxSetModuleHwnd(HWND hWnd);
#ifdef _QT_VERSION
extern "C"  AFX_EXT_API void			WINAPI DeleteFile(CString strFile);
#endif //_QT_VERSION

//extern "C"	TRIVERTEX AFX_EXT_DATA vert[5];
//extern "C"	GRADIENT_TRIANGLE AFX_EXT_DATA gTRi[4];
//extern "C"	double AFX_EXT_DATA __z[4];
#ifdef _QT_VERSION //Qt's similiar functions as WINAPI  --ww 2017.12.28 
// read or write ini file
extern "C" AFX_EXT_API DWORD GetPrivateProfileString(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName);
extern "C" AFX_EXT_API DWORD GetPrivateProfileSection(LPCTSTR lpAppName, LPTSTR lpReturnedString, DWORD nSize, LPCTSTR lpFileName);
extern "C" AFX_EXT_API BOOL WritePrivateProfileString(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString, LPCSTR lpFileName);
//retrieves the  path for the file that contains the specified module that the current process owns
extern "C" AFX_EXT_API DWORD GetModuleFileName(void* hModule, LPTSTR lpFilename, DWORD nSize);


extern "C" AFX_EXT_API void GetLocalTime(SYSTEMTIME* t);


extern "C" AFX_EXT_API int MultiByteToWideChar(
	UINT CodePage,         // code page
	DWORD dwFlags,         // character-type options
	LPCSTR lpMultiByteStr, // string to map
	int cbMultiByte,       // number of bytes in string
	LPWSTR lpWideCharStr,  // wide-character buffer
	int cchWideChar        // size of buffer);
);

extern "C" AFX_EXT_API int WideCharToMultiByte(
	UINT CodePage,            // code page
	DWORD dwFlags,            // performance and mapping flags
	LPCWSTR lpWideCharStr,    // wide-character string
	int cchWideChar,          // number of chars in string.
	LPSTR lpMultiByteStr,     // buffer for new string
	int cbMultiByte,          // size of buffer
	LPCSTR lpDefaultChar,     // default for unmappable chars
	LPBOOL lpUsedDefaultChar  // set when default char used);
);

#endif

#define AfxGetDPIX(x) AfxGetBaseFunction()->GetDPIX(x)
#define AfxGetDPIY(y) AfxGetBaseFunction()->GetDPIY(y)
#define AfxGetDPIPoint(pt) AfxGetBaseFunction()->GetDPIPoint(pt)
#define AfxGetDPIRect(rt) AfxGetBaseFunction()->GetDPIRect(rt)
#define AfxGetDPISize(sz) AfxGetBaseFunction()->GetDPISize(sz)
//extern "C"
//{
//	AFX_EXT_API TRIVERTEX*				WINAPI AfxGetvert();
//	AFX_EXT_API GRADIENT_TRIANGLE*		WINAPI AfxGetgTRi();
//	AFX_EXT_API double*					WINAPI AfxGet__z();
//};


///////////////////////////////////////////////////////////////////
//////插值函数用法
//	dx=(x[pnum-1]-x[0])/num;
//	fw.WriteString("\nlayer m 原始线 \npline\n");
//	for(j=0;j<pnum;j++)
//	{
//		str.Format("%lf,%lf\n",x[j],y[j]);
//		fw.WriteString(str);
//	}

//	if(m_mode==0)//线性插值;
//	{
//		double y0;
//		fw.WriteString("\nlayer m 线性插值 \npline\n");
//		for(j=0;j<num;j++)
//		{
//			xx=x[0]+dx*j;
//			bf.LineValue(y0,x,y,pnum,xx,TRUE,FALSE);
//			str.Format("%lf,%lf\n",xx,y0);
//			fw.WriteString(str);
//		}
//	}
//	if(m_mode==1)//光滑不等距插值;
//	{
//		fw.WriteString("\nlayer m 光滑不等距插值 \npline\n");
//		for(j=0;j<num;j++)
//		{
//			xx=x[0]+dx*j;
//			bf.enspl(x,y,pnum,-1,xx,a);
//			str.Format("%lf,%lf\n",xx,a[4]);
//			fw.WriteString(str);
//		}
//	}
//	if(m_mode==2)//三次样条插值;
//	{
//		fw.WriteString("\nlayer m 三次样条插值 \npline\n");
//		dy[0]=(y[1]-y[0])/(x[1]-x[0]);
//		dy[pnum-1]=(y[pnum-1]-y[pnum-2])/(x[pnum-1]-x[pnum-2]);
//		dfcreate1(num);
//		for(j=0;j<num;j++)
//		{
//			t[j]=x[0]+j*dx;
//		}
//		bf.espl1(x,y,pnum,dy,dyy,t,num,z,dz,ddz);
//		for(j=0;j<num;j++)
//		{
//			str.Format("%lf,%lf\n",t[j],z[j]);
//			fw.WriteString(str);
//		}
//	}
//	if(m_mode==3)//最小二乘曲线拟合;
//	{
//		if(pnum<m_time)
//		{
//			str.Format("原数据点个数＝%d,多项式项数只能小于 %d！",pnum,pnum);
//			::AfxMessageBox(str);return;
//		}
//		if(m_time>=20){::AfxMessageBox("多项式项数只能小于 20！");return;}
//   	fw.WriteString("\nlayer m 最小二乘\npline\n");
//		sum=0;
//		for(j=0;j<pnum;j++)
//		{
//			sum=sum+x[j];
//		}
//		sum=sum/pnum;

//		bf.hpir1(x,y,pnum,a,m_time,dt);//m_time次多项式
//		for(j=0;j<num;j++)
//		{
//			xx=x[0]+dx*j;
//			zz=xx-sum;	
//			yy=0;
//			for(int i=0;i<m_time;i++)
//			{
//				yy=yy+a[i]*pow(zz,i);
//			}
//			//yy=a[0]+a[1]*pow(zz,1)+a[2]*pow(zz,2)+a[3]*pow(zz,3)+a[4]*pow(zz,4)+a[5]*pow(zz,5)+a[6]*pow(zz,6)+a[7]*pow(zz,7);
//			//yy=a[0]+a[1]*zz+a[2]*zz*zz+a[3]*zz*zz*zz+a[4]*zz*zz*zz*zz+a[5]*zz*zz*zz*zz*zz+a[6]*zz*zz*zz*zz*zz*zz+a[7]*zz*zz*zz*zz*zz*zz*zz;
//			str.Format("%lf,%lf\n",xx,yy);
//			fw.WriteString(str);
//		}
//	}
//	if(m_mode==4)//切比雪夫曲线拟合;
//	{
//		if(pnum<m_time)
//		{
//			str.Format("原数据点个数＝%d,多项式项数只能小于 %d！",pnum,pnum);
//			::AfxMessageBox(str);return;
//		}
//		if(m_time>=20){::AfxMessageBox("多项式项数只能小于 20！");return;}
//		fw.WriteString("\nlayer m 切比雪夫曲线拟合\n");

//		bf.hchir(x,y,pnum,a,m_time);       //m_time次多项式
//		fw.WriteString("\npline\n");
//		for(j=0;j<num;j++)
//		{
//			xx=x[0]+dx*j;
//			yy=0.0;

//			for(int i=0;i<m_time;i++)
//			{
//				yy=yy+a[i]*pow(xx,i);
//			}
////		yy=a[0]+a[1]*xx+a[2]*xx*xx+a[3]*xx*xx*xx+a[4]*xx*xx*xx*xx;
//			str.Format("%lf,%lf\n",xx,yy);
//			fw.WriteString(str);
//		}
//	}
//	if(m_mode==5)//埃特金不等距插值;
//	{
//		fw.WriteString("\nlayer m 埃特金不等距插值\n");
//		fw.WriteString("\npline\n");
//		double eps=fabs((y[pnum-1]-y[0])/10000.0);
//		for(j=0;j<num;j++)
//		{
//			xx=x[0]+dx*j;
//			yy=bf.enatk(x,y,pnum,xx,eps);
//			str.Format("%lf,%lf\n",xx,yy);
//			fw.WriteString(str);
//		}
//   }
//	if(m_mode==6)//一元全区间不等距（拉格朗日）;
//	{
//		fw.WriteString("\nlayer m 一元全区间不等距\n");
//		fw.WriteString("\npline\n");
//		for(j=0;j<num;j++)
//		{
//			xx=x[0]+dx*j;
//			yy=bf.enlgr(x,y,pnum,xx);
//			str.Format("%lf,%lf\n",xx,yy);
//			fw.WriteString(str);
//		}
//	}
//	if(m_mode==7)//一元三点不等距（拉格朗日）;
//	{
//		fw.WriteString("\nlayer m 一元三点不等距\n");
//		fw.WriteString("\npline\n");
//		for(j=0;j<num;j++)
//		{
//			xx=x[0]+dx*j;
//			yy=bf.enlg3(x,y,pnum,xx);
//			str.Format("%lf,%lf\n",xx,yy);
//			fw.WriteString(str);
//		}
//	}
//	if(m_mode==8)//连分式不等距;
//	{
//		fw.WriteString("\nlayer m 连分式不等距\n");
//		fw.WriteString("\npline\n");
//		for(j=0;j<num;j++)
//		{
//			xx=x[0]+dx*j;
//			yy=bf.enpqs(x,y,pnum,xx);
//			str.Format("%lf,%lf\n",xx,yy);
//			fw.WriteString(str);
//		}
//	}

template<typename T>
void DeepEraseVector(std::vector<T>& vec)
{
	for (int i = 0; i < (int)vec.size(); i++)
	{
		if (NULL != vec[i])
			delete vec[i];
	}
	vec.clear();
}