1442 lines
43 KiB
C++
1442 lines
43 KiB
C++
#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 >D0,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
|