#pragma warning( push ,0)
#include <cassert>
#include "ObjWell.h"
#include "ObjWelllog.h"
#include "ObjWelllogRound.h"
// #include "ObjWellTrack.h"
// #include "ObjectFolder.h"
// #include "ObjProject.h"
// #include "ViewInfoMetaProperty.h"
#include <QLibrary>
#include <QCoreApplication>
#include <QDir>
// #include "ObjectEvent.h"
#include <QSettings>
#include <QTextCodec>

#pragma warning( pop )

BEGIN_OSGDATAMODEL_NAMESPACE;
CObjWell *g_pObjWell(NULL);

CObjWell::CObjWell()
{
	m_XYZRlev=0.125;
	m_strWellImage = "well" + QString::number( qAbs( qrand()%11) ) + ".png";
    // SetIconName( "well.png");
    // AddChild(new CObjectFolder(GetClassID_SingleMethodFolder()) );//
    // AddChild(new CObjectFolder(GetClassID_WorkflowFolder()) );//
    // AddChild(new CObjectFolder(GetClassID_SingleWellMapFolder()) );//
	m_StartDep=-9999.0,m_EndDep=-9999.0,m_Rlev=0.125;
	m_XYZStartDep=-9999;
	m_XYZEndDep=-9999;

	m_pCurrentWelllogRound=NULL;
	isFLAG=0;
    // connect( (const QObject*)( &GetObjectEvent() ),SIGNAL(RefreshWellMessage(QString,QObject*)),this,SLOT(slotWellMessage(QString)));
}
// void CObjWell::slotWellMessage(QString slffile)
// {
// 	QString slf1=slffile;
// 	slf1.replace("\\","/");
// 	QString slf2=m_WellFileName;
// 	slf2.replace("\\","/");
// 	int index=slffile.lastIndexOf(".",-1,Qt::CaseInsensitive);
// 	if(index>-1) {
// 		slf1=slf1.left(index);
// 	}
// 	index=slf2.lastIndexOf(".",-1,Qt::CaseInsensitive);
// 	if(index>-1) {
// 		slf2=slf2.left(index);
// 	}
// 	slf2.toUpper();
// 	slf1.toUpper();
// 	if(slf1==slf2) {
// 		LoadXYZ(true);
// 	}
// }
// //根据folderid找到对应的folder，如果没有则创建
// CObjectFolder* CObjWell::GetTragetFolder(QUuid aFolderTypeid)
// {
// 	CObjectFolder* target=dynamic_cast<CObjectFolder*>(GetChildByType(aFolderTypeid));
// 	if(target==NULL){
// 		target=new CObjectFolder(aFolderTypeid);
// 		CBaseObjectImpl::AddChild(target,true);
// 	}
// 	return target;
// }

//往井次下加入曲线时，根据曲线的类型返回其对应的目录id
QUuid CObjWell::GetTragetFolderID(QUuid aLogTypeid)
{
//	if(aLogTypeid==GetClassID_WellLog()) return GetClassID_WellLogFolder();
//	else 
	if(aLogTypeid==GetClassID_WellTrajectory()) return GetClassID_WellTrajectoryFolder();
//	else if(aLogTypeid==GetClassID_WellLogWavefile()) return GetClassID_WellLogWavefileFolder();
//	else if(aLogTypeid==GetClassID_WellLogBIN()) return GetClassID_WellLogBINFolder();
//	else if(aLogTypeid==GetClassID_WellLogFMT()) return GetClassID_WellLogFMTFolder();
//	else if(aLogTypeid==GetClassID_WellLogINP()) return GetClassID_WellLogINPFolder();
//	else if(aLogTypeid==GetClassID_WellLogTABLE()) return GetClassID_WellLogTABLEFolder();
//	else if(aLogTypeid==GetClassID_WellLogTDT()) return GetClassID_WellLogTDTFolder();
	else return GetClassID_GeneralFolder();
}

// bool CObjWell::AddChild(PaiObject* pChild, bool mountNow )
// {
// 	if(!pChild) return false;
// 	if(GetTragetFolderID(pChild->GetTypeID())!=GetClassID_GeneralFolder())
// 		GetTragetFolder(GetTragetFolderID(pChild->GetTypeID()))->AddChild(pChild,mountNow);
// 	else
// 		CBaseObjectImpl::AddChild(pChild,true);
// 	return true;
// }

WellHead &CObjWell::GetWellHead()
{
	return m_WellHead;
}
void CObjWell::SaveWellHead(QString wellfilename)
{
	if(wellfilename.isEmpty()) return;
	CLogIO * logio=new CLogIO();
	if(!logio->Open(wellfilename.toStdString().c_str(),CSlfIO::modeRead))
	{
		if(!logio->Open(wellfilename.toStdString().c_str(),CSlfIO::modeCreate)) { 
			QString aa=wellfilename+"文件打开失败，请检查！";
			return;
		}
	}
	Slf_FILE_MESSAGE mssage;
	logio->GetFileMessage(mssage);
	mssage.azca=m_WellHead.azca;
	mssage.Altitude=m_WellHead.earthEle;
	mssage.Kelly=ConvertDataByString(QString::number(m_WellHead.dEle));
	mssage.TVD=m_WellHead.tvd;
	mssage.Xcoor=m_WellHead.x;
	mssage.Ycoor=m_WellHead.y;
	mssage.X0=m_WellHead.dxe;
	mssage.Y0=m_WellHead.dyn;
	mssage.Z0=m_WellHead.z;
	mssage.StartDepth=m_WellHead.depth;

	logio->SetFileMessage(mssage);
	if(wellfilename.endsWith(".well",Qt::CaseInsensitive)){
		m_DbWell.SetAsl(m_WellHead.earthEle);
		m_DbWell.SetBsl(m_WellHead.dEle);
		m_DbWell.SetXCode(m_WellHead.x);
		m_DbWell.SetYCode(m_WellHead.y);
	}

	delete logio;
}
// int CObjWell::GetAllWellRound(QList<PaiObject*> &wellroundchildren)
// {
// 	this->GetObjectByType(wellroundchildren,GetClassID_WellLogRound());
// 	return wellroundchildren.size();
// }

// int CObjWell::GetWellRoundCount()
// {
// 	QList<pai::objectmodel::PaiObject*>  wellroundchildren;
// 	this->GetObjectByType(wellroundchildren,GetClassID_WellLogRound());
// 	return wellroundchildren.size();
// }
void CObjWell::SetCurrentObjWellRound(CObjWelllogRound*pWellRound)
{
	m_pCurrentWelllogRound=pWellRound;
}

CObjWelllogRound* CObjWell::GetCurrentObjWellRound()
{
/*    QList<pai::objectmodel::PaiObject*>  wellroundchildren;
    GetObjectByType(wellroundchildren,GetClassID_WellLogRound());
    if(!m_pCurrentWelllogRound) {
        if(wellroundchildren.size()) {
            m_pCurrentWelllogRound=(CObjWelllogRound*)wellroundchildren[0];
            return (CObjWelllogRound*)wellroundchildren[0];
        }
        else return NULL;
    }
    else */return m_pCurrentWelllogRound;
}

CObjWell::~CObjWell()
{
	if(g_pObjWell==this) g_pObjWell=NULL;
}

QUuid CObjWell::GetTypeID()const
{
	return GetClassID_Well();
}

double CObjWell::GetTopWellLogDepth()
{
	return m_StartDep;
}

// bool CObjWell::isExistsName(QString name)
// {
// 	QList<PaiObject*> objs;
// 	if(this->GetParent() != NULL)
// 	{
// 		 GetParent()->GetChildren(objs);
// 	}else
// 	{
// 		GetProject()->GetWellsFolder(true)->GetPaiObject()->GetChildren(objs);
// 	}
	
	
// 	foreach(PaiObject* obj, objs)
// 	{
// 		CObjWell* pWell = dynamic_cast<CObjWell*>(obj);
// 		if(pWell != NULL &&  pWell != this && pWell->GetName().compare(name,Qt::CaseInsensitive)==0)
// 		{
// 			return true;
// 		}
// 	}
// 	return false;
// }

// void CObjWell::CopyFrom( CBaseObject *pOSGObjectOther )
// {
// 	CBaseObject::CopyFrom( pOSGObjectOther );

// 	CObjWell *pWell= dynamic_cast<CObjWell *>( pOSGObjectOther );
// 	if( pWell )
// 	{
// 		m_WellHead=pWell->GetWellHead();
// 		m_DbWell= pWell->m_DbWell ;
// 	}
// }

double CObjWell::GetBottomWellLogDepth()
{
	return m_EndDep;
}

// bool CObjWell::Serialize( CObjectArchive &ar  )
// {
// 	m_vX.Serialize(ar);
// 	m_vY.Serialize(ar);
// 	m_vZ.Serialize(ar);
// 	if(ar.IsStoring())
// 	{

// 		BEGIN_WRITE_OBJECT( ar,1 );

// 		BEGIN_WRITE_BLOCK( ar, 1);

// 		ar << m_strWellImage;
// 		ar << m_WellFileName;
// 		ar << m_WellCode;
// 		ar << m_StartDep;
// 		ar << m_EndDep;
// 		ar << m_Rlev;

// 		CBaseObjectImpl::Serialize( ar );
// 		END_WRITE_BLOCK( ar, 1 );

// 		END_WRITE_OBJECT( ar );
// 	}
// 	else
// 	{
// 		BEGIN_READ_OBJECT( ar,1 );

// 		BEGIN_READ_BLOCK( 1 );

// 		ar >> m_strWellImage;
// 		ar >> m_WellFileName;
// 		ar >> m_WellCode;
// 		ar >> m_StartDep;
// 		ar >> m_EndDep;
// 		ar >> m_Rlev;
// 		CBaseObjectImpl::Serialize( ar );

// 		END_READ_BLOCK( 1 );

// 		END_READ_OBJECT( ar );
// 	}
// 	return true;
// }

// bool CObjWell::GetXYZByMD(float fMD,double &x,double &y,double &z )
// {
// 	int nXSize = (int)m_vX.size();
// 	if(nXSize<1)
// 	{
// 		LoadXYZ();
// 		nXSize = (int)m_vX.size();
// 	}
// 	x=m_WellHead.x;
// 	y=m_WellHead.y;
// 	z=m_WellHead.z;
// 	if(nXSize<=1) return true;
// 	bool bSuccess(false);
// 	if(nXSize) {
// 		if(m_StartDep==-9999.0) {//离散数据
// 			// get m_vMD
// 			double dSum = 0;
// 			double old_dSum = 0;
// 			for( long i = 1 ;i<nXSize;++i )
// 			{
// 				double dx = m_vX.m_vProperty[i] - m_vX.m_vProperty[i-1];
// 				double dy = m_vY.m_vProperty[i] - m_vY.m_vProperty[i-1];
// 				double dz = m_vZ.m_vProperty[i] - m_vZ.m_vProperty[i-1];
// 				old_dSum=dSum;
// 				dSum +=sqrt(dx*dx + dy*dy + dz*dz ) ;
// 				if(dSum>fMD&&old_dSum<=fMD) {
// 					x=m_vX.m_vProperty[i];
// 					y=m_vY.m_vProperty[i];
// 					z=m_vZ.m_vProperty[i];
// 					return true;
// 				}
// 			}
// 			return bSuccess;
// 		}
// 	}
// 	int nIndex=(fMD-m_XYZStartDep)/m_XYZRlev;
// 	if(nIndex<0) nIndex=0;
// 	if(nIndex>=nXSize) nIndex=nXSize-1;
// 	if( nIndex < nXSize && nIndex>=0 )
// 	{
// 		x = m_vX.m_vProperty[nIndex];
// 		y = m_vY.m_vProperty[nIndex];
// 		z = m_vZ.m_vProperty[nIndex];
// 		bSuccess = true;
// 	}
// 	return bSuccess;
// }

void CObjWell::ClearXYZ()
{
	m_vX.clear();
	m_vY.clear();
	m_vZ.clear();
}

// bool CObjWell::LoadXYZ(bool isreCreateXYZ)
// {
// 	if(m_WellFileName.isEmpty()) return false;
// 	CMemRdWt * logio=new CMemRdWt();
// 	if(!logio->Open(m_WellFileName.toStdString().c_str(),CSlfIO::modeRead))
// 	{
// 		delete logio;
// 		QString aa=m_WellFileName+"文件打开失败，请检查！";
// 		return false;
// 	}
// 	Slf_FILE_MESSAGE mess;
// 	logio->GetFileMessage(mess);

// 	QString temp = ::GetConfPath()+"data.ini";
// 	QSettings settings(temp,QSettings::IniFormat,0);
// 	settings.setIniCodec(QTextCodec::codecForName("UTF-8"));
// 	QStringList serials=settings.value("wellType",0).toStringList();
// 	int type = serials.indexOf(mess.WellType);

// 	if(type>-1) m_strWellImage = "well" + QString::number(type) + ".png";

// 	logio->DiscardObject("DEVI");
// 	logio->DiscardObject("AZIM");

// 	//if(isreCreateXYZ)
// 	{
// 		QList<PaiObject*>childs;
// 		int rcount=GetAllWellRound(childs);
// 		int flag=0;
// 		for(int j=0;j<rcount;j++)//遍历该井下所有井次
// 		{
// 			CMemRdWt * logio1 = new CMemRdWt();
// 			CObjWelllogRound*pRound = dynamic_cast<CObjWelllogRound*>(childs[j]);
// 			if(!pRound) continue;
// 			QString slf = this->GetWellFileName();
// 			if(!logio1->Open(slf.toStdString().c_str(),CSlfIO::modeRead))
// 			{
// 				delete logio1;
// 				delete logio;
// 				QString aa=m_WellFileName+"文件打开失败，请检查！";
// 				continue;
// 			}

// 			if(type<0){
// 				Slf_FILE_MESSAGE mess1;
// 				logio1->GetFileMessage(mess1);
// 				int type=serials.indexOf(mess1.WellType);

// 				if(type>-1) {
// 					m_strWellImage = "well" + QString::number(type) + ".png";
// 					strcpy(mess.WellType,mess1.WellType);
// 					logio->SetFileMessage(mess);
// 				}
// 			}
// 			int iAZIM = -1, iDev=-1, ishaveazim=0;
// 			{
// 				int iAZIM1=-1,iDev1=-1;
// 				QStringList azims=GetSimilarCurves("AZIM");
// 				QString azim;
// 				QString AZIM1;
// 				QString DEVI1;
// 				foreach(QString cname,azims)
// 				{
// 					iAZIM1=logio->OpenCurve(cname.toStdString().c_str());
// 					if(iAZIM1>-1) {
// 						AZIM1=cname;
// 						break;
// 					}
// 				}
// 				QStringList devis=GetSimilarCurves("DEVI");
// 				QString dev;
// 				foreach(QString cname,devis)
// 				{
// 					iDev1=logio->OpenCurve(cname.toStdString().c_str());
// 					if(iDev1>-1)
// 					{
// 						DEVI1/*AZIM1*/ = cname;
// 						break;
// 					}
// 				}

// 				////
// 				foreach(QString cname, azims)
// 				{
// 					iAZIM = logio1->OpenCurve(cname.toStdString().c_str());
// 					if(iAZIM>-1) {
// 						azim=cname;
// 						break;
// 					}
// 				}
// 				foreach(QString cname, devis)
// 				{
// 					iDev = logio1->OpenCurve(cname.toStdString().c_str());
// 					if(iDev>-1) {
// 						dev=cname;
// 						break;
// 					}
// 				}
// 				if(iAZIM>-1){//井次中有方位
// 					if(iAZIM1<0) //井中没有方位
// 						logio->CopyFromFile(*logio1,(char *)azim.toStdString().c_str());
// 					else {//井中有方位
// 						iAZIM = logio->OpenCurve((char *)azim.toStdString().c_str());
// 						if(iAZIM<0) {
// 							logio->CopyFromFile(*logio1,(char *)azim.toStdString().c_str());
// 							iAZIM=logio->OpenCurve((char *)azim.toStdString().c_str());
// 						}
// 						if(iAZIM<0) {
// 							delete logio1;
// 							delete logio;
// 							return false;
// 						}
// 						Slf_CURVE curveinf;
// 						logio->GetCurveInfo(iAZIM,&curveinf);
// 						int count=(curveinf.EndDepth-curveinf.StartDepth)/curveinf.DepLevel+1.5;
// 						float *val=new float[count+1];
// 						logio->ReadCurve(iAZIM,curveinf.StartDepth,count,val);
// 						float sdep=curveinf.StartDepth;
// 						float edep=curveinf.EndDepth;
// 						for(int i=0;i<count;i++)
// 						{
// 							if(val[i]!=-9999&&val[i]!=-99999&&val[i]!=-999.25) {
// 								if(sdep==-9999) sdep=i*curveinf.DepLevel+curveinf.StartDepth;
// 								edep=i*curveinf.DepLevel+curveinf.StartDepth;
// 							}
// 						}
// 						logio1->CopyCurve(*logio,sdep,edep,sdep,(char *)azim.toStdString().c_str(),(char *)azim.toStdString().c_str());
// 						delete val;
// 					}

// 					//默认井中没有方位，需要从井次中获取
// 					//logio->CopyFromFile(*logio1,(char *)azim.toStdString().c_str());

// 					flag=1;
// 				}
// 				if(iDev>-1){
// 					if(iDev1<0)
// 						logio->CopyFromFile(*logio1,(char *)dev.toStdString().c_str());
// 					else {
// 						iDev=logio->OpenCurve((char *)dev.toStdString().c_str());
// 						if(iDev<0) {
// 							logio->CopyFromFile(*logio1,(char *)dev.toStdString().c_str());
// 							iDev=logio->OpenCurve((char *)dev.toStdString().c_str());
// 						}
// 						if(iDev<0) {
// 							delete logio1;
// 							delete logio;
// 							return false;
// 						}
// 						Slf_CURVE curveinf;
// 						logio->GetCurveInfo(iDev,&curveinf);
// 						int count=(curveinf.EndDepth-curveinf.StartDepth)/curveinf.DepLevel+1.5;
// 						float *val=new float[count+1];
// 						logio->ReadCurve(iDev,curveinf.StartDepth,count,val);
// 						float sdep=curveinf.StartDepth;
// 						float edep=curveinf.EndDepth;
// 						for(int i=0;i<count;i++)
// 						{
// 							if(val[i]!=-9999&&val[i]!=-99999&&val[i]!=-999.25) {
// 								if(sdep==-9999) sdep=i*curveinf.DepLevel+curveinf.StartDepth;
// 								edep=i*curveinf.DepLevel+curveinf.StartDepth;
// 							}
// 						}
// 						logio1->CopyCurve(*logio,sdep,edep,sdep,(char *)dev.toStdString().c_str(),(char *)dev.toStdString().c_str());
// 						delete val;
// 					}
// 					//默认井中没有井斜，需要从井次中获取
// 					//logio->CopyFromFile(*logio1,(char *)dev.toStdString().c_str());

// 					flag=1;
// 				}
// 			}
// 			delete logio1;
// 		}
// 		if(flag){
// 			logio->DiscardObject("X");
// 			logio->DiscardObject("Y");
// 			logio->DiscardObject("Z");
// 			if(ComputeTrajectory(this,m_WellFileName)<1) {
// 				return false;
// 			}
// 		}
// 	}
// 	int	iX=logio->OpenCurve("X");
// 	int	iY=-1;
// 	int	iZ=-1;
// 	Slf_CURVE acurveinfo;
// 	memset(&acurveinfo,0,sizeof(Slf_CURVE));
// 	if(iX>-1) logio->GetCurveInfo(iX,&acurveinfo);
// 	if(iX<0||mess.Xcoor==0||mess.Ycoor==0)
// 	{
// 		CMemRdWt * logio1=new CMemRdWt();
// 		QString slf=this->GetWellFileName();
// 		if(!logio1->Open(slf.toStdString().c_str(),CSlfIO::modeRead))
// 		{
// 			delete logio1;
// 			delete logio;
// 			QString aa=m_WellFileName+"文件打开失败，请检查！";
// 			return false;
// 		}
// 		if(mess.Xcoor==0||mess.Ycoor==0)
// 		{
// 			logio1->GetFileMessage(mess);
// 			logio->SetFileMessage(mess);
// 			logio->DiscardObject(iX);
// 			logio->DiscardObject(iY);
// 			logio->DiscardObject(iZ);
// 		}
// 		delete logio;
// 		delete logio1;
// 		if(ComputeTrajectory(this,m_WellFileName)<1) {
// 			return false;
// 		}
// 		logio=new CMemRdWt();
// 		logio->Open(m_WellFileName.toStdString().c_str(),CSlfIO::modeRead);
// 		int iAZIM=-1,iDev=-1;
// 		{
// 			QStringList azims=GetSimilarCurves("AZIM");
// 			QString azim;
// 			foreach(QString cname,azims)
// 			{
// 				iAZIM=logio->OpenCurve(cname.toStdString().c_str());
// 				if(iAZIM>-1) {
// 					azim=cname;
// 					break;
// 				}
// 			}
// 			QStringList devis=GetSimilarCurves("DEVI");
// 			QString dev;
// 			foreach(QString cname,devis)
// 			{
// 				iDev=logio->OpenCurve(cname.toStdString().c_str());
// 				if(iDev>-1) {
// 					dev=cname;
// 					break;
// 				}
// 			}
// 		}
// 		if(iAZIM>-1&&iDev>-1)
// 		{
// 			iX=logio->OpenCurve("X");
// 			iY=logio->OpenCurve("Y");
// 			iZ=logio->OpenCurve("Z");
// 			logio->GetCurveInfo(iX,&acurveinfo);

// 			m_XYZRlev=acurveinfo.DepLevel;
// 			m_XYZStartDep=acurveinfo.StartDepth;
// 			m_XYZEndDep=acurveinfo.EndDepth;

// 			int point=(acurveinfo.EndDepth-acurveinfo.StartDepth)/acurveinfo.DepLevel+1.5;
// 			m_vX.resize(point);
// 			m_vY.resize(point);
// 			m_vZ.resize(point);
// 			if(acurveinfo.RepCode==REPR_DOUBLE) {
// 				logio->ReadCurve(iX,acurveinfo.StartDepth,point,(void *)&m_vX.m_vProperty[0]);
// 				logio->ReadCurve(iY,acurveinfo.StartDepth,point,(void *)&m_vY.m_vProperty[0]);
// 				logio->ReadCurve(iZ,acurveinfo.StartDepth,point,(void *)&m_vZ.m_vProperty[0]);
// 			}
// 			else if(acurveinfo.RepCode==REPR_FLOAT) {
// 				FLOATPROPERTY m_vX1;
// 				FLOATPROPERTY m_vY1;
// 				FLOATPROPERTY m_vZ1;
// 				m_vX1.resize(point);
// 				m_vY1.resize(point);
// 				m_vZ1.resize(point);
// 				logio->ReadCurve(iX,acurveinfo.StartDepth,point,(float *)&m_vX1.m_vProperty[0]);
// 				logio->ReadCurve(iY,acurveinfo.StartDepth,point,(float *)&m_vY1.m_vProperty[0]);
// 				logio->ReadCurve(iZ,acurveinfo.StartDepth,point,(float *)&m_vZ1.m_vProperty[0]);
// 				for(int i=0;i<point;i++) {
// 					m_vX.m_vProperty[i]=m_vX1.m_vProperty[i];
// 					m_vY.m_vProperty[i]=m_vY1.m_vProperty[i];
// 					m_vZ.m_vProperty[i]=m_vZ1.m_vProperty[i];
// 				}
// 			}
// 			delete logio;
// 			return true;
// 		}
// 	}
// 	iX=logio->OpenCurve("X");
// 	iY=logio->OpenCurve("Y");
// 	iZ=logio->OpenCurve("Z");
// 	double x=0,y=0;
// 	if(iX>=0&&iY>=0&&iZ>=0) {
// 		logio->GetCurveInfo(iX,&acurveinfo);
// 		if(acurveinfo.DepLevel==0||acurveinfo.DepLevel>=2.226e+008||acurveinfo.StartDepth==acurveinfo.EndDepth&&acurveinfo.DepLevel==acurveinfo.StartDepth)
// 		{
// 			mess.Xcoor=0;
// 			mess.Ycoor=0;
// 			goto next1;
// 		}
// 		m_XYZRlev=acurveinfo.DepLevel;
// 		m_XYZStartDep=acurveinfo.StartDepth;
// 		m_XYZEndDep=acurveinfo.EndDepth;
// 		int point=(acurveinfo.EndDepth-acurveinfo.StartDepth)/acurveinfo.DepLevel+1.5;
// 		if(point<1) point=1;
// 		m_vX.resize(point);
// 		m_vY.resize(point);
// 		m_vZ.resize(point);
		
// 		if(acurveinfo.RepCode==REPR_DOUBLE) {
// 			logio->ReadCurve(iX,acurveinfo.StartDepth,1,(double *)&m_vX.m_vProperty[0]);
// 			x=m_vX.m_vProperty[0];
// 			logio->ReadCurve(iY,acurveinfo.StartDepth,1,(double *)&m_vY.m_vProperty[0]);
// 			y=m_vY.m_vProperty[0];
// 		}
// 		else if(acurveinfo.RepCode==REPR_FLOAT) {
// 			float xx,yy;
// 			logio->ReadCurve(iX,acurveinfo.StartDepth,1,(float *)&xx);
// 			x=xx;
// 			logio->ReadCurve(iY,acurveinfo.StartDepth,1,(float *)&yy);
// 			y=yy;
// 		}
// 		if(x==y&&mess.Xcoor!=0&&mess.Ycoor!=0) {
// next1:
// 			logio->DiscardObject(iX);
// 			logio->DiscardObject(iY);
// 			logio->DiscardObject(iZ);
// 			delete logio;

// 			if(ComputeTrajectory(this,m_WellFileName)<1) {
// 				return false;
// 			}
// 			logio=new CMemRdWt();
// 			logio->Open(m_WellFileName.toStdString().c_str(),CSlfIO::modeRead);
// 			iX=logio->OpenCurve("X");
// 			iY=logio->OpenCurve("Y");
// 			iZ=logio->OpenCurve("Z");
// 			logio->GetCurveInfo(iX,&acurveinfo);
// 			m_XYZRlev=acurveinfo.DepLevel;
// 			m_XYZStartDep=acurveinfo.StartDepth;
// 			m_XYZEndDep=acurveinfo.EndDepth;
// 		}
// 		m_vX.resize(point);
// 		m_vY.resize(point);
// 		m_vZ.resize(point);
// 		if(acurveinfo.RepCode==REPR_DOUBLE) {
// 			logio->ReadCurve(iX,acurveinfo.StartDepth,point,(double *)&m_vX.m_vProperty[0]);
// 			logio->ReadCurve(iY,acurveinfo.StartDepth,point,(double *)&m_vY.m_vProperty[0]);
// 			logio->ReadCurve(iZ,acurveinfo.StartDepth,point,(double *)&m_vZ.m_vProperty[0]);
// 		}
// 		else if(acurveinfo.RepCode==REPR_FLOAT) {
// 			FLOATPROPERTY m_vX1;
// 			FLOATPROPERTY m_vY1;
// 			FLOATPROPERTY m_vZ1;
// 			m_vX1.resize(point);
// 			m_vY1.resize(point);
// 			m_vZ1.resize(point);
// 			logio->ReadCurve(iX,acurveinfo.StartDepth,point,(float *)&m_vX1.m_vProperty[0]);
// 			logio->ReadCurve(iY,acurveinfo.StartDepth,point,(float *)&m_vY1.m_vProperty[0]);
// 			logio->ReadCurve(iZ,acurveinfo.StartDepth,point,(float *)&m_vZ1.m_vProperty[0]);
// 			for(int i=0;i<point;i++) {
// 				m_vX.m_vProperty[i]=m_vX1.m_vProperty[i];
// 				m_vY.m_vProperty[i]=m_vY1.m_vProperty[i];
// 				m_vZ.m_vProperty[i]=m_vZ1.m_vProperty[i];
// 			}
// 		}
// 		if(m_XYZStartDep==m_XYZEndDep&&m_vX.m_vProperty[0]!=mess.Xcoor) m_vX.m_vProperty[0]=mess.Xcoor;
// 		if(m_XYZStartDep==m_XYZEndDep&&m_vY.m_vProperty[0]!=mess.Ycoor) m_vY.m_vProperty[0]=mess.Ycoor;
// 	}
// 	else {
// 		delete logio;
// 		return false;
// 	}
// 	delete logio;
// 	return true;
// }

// bool CObjWell::GetDXDYDZByMD(float fMD,double &x,double &y,double &z )
// {
// 	int nXSize = (int)m_vX.size();
// 	if(nXSize<1)
// 	{
// 		LoadXYZ();
// 		nXSize = (int)m_vX.size();
// 	}
// 	bool bSuccess(false);
// 	if(nXSize) {
// 		if(m_StartDep==-9999.0) {//离散数据
// 			// get m_vMD
// 			double dSum = 0;
// 			double old_dSum = 0;
// 			for( long i = 1 ;i<nXSize;++i )
// 			{
// 				double dx = m_vX.m_vProperty[i] - m_vX.m_vProperty[i-1];
// 				double dy = m_vY.m_vProperty[i] - m_vY.m_vProperty[i-1];
// 				double dz = m_vZ.m_vProperty[i] - m_vZ.m_vProperty[i-1];
// 				old_dSum=dSum;
// 				dSum +=sqrt(dx*dx + dy*dy + dz*dz ) ;
// 				if(dSum>fMD&&old_dSum<=fMD) {
// 					x=m_vX.m_vProperty[i]-m_vX.m_vProperty[0];
// 					y=m_vY.m_vProperty[i]-m_vY.m_vProperty[0];
// 					z=m_vZ.m_vProperty[i]-m_vZ.m_vProperty[0];
// 					return true;
// 				}
// 			}
// 			return bSuccess;
// 		}
// 	}
// 	int nIndex=(fMD-m_XYZStartDep)/m_XYZRlev;
// 	if( nIndex < nXSize && nIndex>=0 )
// 	{
// 		x = m_vX.m_vProperty[nIndex]-m_vX.m_vProperty[0];
// 		y = m_vY.m_vProperty[nIndex]-m_vY.m_vProperty[0];
// 		z = m_vZ.m_vProperty[nIndex]-m_vZ.m_vProperty[0];
// 		bSuccess = true;
// 	}
// 	return bSuccess;
// }
// void CObjWell::SetDepth(CObjWell *pWell)
// {
// 	if(pWell)
// 	{
// 		int roc=pWell->GetWellRoundCount();
// 		if(roc)
// 		{
// 			QList<PaiObject*>childs;
// 			pWell->GetAllWellRound(childs);
// 			double stardep=99999,enddep=-99999;
// 			float rlev=100;
// 			for(int i=0;i<roc;i++)
// 			{
// 				CObjWelllogRound* pWelllogRound=dynamic_cast<CObjWelllogRound*>(childs[i]);
// 				if(!pWelllogRound) continue;
// 				CLogIO * logio=new CLogIO();

// 				if(!logio->Open(pWelllogRound->GetSlfFileName().toStdString().c_str(),CSlfIO::modeReadWrite))
// 				{
// 					delete logio;
// 					break;
// 				}
// 				int curveCount=logio->GetObjectCount();
// 				for(int k1=0;k1<curveCount;k1++)
// 				{
// 					char buf[64];
// 					logio->GetObjectName(k1,buf);
// 					int a=logio->OpenCurve(buf);
// 					if(a>-1)
// 					{
// 						Slf_CURVE acurveinfo;
// 						logio->GetCurveInfo(a,&acurveinfo);
// 						if(acurveinfo.StartDepth<stardep) stardep=acurveinfo.StartDepth;
// 						if(acurveinfo.EndDepth>enddep) enddep=acurveinfo.EndDepth;
// 						if(rlev>acurveinfo.DepLevel) rlev=acurveinfo.DepLevel;
// 					}
// 					else {
// 						int a=logio->OpenWave(buf);
// 						if(a>-1)
// 						{
// 							Slf_WAVE acurveinfo;
// 							logio->GetWaveInfo(a,&acurveinfo);
// 							if(acurveinfo.StartDepth<stardep) stardep=acurveinfo.StartDepth;
// 							if(acurveinfo.EndDepth>enddep) enddep=acurveinfo.EndDepth;
// 							if(rlev>acurveinfo.DepLevel) rlev=acurveinfo.DepLevel;
// 						}
// 					}
// 				}
// 				if(rlev<=0) rlev=0.125;
// 				delete logio;
// 			}
// 			pWell->SetDepth(stardep,enddep,rlev);
// 		}
// 	}
// }
// int CObjWell::ComputeTrajectory(CObjWell *pWell,QString slffilename)
// {
// 	pWell->SetDepth(pWell);
// 	QLibrary Methodlib;
// 	QString PeModulePath=QCoreApplication::applicationDirPath() + QDir::separator() +"TrackPoints.dll";
// 	Methodlib.setFileName(PeModulePath);
// 	Methodlib.load();
// 	typedef int (* LPFNDLLFUNC1)(double azca,double tvd,double dxe,double dyn,double rlev0,double Gldddep,double hoff);
// 	LPFNDLLFUNC1 initTrackPoints;
// 	typedef int (* LPFNDLLFUNC2)(double nDevi,double nAzim,double rlev,double &XE,double &YN,double &ZD,double &HOFF0,double &HOAZ0,double &GTD0,double &AZIM0);
// 	LPFNDLLFUNC2 TrackPoints;
// 	QString initfname="initTrackPoints";
// 	QString funname="TrackPoints";
// 	initTrackPoints = (LPFNDLLFUNC1)(Methodlib.resolve(initfname.toStdString().c_str()));//strDLLFun.toStdString().c_str())
// 	TrackPoints = (LPFNDLLFUNC2)(Methodlib.resolve(funname.toStdString().c_str()));//strDLLFun.toStdString().c_str())
// 	QStringList CurveNames;
// 	int iDev=-1,iAZIM=-1,iX=-1,iY=-1,iZ=-1,iDepth=-1;
// 	Slf_FILE_MESSAGE mssage;

// 	CObjWelllogRound* pWelllogRound;


// 	CMemRdWt * logio=new CMemRdWt();

// 	if(!logio->Open(slffilename.toStdString().c_str(),CSlfIO::modeReadWrite))
// 	{
// 		delete logio;
// 		QString aa=slffilename+"文件打开失败，请检查！";
// 		//		AppendConsole(pai::log::PAI_ERROR,aa);
// 		Methodlib.unload();
// 		return 0;
// 	}
// 	logio->GetFileMessage(mssage);
// 	QString path,wen,slfn;
// 	GetWellNameAndPath(slffilename,wen,path,slfn);
// 	if(slfn.indexOf(".well",0,Qt::CaseInsensitive)==-1)
// 	{
// 		QString slf;
// 		if(strlen(mssage.WellName)==0||mssage.WellName[0]==' ')
// 		{
// 			int len=slffilename.indexOf(".slf",0,Qt::CaseInsensitive);
// 			slf=slffilename.mid(0,len)+".well";
// 		}
// 		else slf=path+"/"+mssage.WellName+".well";
// 		CMemRdWt sf(slf.toStdString().c_str(),CSlfIO::modeReadWrite);
// 		Slf_FILE_MESSAGE sm;
// 		sf.GetFileMessage(sm);
// 		if(sm.Xcoor!=mssage.Xcoor)
// 		{
// 			if(sm.Xcoor>1&&(_finite(sm.Xcoor)&&!_isnan(sm.Xcoor))) mssage.Xcoor=sm.Xcoor;
// 			else if(mssage.Xcoor>1&&(_finite(mssage.Xcoor)&&!_isnan(mssage.Xcoor)))sm.Xcoor=mssage.Xcoor;
// 			if(sm.Ycoor>1&&(_finite(sm.Ycoor)&&!_isnan(sm.Ycoor))) mssage.Ycoor=sm.Ycoor;
// 			else if(mssage.Ycoor>1&&(_finite(mssage.Ycoor)&&!_isnan(mssage.Ycoor)))sm.Ycoor=mssage.Ycoor;
// 			if(sm.azca&&(_finite(sm.azca)&&!_isnan(sm.azca))) mssage.azca=sm.azca;
// 			else if(mssage.azca&&(_finite(mssage.azca)&&!_isnan(mssage.azca)))sm.azca=mssage.azca;
// 			if(sm.Altitude&&(_finite(sm.Altitude)&&!_isnan(sm.Altitude))) mssage.Altitude=sm.Altitude;
// 			else if(mssage.Altitude&&(_finite(mssage.Altitude)&&!_isnan(mssage.Altitude)))sm.Altitude=mssage.Altitude;
// 			if(sm.Kelly&&(_finite(sm.Kelly)&&!_isnan(sm.Kelly))) mssage.Kelly=sm.Kelly;
// 			else if(mssage.Kelly&&(_finite(mssage.Kelly)&&!_isnan(mssage.Kelly)))sm.Kelly=mssage.Kelly;
// 			if(sm.TVD&&(_finite(sm.TVD)&&!_isnan(sm.TVD))) mssage.TVD=sm.TVD;
// 			else if(mssage.TVD&&(_finite(mssage.TVD)&&!_isnan(mssage.TVD)))sm.TVD=mssage.TVD;
// 			if(sm.X0&&(_finite(sm.X0)&&!_isnan(sm.X0))) mssage.X0=sm.X0;
// 			else if(mssage.X0&&(_finite(mssage.X0)&&!_isnan(mssage.X0)))sm.X0=mssage.X0;
// 			if(sm.Y0&&(_finite(sm.Y0)&&!_isnan(sm.Y0))) mssage.Y0=sm.Y0;
// 			else if(mssage.Y0&&(_finite(mssage.Y0)&&!_isnan(mssage.Y0)))sm.Y0=mssage.Y0;
// 			sf.SetFileMessage(sm);
// 			logio->SetFileMessage(mssage);
// 		}
// 	}
// 	int curveCount=logio->GetObjectCount();
// 	//说明从项目或者井节点发起attachSLF,需要读取slf获得井名和井次信息
// 	QString wellname="";
// 	QString wellRoundname="";
// 	QStringList azims=GetSimilarCurves("AZIM");
// 	foreach(QString cname,azims)
// 	{
// 		iAZIM=logio->OpenCurve(cname.toStdString().c_str());
// 		if(iAZIM>-1) break;
// 	}
// 	QStringList devis=GetSimilarCurves("DEVI");
// 	foreach(QString cname,devis)
// 	{
// 		iDev=logio->OpenCurve(cname.toStdString().c_str());
// 		if(iDev>-1) break;
// 	}
// 	Slf_CURVE acurveinfo;
// 	memset(&acurveinfo,0,sizeof(Slf_CURVE));
// 	float AZCA=mssage.azca,TVD=mssage.TVD,X0=mssage.X0,Y0=mssage.Y0;
// 	double XE=X0,YN=Y0;
// 	float Altitude=mssage.Altitude;
// 	float X_COORDINATE=mssage.Xcoor;
// 	float Y_COORDINATE=mssage.Ycoor;//井斜x,y坐标
// 	float KB=ConvertDataByFloat(mssage.Kelly).toFloat();
// 	double HOFF0=0;
// 	double HOAZ0=0,gtd=0;
// 	double AZIM0=0;
// 	if(iAZIM>-1) logio->GetCurveInfo(iAZIM,&acurveinfo);
// 	WellHead &mWellHead=pWell->GetWellHead();

// 	mWellHead.x=X_COORDINATE;
// 	mWellHead.y=Y_COORDINATE;
// 	if(KB==-9999) KB=0;
// 	if(KB==-99999) KB=0;
// 	mWellHead.dEle=KB;
// 	mWellHead.earthEle=Altitude;
// 	mWellHead.depth=acurveinfo.StartDepth;
// 	mWellHead.startDepth=acurveinfo.StartDepth;
// 	mWellHead.azca=AZCA;
// 	mWellHead.endDepth=acurveinfo.EndDepth;
// 	if(TVD==0) TVD=mWellHead.startDepth;
// 	mWellHead.tvd=TVD;

// 	mWellHead.z=mWellHead.earthEle+mWellHead.dEle-TVD;
// 	mWellHead.dxe=X0;
// 	mWellHead.dyn=Y0;

// //	if(mWellHead.tvd==0) mWellHead.tvd=TVD;
// 	double ZD=mWellHead.tvd;
// 	if(mWellHead.tvd==0) ZD=TVD;

// 	//TVD=mWellHead.tvd;

// 	std::vector<double>vX;
// 	std::vector<double>vY;
// 	std::vector<double>vZ;
// 	std::vector<float>vTVD;
// 	if(iAZIM>=0&&iDev>=0&&acurveinfo.DepLevel) {
// 		initTrackPoints(AZCA,TVD,X0,Y0,acurveinfo.DepLevel,30,0);
// 		int point=(mWellHead.endDepth-mWellHead.startDepth)/acurveinfo.DepLevel+1.5;
// 		float *nDevi=new float[point+1];
// 		memset(nDevi,0,sizeof(float)*point);
// 		float *nAzim=new float[point+1];
// 		memset(nAzim,0,sizeof(float)*point);
// 		vX.resize(point);
// 		vY.resize(point);
// 		vZ.resize(point);
// 		vTVD.resize(point);
// 		int point1=(acurveinfo.EndDepth-acurveinfo.StartDepth)/acurveinfo.DepLevel+1.5;
// 		int point2=(acurveinfo.EndDepth-mWellHead.startDepth)/acurveinfo.DepLevel+0.5;
// 		logio->ReadCurve(iAZIM,acurveinfo.StartDepth,point1,nAzim);
// 		logio->ReadCurve(iDev,acurveinfo.StartDepth,point1,nDevi);
// 		for(int i=point2;i<point-1;i++)
// 		{
// 			nDevi[i]=nDevi[point2-1];
// 			nAzim[i]=nAzim[point2-1];
// 		}
// 		for(int i=0;i<point;i++) {
// 			TrackPoints(nDevi[i],nAzim[i],acurveinfo.DepLevel,XE,YN,ZD,HOFF0,HOAZ0,gtd,AZIM0);
// 			//x0;
// 			//y0;		//xy偏移
// 			//tvd;			//井口垂直高度
// 			//depth;		//测量深度
// 			//Altitude	;	//地面海拔
// 			//KB;		//	补心高
// 			//azca;		//	闭合方位,磁偏角
// 			double z=mWellHead.earthEle-ZD+mWellHead.dEle;
// 			double x=X_COORDINATE+XE;
// 			double y=Y_COORDINATE+YN;//井斜x,y坐标
// 			float tvd=ZD;
// 			vX[i]=x;
// 			vY[i]=y;
// 			vZ[i]=z;
// 			vTVD[i]=tvd;
// 		}
// 		delete nDevi;
// 		delete nAzim;
// 	}
// 	else {
// 		int curveindex=-1;
// 		for(int i=0;i<curveCount;i++) {
// 			if(logio->GetObjectStatus(i)!=OBJECT_NORMAL) continue;
// 			short curvetype=logio->GetObjectType(i);
// 			if(curvetype==CURVE_OBJECT) {
// 				char* curvename=new char[65];
// 				curvename[64]='\0';
// 				char* aliasname=new char[65];
// 				aliasname[64]='\0';
// 				logio->GetObjectName(i,curvename,NULL,aliasname);
// 				logio->GetCurveInfo(i,&acurveinfo);
// 				if(acurveinfo.DepLevel==0||
// 					acurveinfo.DepLevel==0xcdcdcdcd
// 					||acurveinfo.DepLevel>=2.226e+008||
// 					acurveinfo.StartDepth==acurveinfo.EndDepth){
// 						logio->DiscardObject(i);
// 						delete curvename;
// 						delete aliasname;
// 						continue;
// 				}
// 				else {
// 					curveindex=logio->OpenCurve(curvename);
// 					delete curvename;
// 					delete aliasname;
// 				}
// 				break;
// 			}
// 		}
// 		float sdep=TVD,edep=TVD,rlev=0.125;
// 		if(curveindex>-1) {
// 			logio->GetCurveInfo(curveindex,&acurveinfo);
// 			sdep=acurveinfo.StartDepth;
// 			edep=acurveinfo.EndDepth;
// 			rlev=acurveinfo.DepLevel;
// 			ZD=sdep;
// 			double z=mWellHead.earthEle-ZD+mWellHead.dEle;
// 			double x=X_COORDINATE+XE+X0;
// 			double y=Y_COORDINATE+YN+Y0;//井斜x,y坐标
// 			int count=(edep-sdep)/rlev+1.5;
// 			vX.resize(count);
// 			vY.resize(count);
// 			vZ.resize(count);
// 			vTVD.resize(count);
// 			for(int i=0;i<count;i++) {
// 				z-=rlev;
// 				ZD+=rlev;
// 				vX[i]=x;
// 				vY[i]=y;
// 				vZ[i]=z;
// 				vTVD[i]=ZD;
// 			}
// 		}
// 		else {
// 			memset(&acurveinfo,0,sizeof(Slf_CURVE));
// 		}
// 	}
// //	if(acurveinfo.DepLevel&&acurveinfo.StartDepth!=acurveinfo.EndDepth)
// 	{
// 		Slf_CURVE xinfo;
// 		memset(&xinfo,0,sizeof(xinfo));
// 		xinfo.DepLevel=acurveinfo.DepLevel;
// 		if(xinfo.DepLevel==0) xinfo.DepLevel=0.125;
// 		xinfo.StartDepth=acurveinfo.StartDepth;
// 		xinfo.EndDepth=acurveinfo.EndDepth;
// 		xinfo.MaxValue=-999999;
// 		xinfo.MinValue=999999;
// 		xinfo.CodeLen=sizeof(double);
// 		xinfo.RepCode=REPR_DOUBLE;
// 		strcpy(xinfo.AliasName,"X");
// 		strcpy(xinfo.Name,"X");
// 		int index=logio->CreateCurve(&xinfo);
// 		if(index>-1&&vX.size()) {
// 			logio->WriteCurve(index,xinfo.StartDepth,vX.size(),(double *)&vX[0]);
// 			logio->CloseCurve(index);
// 		}
// 		strcpy(xinfo.AliasName,"Y");
// 		strcpy(xinfo.Name,"Y");
// 		index=logio->CreateCurve(&xinfo);
// 		if(index>-1&&vY.size()) {
// 			logio->WriteCurve(index,xinfo.StartDepth,vY.size(),(double *)&vY[0]);
// 			logio->CloseCurve(index);
// 		}
// 		strcpy(xinfo.AliasName,"Z");
// 		strcpy(xinfo.Name,"Z");
// 		index=logio->CreateCurve(&xinfo);
// 		if(index>-1&&vZ.size()) {
// 			logio->WriteCurve(index,xinfo.StartDepth,vZ.size(),(double *)&vZ[0]);
// 			logio->CloseCurve(index);
// 		}
// 		strcpy(xinfo.AliasName,"TVD");
// 		strcpy(xinfo.Name,"TVD");
// 		xinfo.CodeLen=sizeof(float);
// 		xinfo.RepCode=REPR_FLOAT;
// 		index=logio->CreateCurve(&xinfo);
// 		if(index>-1&&vTVD.size()) {
// 			logio->WriteCurve(index,xinfo.StartDepth,vTVD.size(),(float *)&vTVD[0]);
// 			logio->CloseCurve(index);
// 		}
// 	}
// 	delete logio;
// 	Methodlib.unload();
// 	return vTVD.size();
// }

// void CObjWell::Compute2DTrajectory(float _ProjAngle,double _HorizBoreXE,double _HorizBoreYN,float _HScale,float _VScale)
// {
// 	m_WellHead._ProjAngle=_ProjAngle;
// 	m_WellHead._HorizBoreXE=_HorizBoreXE;
// 	m_WellHead._HorizBoreYN=_HorizBoreYN;
// 	Compute2DTrajectory(_HScale,_VScale);
// }
// void CObjWell::Compute2DTrajectory(float _HScale,float _VScale)
// {
// 	if(!m_vX.size())LoadXYZ();
// 	Well &well=GetDBWell();
// 	float bs=m_WellHead.earthEle+m_WellHead.dEle;
// 	int xsize=m_vX.size();
// 	CGeneralProfileModelData model;
// 	model._HRate=1;
// 	model._VRate=1;
// 	model._HScale=1;
// 	model._VScale=1;
// //		model.InitRealScaleRate();
		
// 	if(!m_WellHead._HorizBoreXE) {
// 		m_WellHead._HorizBoreXE=m_WellHead.x;
// 		m_WellHead._HorizBoreYN=m_WellHead.y;
// 	}
// 	model.InitProfileExtent(m_WellHead);
// 	m_vDX.SetSize(xsize);
// 	m_vDY.SetSize(xsize);
// 	m_vAngle.SetSize(xsize);
// 	if(!xsize) return;
// 	m_vDX.m_vProperty[0]=0;
// 	m_vDY.m_vProperty[0]=0;
// 	m_vAngle.m_vProperty[0]=0;
// 	for(int i=1;i<xsize;i++) {
// 		double z = m_vZ.m_vProperty[i];
// //			z=-ConvertY0(-z);
// 		double x = m_vX.m_vProperty[i];
// 		double y = m_vY.m_vProperty[i];

// 		Point3D p(x, y, z);
// 		Point3D p3 = model.GetProjectPoint(p);
// 		Point2D p2 = model.ProfilePointToScreen(p3);
// 		m_vDX.m_vProperty[i]=p2.x;
// 		m_vDY.m_vProperty[i]=p2.y;
// 		float x1, x2, y1, y2, angle = 0;
// 		int i_1=i-1;/*
// 		if(i>=3)
// 			i_1=i-3;*/
// 		double Z0 = m_vZ.m_vProperty[i_1];
// //			Z0=-ConvertY0(-Z0);
// 		double X0 = m_vX.m_vProperty[i-1];
// 		double Y0= m_vY.m_vProperty[i_1];
// 		Point3D P30(X0, Y0, Z0);
// 		Point3D PP3 = model.GetProjectPoint(P30);
// 		Point2D ttp2 = model.ProfilePointToScreen(PP3);

// 		Point2D zP21 = model.ProfilePointToScreenZoom(p3);//计算投影后的直接段的与角度
// 		Point2D zP20 = model.ProfilePointToScreenZoom(PP3);//计算投影后的直接段的与角度
// 		float tdevi = 0;
// 		zP21.y=-zP21.y;
// 		zP20.y=-zP20.y;
// 		if (zP21.x == zP20.x)
// 		{
// 			if (zP21.y - zP20.y > 0)
// 				tdevi = 90;
// 			else
// 				tdevi = 270;
// 		}
// 		else
// 		{
// 			tdevi = (float)(atan((zP21.y - zP20.y) / (zP21.x - zP20.x)) * 180 / 3.1415926);
// 			if (zP21.y - zP20.y == 0 && zP21.x - zP20.x < 0) tdevi = 180;
// 			if (tdevi < 0) tdevi += 360;
// 			if (zP21.x - zP20.x < 0 && zP21.y - zP20.y > 0)
// 			{
// 				tdevi = tdevi - 180;
// 			}
// 			else if (zP21.x - zP20.x < 0 && zP21.y - zP20.y < 0)
// 			{
// 				tdevi = tdevi + 180;
// 			}
// 		}
// 		angle = tdevi + 90;
// 		if (angle > 360) angle -= 360;
// 		m_vAngle.m_vProperty[i]=angle;
// 	}
// }
void CObjWell::SetDX(const FLOATPROPERTY *DX)
{
	m_vDX.copy(DX);
}
void CObjWell::SetDY(const FLOATPROPERTY *DY)
{
	m_vDY.copy(DY);
}
void CObjWell::SetAngle(const FLOATPROPERTY *Angle)
{
	m_vAngle.copy(Angle);
}

FLOATPROPERTY &  CObjWell::GetDX()
{
	return m_vDX;
}

FLOATPROPERTY &  CObjWell::GetDY()
{
	return m_vDY;
}

DOUBLEPROPERTY &  CObjWell::GetX()
{
	return m_vX;
}

float CObjWell::GetDX(float dep)
{
	int i=(dep-m_XYZStartDep)/m_XYZRlev;
	if(i>0)i-=1;
	if(m_vDX.size()&&i>-1&&i<m_vDX.size()) return m_vDX.m_vProperty[i];
	else if(m_vDX.size()) return -9999;
	else return dep;
}

float CObjWell::GetDXToDep(float dx)
{
	//以下只适用于递增或递减水平位移的井段

	if(m_vDX.size() < 1)return m_XYZStartDep;
	int s=m_vDX.size();
	if(dx > m_vDX.m_vProperty[s-1])return m_XYZEndDep;
	if(dx<=m_vDX.m_vProperty[0]) return m_XYZStartDep;
	float err=0;
	//int i=binarySearch(m_vDX.m_vProperty,s,dx,err);
	int i = 0;
	for(int j = 0;j<m_vDX.size()-1;j++)
	{
		if(dx==m_vDX.m_vProperty[j]||(dx > m_vDX.m_vProperty[j] && dx < m_vDX.m_vProperty[j+1]) || ((dx >= m_vDX.m_vProperty[j+1] && dx < m_vDX.m_vProperty[j])))
		{
			i = j;
			break;
		}
	}

	return m_XYZStartDep+i*m_XYZRlev;
}

float CObjWell::GetDYToDep(float dy)
{
	//以下只适用于递增或递减垂深的井段
	if(m_vDY.size() < 1)return m_XYZStartDep;
	int s=m_vDY.size();
	if(dy > m_WellHead.earthEle+m_WellHead.dEle-m_vDY.m_vProperty[s-1])return m_XYZEndDep;
	float err=0;
	//int i=binarySearch(m_vDY.m_vProperty,s,dy,err);
	int i = 0;
	for(int j = 0;j<m_vDY.size()-1;j++)
	{
		if((dy >= m_WellHead.earthEle+m_WellHead.dEle-m_vDY.m_vProperty[j] &&
			dy < m_WellHead.earthEle+m_WellHead.dEle-m_vDY.m_vProperty[j+1]) ||
			(dy >=m_WellHead.earthEle+m_WellHead.dEle -m_vDY.m_vProperty[j+1] && 
			dy <m_WellHead.earthEle+m_WellHead.dEle -m_vDY.m_vProperty[j]))
		{
			i = j;
			break;
		}
	}

	return m_XYZStartDep+i*m_XYZRlev;
}


float CObjWell::GetDY(float dep)
{
	int i=(dep-m_XYZStartDep)/m_XYZRlev;
	if(m_vDY.size()&&i>-1&&i<m_vDY.size()) return m_vDY.m_vProperty[i];
	else if(m_vDY.size()) return -9999;
	else return dep;
}
float CObjWell::GetDZ(float dep)
{
	int i=(dep-m_XYZStartDep)/m_XYZRlev;
	if(m_vZ.size()&&i>=0&&i<m_vZ.size()){
		dep=m_WellHead.earthEle+m_WellHead.dEle-m_vZ.m_vProperty[i];
		return dep;
	}
	else if(m_vZ.size())return -9999;
	else return dep;
}

DOUBLEPROPERTY &  CObjWell::GetY()
{
	return m_vY;
}

FLOATPROPERTY &  CObjWell::GetAngle()
{
	return m_vAngle;
}

DOUBLEPROPERTY &  CObjWell::GetZ()
{
	return m_vZ;
}

void CObjWell::SetX( const DOUBLEPROPERTY *vX )
{
	m_vX.copy(vX);
}

void CObjWell::SetY( const DOUBLEPROPERTY *vY )
{
	m_vY.copy(vY);
}

void CObjWell::SetZ( const DOUBLEPROPERTY *vZ )
{
	m_vZ.copy(vZ);
}

void CObjWell::SetDepth(float sdep,float edep,float rlev)
{
	m_StartDep = sdep;
	m_EndDep = edep;
	m_Rlev = rlev;
}
void CObjWell::SetStartDep(float sdep)
{
	m_StartDep = sdep;
}
void CObjWell::SetEndDep(float dep)
{
	m_EndDep = dep;
}

void CObjWell::SetRlev( float rlev )
{
	m_Rlev = rlev;
}
float CObjWell::GetStartDep()
{
	return m_StartDep;
}
float CObjWell::GetEndDep()
{
	return m_EndDep;
}

float CObjWell::GetRlev()
{
	return m_Rlev;
}

QString CObjWell::GetWellSymbol()
{
	return m_strWellImage;
}

pai::ios::welllog::Well &CObjWell::GetDBWell()
{
	return m_DbWell;

}
void CObjWell::SetDBWell(pai::ios::welllog::Well &DbWell)
{
	m_DbWell=DbWell;
	
}
// void CObjWell::SetBelongID()
// {
// 	pai::objectmodel::PaiObject* paiProject  =  this->GetForebear(GetClassID_Project());
// 	if(paiProject)
// 	{
// 		pai::datamodel::CObjProject *currentProject = dynamic_cast<pai::datamodel::CObjProject*>(paiProject);
// 		if(currentProject)
// 		{
// 			pai::ios::welllog::DataObject* dbProject = currentProject->GetDbObject();
// 			if(dbProject)
// 			{
// 				m_DbWell.SetDataBelongID(dbProject->GetDataID());
// 			}
							
// 		}
// 	}
// }
// pai::ios::welllog::DataObject * CObjWell::GetDbObject()
// {
// 	SetBelongID();
// 	return &m_DbWell;
// }
/************************************************************************/
/* @brief 得到本井次下的对应模板值的井曲线                                                                     */
/************************************************************************/
// pai::datamodel::CObjWellLog* CObjWell::GetWellLogByTemplate(QString wellroundPath,const QVariant& templateKey)
// {
// 	int ghostindex=templateKey.toString().indexOf(OBJ_GHOST_MARK);

// 	if(ghostindex>0)  return GetWellLogByTemplate(templateKey);
// 	if(wellroundPath=="") return GetWellLogByTemplate(templateKey);
// 	return dynamic_cast<pai::datamodel::CObjWellLog*>(CPaiObjectHelper::GetSubtree(::GetProject(),wellroundPath.append("/").append(templateKey.toString())));
// }
// pai::datamodel::CObjWellLog* CObjWell::GetWellLogByTemplate(const QVariant& templateKey)
// {
// 	QList<PaiObject*> wellLogsUnderRounds;
// 	QList<PaiObject*> welllogOrRounds;
// 	this->GetChildren(welllogOrRounds);
// 	for(int i= welllogOrRounds.size()-1; i>=0; --i)
// 	{

// 		if(welllogOrRounds[i]->GetTypeID() == GetClassID_WellLogRound() )
// 		{
// 			CObjWelllogRound* currentround=dynamic_cast<pai::datamodel::CObjWelllogRound*>(welllogOrRounds[i]);
// 			QString wellroundspath=currentround->GetWellRoundPath();
// 				CObjWellLog* result=dynamic_cast<CObjWellLog*>(CPaiObjectHelper::GetSubtree(::GetProject(),wellroundspath.append("/").append(templateKey.toString())));
// 			if(result) return result;
// 			QList<PaiObject*> welllogsUnderRound;
// 			welllogOrRounds[i]->GetChildren(welllogsUnderRound);
// 			wellLogsUnderRounds << welllogsUnderRound;

// 			welllogOrRounds.removeAt(i);
// 		}
// 	}
// 	welllogOrRounds << wellLogsUnderRounds ;
// 	foreach(PaiObject* welllog, welllogOrRounds)
// 	{
// 		pai::datamodel::CBaseObject*  welllogCurve = dynamic_cast<pai::datamodel::CBaseObject* >(welllog);
// 		if(welllogCurve!= NULL && welllogCurve->GetTemplateKey() == templateKey)
// 		{
// 			return dynamic_cast<pai::datamodel::CObjWellLog*>(welllogCurve);
// 		}
// 	}
// 	//没有找到，看看是否存在Ghost
// 	int ghostindex=templateKey.toString().indexOf(OBJ_GHOST_MARK);

// 	if(ghostindex>0){
// 		QString OriginalCurveName=templateKey.toString().left(ghostindex);
// 		//如果是ghost对象，优先在本节点下找，再到各级井次查找




// 		CBaseObject* pClonedObj=NULL;
// 		foreach(PaiObject* welllog, welllogOrRounds)
// 		{
// 			pai::datamodel::CBaseObject*  origwelllogCurve = dynamic_cast<pai::datamodel::CBaseObject* >(welllog);
// 			if(origwelllogCurve!= NULL && origwelllogCurve->GetTemplateKey().toString() == OriginalCurveName)
// 			{
// 				pClonedObj=origwelllogCurve->CloneObject();
// 				break;
// 			}
// 		}
// 		if(pClonedObj){
// 			this->AddChild(pClonedObj->GetPaiObject(),pai::objectmodel::PaiObject::MountNoTree);//MountNoTree
// 			::GetProject()->AddIDMap(pClonedObj->GetPaiObject()->GetID(),pClonedObj);
// 			pClonedObj->SetCheckState(Qt::Checked);
// 			pClonedObj->SetGhostName(pClonedObj->GetPaiObject()->GetName()+OBJ_GHOST_MARK+QString::fromStdString(GenTimeStamp()));
// 			return dynamic_cast<pai::datamodel::CObjWellLog*>(pClonedObj);
// 		}
// 	}

// 	return NULL;
// }

OSGDATAMODEL_EXPORT CObjWell *GetCurrentObjWell()
{
	return g_pObjWell;
}

OSGDATAMODEL_EXPORT void SetCurrentObjWell( CObjWell *pObjWell)
{
	g_pObjWell = pObjWell;
}

// BEGIN_REGISTER_OBJECT(CObjWell)
// 	QUuid(GetClassID_Well())
// END_REGISTER_OBJECT( CObjWell );
// CWellViewInfo3DBasemap::CWellViewInfo3DBasemap()
// {
// 	SetDrawWellPath( true );
// 	m_LineProperty.SetLineColor( osg::Vec4f(1,0,0,1) );
// 	m_LineProperty.SetLineWidth(2);
// }

// BEGIN_REGISTER_OBJECTVIEWINFO(CWellViewInfo3DBasemap)
// 	sOSGObjectViewInfoKey( GetClassID_Well(),GetWindowTypeID_3D() ),
// 	sOSGObjectViewInfoKey( GetClassID_Well(),GetWindowTypeID_QtBasemap() ),
// 	sOSGObjectViewInfoKey( GetClassID_Well(),GetWindowTypeID_Contour() )
// END_REGISTER_OBJECTVIEWINFO( CWellViewInfo3DBasemap );

END_OSGDATAMODEL_NAMESPACE