diff --git a/DataMgr/src/CreateNewTableDlg.cpp b/DataMgr/src/CreateNewTableDlg.cpp new file mode 100644 index 0000000..2c66ca8 --- /dev/null +++ b/DataMgr/src/CreateNewTableDlg.cpp @@ -0,0 +1,266 @@ +#include "CreateNewTableDlg.h" +#include "DataHelper.h" +#include "LogIO.h" +#include "dataslothelper.h" +extern DEFAULTTABLE *DefauleTable;//[DefTabNum]; +extern int DefTabNum; +/* +CCreateNewTableDlg::CCreateNewTableDlg(QWidget *parent) + : QDialog(parent) +{ + ui.setupUi(this); +} +*/ +CCreateNewTableDlg::~CCreateNewTableDlg() +{ + +} +CCreateNewTableDlg::CCreateNewTableDlg(QDialog *parent) + : QDialog(parent) +{ + //m_pUI = new Ui_CCreateNewTableDlg(); + m_pUI.setupUi(this); + QObject::connect(m_pUI.okbtn, SIGNAL(clicked()), this, SLOT(slotSave())); + QObject::connect(m_pUI.cancelbtn, SIGNAL(clicked()), this, SLOT(slotCancel())); + QObject::connect(m_pUI.comboBox,SIGNAL(currentIndexChanged(int)),this, SLOT(slotChangeTableType(int))); + QObject::connect(m_pUI.tableWidget, SIGNAL(cellClicked(int,int)), this, SLOT(slotGetCell(int,int))); + QObject::connect(m_pUI.pushButton_Add, SIGNAL(clicked()), this, SLOT(slotAdd())); + QObject::connect(m_pUI.pushButton_Delete, SIGNAL(clicked()), this, SLOT(slotDelete())); + QObject::connect(m_pUI.pushButton_Up, SIGNAL(clicked()), this, SLOT(slotUp())); + QObject::connect(m_pUI.pushButton_Down, SIGNAL(clicked()), this, SLOT(slotDown())); + m_pUI.tableWidget->setColumnCount(6); + QStringList header; + header<<"字段名"<<"字段描述"<<"字段单位"<<"单位别名"<<"字段类型"<<"字段长度"; + m_pUI.tableWidget->setHorizontalHeaderLabels(header); + m_pUI.tableWidget->horizontalHeader()->sectionResizeMode(QHeaderView::Stretch); + for(int i=0;iaddItem(DefauleTable[i].TableAliasName);//系统缺省表列表 + } + m_pUI.comboBox->setCurrentIndex(0); +} +void CCreateNewTableDlg::slotComboxSelectChange(int index) +{ + if(! m_pUI.tableWidget->isActiveWindow()) + return; + //刷新当前字段内容 + + //QWidget *widget=m_pUI.tableWidget->cellWidget(row,col); + QComboBox *combox=(QComboBox*)sender(); + int row=combox->property("row").toInt(); + int col=combox->property("col").toInt(); + int colIndex=index; + if(index!=5)//STRING + { + m_pUI.tableWidget->setItem(row,5,new QTableWidgetItem(QString::number(RepSize[index+1]))); + m_pUI.tableWidget->item(row,5)->setFlags( + m_pUI.tableWidget->item(row,5)->flags()&(~Qt::ItemIsEditable) + ); + } + else + { + m_pUI.tableWidget->item(row,5)->setFlags( + m_pUI.tableWidget->item(row,5)->flags()|Qt::ItemIsEditable|Qt::ItemIsEnabled); + //m_pUI.tableWidget->editItem(m_pUI.tableWidget->item(row,5)); + } + //m_pUI.tableWidget->item(row,5)->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEditable); +} +void CCreateNewTableDlg::slotGetCell(int row,int column) +{ + if(column!=4)return; + QString oldType=m_pUI.tableWidget->item(row,column)->text(); + QComboBox *comboBox = new QComboBox(); + for(int i=0;i<11;i++) + { + comboBox->addItem(QString(Rep_STR[i])); + } + connect(comboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(slotComboxSelectChange(int))); + comboBox->setProperty("row",row); + comboBox->setProperty("col",column); + for(int i=0;i<11;i++) + { + if(oldType==QString(Rep_STR[i]))comboBox->setCurrentIndex(i); + } + m_pUI.tableWidget->setCellWidget(row,column, comboBox ); +} +void CCreateNewTableDlg::slotChangeTableType(int No) +{ + m_pUI.lineEdit_Name->setText(DefauleTable[No].TableName); + m_pUI.lineEdit_Name_2->setText(DefauleTable[No].TableAliasName); + int fNum=DefauleTable[No].ZdNum; + m_pUI.tableWidget->clearContents(); + m_pUI.tableWidget->setRowCount(fNum); + m_rowCount=m_pUI.tableWidget->rowCount(); + for(int i=0;isetItem(i,0,new QTableWidgetItem(QString(DefauleTable[No].tinfo[i].Name))); + m_pUI.tableWidget->setItem(i,1,new QTableWidgetItem(QString(DefauleTable[No].tinfo[i].HZName))); + m_pUI.tableWidget->setItem(i,2,new QTableWidgetItem(QString(DefauleTable[No].tinfo[i].Unit))); + m_pUI.tableWidget->setItem(i,3,new QTableWidgetItem(QString(DefauleTable[No].tinfo[i].HZUnit))); + QString DataType=QString(Rep_STR[DefauleTable[No].tinfo[i].RepCode-1]); + m_pUI.tableWidget->setItem(i,4,new QTableWidgetItem(DataType)); + m_pUI.tableWidget->setItem(i,5,new QTableWidgetItem(QString::number(DefauleTable[No].tinfo[i].CodeLength))); + if(DataType=="STRING") + { + m_pUI.tableWidget->editItem(m_pUI.tableWidget->item(i,5)); + //m_pUI.tableWidget->item(i,5)->setFlags(m_pUI.tableWidget->item(i,5)->flags()&(Qt::ItemIsEditable));//ItemIsEnabled)); + } + else + { + m_pUI.tableWidget->item(i,5)->setFlags(Qt::ItemIsSelectable|Qt::NoItemFlags); + } + + } +} +void CCreateNewTableDlg::slotSave() +{ + TableName=m_pUI.lineEdit_Name->text().toUpper(); + if(TableName=="") + { + QMessageBox::warning(NULL,"警告！","表名不能为空！");return; + } + int fNum=m_pUI.tableWidget->rowCount(); + if(!fNum) + { + QMessageBox::warning(NULL,"警告！","没有表字段！");return; + } + CLogIO logio(FileName.toStdString().c_str(),(unsigned int)CLogIO::modeReadWrite); + if(!logio.mFile) + { + QMessageBox::warning(NULL,"警告！",FileName+"\r\n打开井次文件失败！");return ; + } + if(logio.FindObjectIndex(TableName.toStdString().c_str())>=0) + { + QMessageBox::warning(NULL,"警告！","您要产生的表名称已存在！");return; + } + QString TableHzName=m_pUI.lineEdit_Name_2->text(); + Slf_OBJECT_FIELD *pField=new Slf_OBJECT_FIELD[fNum]; + memset(pField,0,sizeof(Slf_OBJECT_FIELD)*fNum); + for(int i=0;iitem(i,0)->text().toStdString().c_str()); + strcpy(pField[i].HZName,m_pUI.tableWidget->item(i,1)->text().toStdString().c_str()); + strcpy(pField[i].Unit,m_pUI.tableWidget->item(i,2)->text().toStdString().c_str()); + strcpy(pField[i].HZUnit,m_pUI.tableWidget->item(i,3)->text().toStdString().c_str()); + pField[i].ArrayNum=1; + pField[i].SamplePoint=1; + QString CodeType=m_pUI.tableWidget->item(i,4)->text(); + for(int j=0;j<11;j++) + { + if(CodeType==QString(Rep_STR[j])) + { + pField[i].RepCode=j+1; + break; + } + } + pField[i].CodeLength=m_pUI.tableWidget->item(i,5)->text().toInt(); + if(QString(pField[i].Name)==""||pField[i].CodeLength<=0) + { + if(QString(pField[i].Name)=="")QMessageBox::warning(NULL,"警告！","字段名不能为空！"); + else QMessageBox::warning(NULL,"警告！","字段长度必须是大于0的正整数！"); + delete []pField; + logio.Close(); + return; + } + } + int table=logio.CreateTable(0,TableName.toLocal8Bit().toStdString().c_str(),TableHzName.toLocal8Bit().toStdString().c_str(),fNum,&pField[0],0); + delete []pField; + logio.CloseTable(table); + logio.Close(); + accept(); +} +void CCreateNewTableDlg::slotAdd() +{ + int count=m_pUI.tableWidget->rowCount(); + m_rowCount++; + QList selRange=m_pUI.tableWidget->selectedRanges(); + bool isSel=selRange.size()>0; + int index=0; + int sRow=isSel?(selRange.value(0).bottomRow()+1):count+1; + if(!isSel) + { + m_pUI.tableWidget->setRowCount(1+count); + index=sRow-1; + }else + { + m_pUI.tableWidget->insertRow(sRow); + index=sRow; + } + m_pUI.tableWidget->setItem(index,0,new QTableWidgetItem("name"+QString::number(index+1))); + m_pUI.tableWidget->setItem(index,1,new QTableWidgetItem("字段"+QString::number(index+1))); + m_pUI.tableWidget->setItem(index,2,new QTableWidgetItem("NONE")); + m_pUI.tableWidget->setItem(index,3,new QTableWidgetItem("")); + m_pUI.tableWidget->setItem(index,4,new QTableWidgetItem("INT")); + m_pUI.tableWidget->setItem(index,5,new QTableWidgetItem("4")); + m_pUI.tableWidget->item(index,5)->setFlags(Qt::ItemIsEditable); +} +void CCreateNewTableDlg::slotDelete() +{ +if(m_rowCount<=1) + { + return; + } + + int count=m_pUI.tableWidget->rowCount(); + int insertRow=m_rowCount-count; + QList selRanges=m_pUI.tableWidget->selectedRanges(); + bool isSel=selRanges.size()>0; + if(!isSel) + { + return; + } + int index=0; + int sRow=0; + int eRow=0; + int delCount=0; + foreach(const QTableWidgetSelectionRange &range,selRanges) + { + + sRow=range.topRow(); + eRow=range.bottomRow(); + index=sRow-delCount; + delCount=0; + for(int r=sRow;r<=eRow;r++) + { + --m_rowCount; + delCount++; + m_pUI.tableWidget->removeRow(index); + + } + } +} + + + +void CCreateNewTableDlg::slotUp() +{ + //选择一行或者多行往前移动，允许不连续选择，如删除1、2、3、8、10行 + //1、把选择的行向上移动一行，移动后被选择的行仍处于选中状态（可以继续上移，实现多步移动） + //2、CurveNameList内容随之改变 + int count=m_pUI.tableWidget->rowCount(); + int insertRow=m_rowCount-count; + QList selRanges=m_pUI.tableWidget->selectedRanges(); + bool isSel=selRanges.size()>0; + if(!isSel) + { + return; + } + DataSlotHelper::instance()->movedUp(m_pUI.tableWidget); + +} +void CCreateNewTableDlg::slotDown() +{ + //选择一行或者多行往后移动，允许不连续选择，如删除1、2、3、8、10行 + //1、把选择的行向上移动一行，移动后被选择的行仍处于选中状态（可以继续上移，实现多步移动） + //2、CurveNameList内容随之改变 + int count=m_pUI.tableWidget->rowCount(); + int insertRow=m_rowCount-count; + QList selRanges=m_pUI.tableWidget->selectedRanges(); + bool isSel=selRanges.size()>0; + if(!isSel) + { + return; + } + DataSlotHelper::instance()->movedDow(m_pUI.tableWidget); + +} diff --git a/DataMgr/src/CreateNewTableDlg.h b/DataMgr/src/CreateNewTableDlg.h new file mode 100644 index 0000000..5026642 --- /dev/null +++ b/DataMgr/src/CreateNewTableDlg.h @@ -0,0 +1,39 @@ +#ifndef CREATENEWTABLEDLG_H +#define CREATENEWTABLEDLG_H + +#include +#include "ui_CreateNewTableDlg.h" +#pragma execution_character_set("utf-8") + +class CCreateNewTableDlg : public QDialog +{ + Q_OBJECT + +public: + CCreateNewTableDlg(QDialog *parent = 0); + ~CCreateNewTableDlg(); + QString FileName;//slf文件名 + QString TableName;//表名 +private: + Ui::CCreateNewTableDlg m_pUI; + //动态表格行数 + int m_rowCount; +private slots: + /** + *@brief 保存槽函数 + */ + void slotSave(); + + /** + *@brief 取消槽函数*/ + void slotCancel(){reject ();}; + void slotChangeTableType(int); + void slotGetCell(int row,int column); + void slotComboxSelectChange(int index); + void slotAdd(); + void slotDelete(); + void slotUp(); + void slotDown(); +}; + +#endif // CREATENEWTABLEDLG_H diff --git a/DataMgr/src/CreateNewTableDlg.ui b/DataMgr/src/CreateNewTableDlg.ui new file mode 100644 index 0000000..d622285 --- /dev/null +++ b/DataMgr/src/CreateNewTableDlg.ui @@ -0,0 +1,203 @@ + + + CCreateNewTableDlg + + + + 0 + 0 + 863 + 425 + + + + 产生新数据表 + + + + + + + + + + + + 选择表类型 + + + + + + + + 0 + 0 + + + + 20 + + + + + + + 表名称 + + + + + + + true + + + + + + + 表别名 + + + + + + + + + + + + 表字段信息 + + + Qt::AlignCenter + + + + + + + + 700 + 200 + + + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + 确定 + + + + + + + 取消 + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + 10 + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + 添加 + + + + + + + 删除 + + + + + + + 上移 + + + + + + + 下移 + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + + + + + + diff --git a/DataMgr/src/DataManagger.cpp b/DataMgr/src/DataManagger.cpp index 6d3a81a..c1852a2 100644 --- a/DataMgr/src/DataManagger.cpp +++ b/DataMgr/src/DataManagger.cpp @@ -27,7 +27,7 @@ // #include "ShowCurve.h"//2020.5.12常规曲线预览 #include // #include "tableproeditdlg.h" -// #include "CreateNewTableDlg.h" +#include "CreateNewTableDlg.h" #include "BaseFun.h" #include "DepthProgress.h" #include "geometryutils.h" @@ -1217,22 +1217,22 @@ QString CDataManagger::Curve2ResultTable(const QString& wellname,const QString& //whp 2020.7.21 //创建新表 -// QString CDataManagger::CreateNewTable(const QString& wellname) -// { -// if(DataHelper::m_IsGc)DataHelper::InitDefauleTable(); -// CCreateNewTableDlg *pDlg=new CCreateNewTableDlg(); -// pDlg->FileName=wellname; -// if(pDlg->exec()==QDialog::Accepted) -// { -// QString cs=pDlg->TableName; -// delete pDlg; -// return cs; -// } -// else { -// delete pDlg; -// return ""; -// } -// } +QString CDataManagger::CreateNewTable(const QString& wellname) +{ + if(DataHelper::m_IsGc)DataHelper::InitDefauleTable(); + CCreateNewTableDlg *pDlg=new CCreateNewTableDlg(); + pDlg->FileName=wellname; + if(pDlg->exec()==QDialog::Accepted) + { + QString cs=pDlg->TableName; + delete pDlg; + return cs; + } + else { + delete pDlg; + return ""; + } +} // QString CDataManagger::CreateNewCurve(const QString& wellname) // { // CCreateNewCurveDlg *pDlg=new CCreateNewCurveDlg(); diff --git a/DataMgr/src/DataMgr.pro b/DataMgr/src/DataMgr.pro index e9a6275..c74d049 100644 --- a/DataMgr/src/DataMgr.pro +++ b/DataMgr/src/DataMgr.pro @@ -46,6 +46,7 @@ CONFIG(debug, debug|release){ FORMS += \ + CreateNewTableDlg.ui \ UI/InDefTable.ui \ UI/SigelWell.ui \ UI/MutlWell.ui\ @@ -59,24 +60,28 @@ HEADERS += \ ../../common/geometryutils.h \ AdaptionComboBox.h \ CheckHeadView.h \ + CreateNewTableDlg.h \ DataHelper.h \ DataManagger.h \ InDefTableDlg.h\ TiShiDlg.h\ ConsoleOutputWidget.h \ - cdialog.h + cdialog.h \ + dataslothelper.h SOURCES += \ ../../common/geometryutils.cpp \ AdaptionComboBox.cpp \ CStringType.cpp \ CheckHeadView.cpp \ + CreateNewTableDlg.cpp \ DataHelper.cpp \ DataManagger.cpp\ InDefTableDlg.cpp\ TiShiDlg.cpp\ ConsoleOutputWidget.cpp \ - cdialog.cpp + cdialog.cpp \ + dataslothelper.cpp INCLUDEPATH += ../include INCLUDEPATH += ../CallManage diff --git a/OSGDataModel/include/ObjWell.h b/OSGDataModel/include/ObjWell.h new file mode 100644 index 0000000..d48bd6d --- /dev/null +++ b/OSGDataModel/include/ObjWell.h @@ -0,0 +1,219 @@ +/** +* @file ObjWell.h +* @brief "井"数据模型 +* @date 2014-6-3 +* @author: liyonggang +*/ +#ifndef PAI_FRAME_OSGWELL_H +#define PAI_FRAME_OSGWELL_H +#pragma warning( push ,0) + +#include + +#include + +#include "ObjectID.h" +// #include "LineProperty.h" +#include "Well.h" +#include "BaseObject.h" +// #include "ObjWellTrack.h" +#include "BaseFun.h" +#include "ObjWelllogRound.h" +// #include "ObjectViewInfo.h" + +#pragma warning( pop ) + +BEGIN_OSGDATAMODEL_NAMESPACE; +class CObjWellLog; +OSGDATAMODEL_EXPORT CObjWell *GetCurrentObjWell(); +OSGDATAMODEL_EXPORT void SetCurrentObjWell( CObjWell *pObjWell ); + +class OSGDATAMODEL_EXPORT CObjWell/* : public CObjBaseObject*/ +{ + // Q_OBJECT; +public: + CObjWell(); + + ~CObjWell(); + +public: + QString GetWellCode() const + { + return m_WellCode; + } + void SetWellCode(QString WellCode) + { + m_WellCode=WellCode; + } + void SaveWellHead(QString filename); + //往井次下加入曲线时，根据曲线的类型返回其对应的目录id + QUuid GetTragetFolderID(QUuid aLogTypeid); + //根据folderid找到对应的folder，如果没有则创建 + // CObjectFolder* GetTragetFolder(QUuid aFolderTypeid); + //获得井次数 + int GetWellRoundCount(); + // int GetAllWellRound(QList &wellroundchildren); + virtual QUuid GetTypeID()const; + + // virtual bool Serialize( CObjectArchive &ar ); + // virtual bool AddChild(PaiObject* pChild, bool mountNow = true); + + // virtual pai::ios::welllog::DataObject *GetDbObject(); + + /** + * Well的MD得到对应的x,y,z + */ + // bool GetXYZByMD(float fMD,double &x,double &y,double &z ); + // bool LoadXYZ(bool isreCreateXYZ=false); + void ClearXYZ(); + /** + * Well的点MD对应井口位置的相对位置dx、dy、dz + */ + // bool GetDXDYDZByMD(float fMD,double &dx,double &dy,double &dz ); + WellHead &GetWellHead(); + /** + * Well log的最上点MD + */ + double GetTopWellLogDepth(); + + double GetBottomWellLogDepth(); + CObjWelllogRound* GetCurrentObjWellRound(); + void SetCurrentObjWellRound(CObjWelllogRound*pWellRound); + /** + * Well x,y,z井轨迹信息 + */ + // void Compute2DTrajectory(float _HScale=10000,float _VScale=10000); + // void Compute2DTrajectory(float _ProjAngle,double _HorizBoreXE,double _HorizBoreYN,float _HScale=10000,float _VScale=10000); + FLOATPROPERTY & GetDX(); + FLOATPROPERTY & GetDY(); + float GetDX(float dep); + float GetDY(float dep); + float GetDZ(float dep); + FLOATPROPERTY & GetAngle(); + float GetDYToDep(float dy); + float GetDXToDep(float dx); + void SetDX( const FLOATPROPERTY *vDX ); + void SetDY( const FLOATPROPERTY *vDX ); + void SetAngle(const FLOATPROPERTY *Angle); + DOUBLEPROPERTY & GetX(); + DOUBLEPROPERTY & GetY(); + DOUBLEPROPERTY & GetZ(); + void SetX( const DOUBLEPROPERTY *vX ); + void SetY( const DOUBLEPROPERTY *vX ); + void SetZ( const DOUBLEPROPERTY *vX ); + void SetStartDep(float dep); + void SetEndDep(float dep); + void SetRlev(float rlev); + void SetDepth(float sdep,float edep,float rlev); + float GetStartDep(); + float GetEndDep(); + float GetRlev(); + + void SetWellFileName(QString WellName) + { + m_WellFileName=WellName; + } + QString GetWellFileName() + { + CObjWelllogRound *pWR=GetCurrentObjWellRound(); + if(pWR) return pWR->GetSlfFileName(); + return m_WellFileName; + } + virtual QString GetWellMessageFileName() + { + return m_WellFileName; + } + + bool isUsed() + { + return isFLAG; + } + void SetUsed(bool flag) + { + isFLAG=flag; + } + // void SetDepth(CObjWell *pWell); + + /** + * 井符号图片 + */ + QString GetWellSymbol(); + void SetWellSymbol(QString imagef) + { + m_strWellImage=imagef; + } + + virtual void SetDBWell(pai::ios::welllog::Well &DbWell); + + pai::ios::welllog::Well &GetDBWell(); + + + // virtual void CopyFrom( CBaseObject *pOSGObjectOther ); + + /** + *@brief 判断井名是否存在 + */ + // virtual bool isExistsName(QString name); + /************************************************************************/ + /* @brief 得到本井下的对应模板值的井曲线[遍历所有井次，拿到第一条] */ + /************************************************************************/ + // pai::datamodel::CObjWellLog* GetWellLogByTemplate(const QVariant& templateKey); + /************************************************************************/ + /* @brief 得到本井次下的对应模板值的井曲线 */ + /************************************************************************/ + // pai::datamodel::CObjWellLog* GetWellLogByTemplate(QString wellroundPath,const QVariant& templateKey); + // static int ComputeTrajectory(CObjWell *pWell,QString Slffilename); +private: + + /** + * @brief 设置数据所属ID + */ + // void SetBelongID(); +private: + + //井轨迹x,y,z,MD + FLOATPROPERTY m_vDX; + FLOATPROPERTY m_vDY; + FLOATPROPERTY m_vAngle; + + DOUBLEPROPERTY m_vX; + DOUBLEPROPERTY m_vY; + DOUBLEPROPERTY m_vZ; + DOUBLEPROPERTY m_vMD; + WellHead m_WellHead; + double m_StartDep,m_EndDep,m_Rlev; + QString m_strWellImage; //井类型符号 + pai::ios::welllog::Well m_DbWell; //Db 里的well对象 + QString m_WellFileName; + QString m_WellCode; ///<井编码 API编码 + CObjWelllogRound*m_pCurrentWelllogRound; + bool isFLAG; + double m_XYZStartDep,m_XYZEndDep,m_XYZRlev; +public slots: + // void slotWellMessage(QString slffile); +}; + +/** +* @class CWellViewInfo3DBasemap +* @brief well在3D窗口,Basemap窗口上的viewinfo +*/ +// class OSGDATAMODEL_EXPORT CWellViewInfo3DBasemap: public CObjectViewInfo +// { +// Q_OBJECT +// public: +// CWellViewInfo3DBasemap(); + +// IMPLE_META_PROPERTY(); + +// GM_PROPERTY_NORMAL( CLineProperty,LineProperty ); +// Q_PROPERTY(CLineProperty LineProperty READ GetLineProperty WRITE SetLineProperty ); + +// GM_PROPERTY_NORMAL( bool,DrawWellPath); +// Q_PROPERTY(bool DrawWellPath READ GetDrawWellPath WRITE SetDrawWellPath ); +// }; + +using namespace pai::datamodel; + +END_OSGDATAMODEL_NAMESPACE + +#endif diff --git a/OSGDataModel/include/ObjWelllogRound.h b/OSGDataModel/include/ObjWelllogRound.h new file mode 100644 index 0000000..0bc55c0 --- /dev/null +++ b/OSGDataModel/include/ObjWelllogRound.h @@ -0,0 +1,92 @@ +/** +* @file ObjWell.h +* @brief "井次"数据模型 +* @date 2014-6-3 +* @author: liyonggang +*/ +#ifndef PAI_FRAME_OSGWELLLOGROUND_H +#define PAI_FRAME_OSGWELLLOGROUND_H +#pragma warning( push ,0) +#include +#include "WelllogRound.h" +#include "BaseObject.h" +// #include "ObjectFolder.h" +#include "ObjWelllog.h" +#pragma warning( pop ) + +BEGIN_OSGDATAMODEL_NAMESPACE; + +class OSGDATAMODEL_EXPORT CObjWelllogRound : public CBaseObject/*CBaseObjectImpl*/ +{ + // Q_OBJECT +public: + // CObjWelllogRound(); + + ~CObjWelllogRound(); + +public: + /** + * @brief Add a child object in general way. + * @param pChild the child object handle + * @param mountNow 是否将其挂载到树上 + * @根据对象的类型，将其加到对应的分类上 + */ + // virtual bool AddChild(PaiObject* pChild, bool mountNow = true); + + virtual QUuid GetTypeID()const; + + // virtual bool Serialize( CObjectArchive &ar ); + + virtual pai::ios::welllog::DataObject *GetDbObject(); + + pai::ios::welllog::WelllogRound &GetDBWelllogRound(); + //按名称从井次下拿测井曲线 + // CObjWellLog* GetWellLogByName(QString name); + + // void SetDBWelllogRound( pai::ios::welllog::WelllogRound DbWelllogRound); + + // bool isExistsName(QString name); + // void setParent(PaiObject* pObject); + + virtual void CopyFrom( CBaseObject *pOSGObjectOther ); + QString GetSlfFileName() const { return m_strAttachedSlfFile; } + // void SetSlfFileName(QString val); + CObjWell *GetWell(); + void SetWell(CObjWell *pWell); + // QString GetWellRoundPath(); + bool isUsed() + { + return isFLAG; + } + void SetUsed(bool flag) + { + isFLAG=flag; + } + virtual QString GetDescription(); + +private: + void SetBelongID(); +private: + //往井次下加入曲线时，根据曲线的类型返回其对应的目录id + QUuid GetTragetFolderID(QUuid aLogTypeid); + //根据folderid找到对应的folder，如果没有则创建 + // CObjectFolder* GetTragetFolder(QUuid aFolderTypeid); + + QString m_strAttachedSlfFile; //该井次附加的slf文件 + + QString m_strWellImage; //井类型符号 + pai::ios::welllog::WelllogRound m_DbWelllogRound; //Db 里的well对象 + // PaiObject* m_pObject; // + CObjWell *m_pWell; + bool isFLAG; +}; +//得到当前井次 +OSGDATAMODEL_EXPORT CObjWelllogRound *GetCurrentObjWelllogRound(); +OSGDATAMODEL_EXPORT void SetCurrentObjWelllogRound( CObjWelllogRound *pObjWelllogRound ); +// OSGDATAMODEL_EXPORT QString GetCurrentWellRoundPath(); +// OSGDATAMODEL_EXPORT QString GetSingleWellFolderID(); +using namespace pai::datamodel; + +END_OSGDATAMODEL_NAMESPACE + +#endif diff --git a/OSGDataModel/include/Well.h b/OSGDataModel/include/Well.h new file mode 100644 index 0000000..b2ce5c2 --- /dev/null +++ b/OSGDataModel/include/Well.h @@ -0,0 +1,539 @@ +/** + * @file Well.h + * @brief 测井对象基类 + */ + +#ifndef PAI_FRAME_IOSERVICE_WELL_H +#define PAI_FRAME_IOSERVICE_WELL_H + +#include +#include +#include "DataObject.h" +#include "WelllogRound.h" +#include "OSGDataModel.h" +#include "MemRdWt.h" +namespace pai { +namespace ios { +namespace welllog { + +/** + *@class Point + *@brief 定义井轨迹点类 + */ +class Point +{ +public: + double GetMd() + { + return m_md; + } + double GetAzim() + { + return m_azim; + } + double GetIncl() + { + return m_incl; + } + void SetMd(double md) + { + this->m_md = md; + } + void SetAzim(double azim) + { + this->m_azim = azim; + } + void SetIncl(double incl) + { + this->m_incl = incl; + } +private: + double m_md; ///<测量深度 + double m_azim; ///<井斜角 + double m_incl; ///<方位角 +}; + +/** + *@class Well + *@brief 定义井数据类 + */ +class OSGDATAMODEL_EXPORT Well : public DataObject +{ +public: + /** + * @brief 构造函数 + */ + Well():DataObject() + { + Init(); + } + void Init() + { + m_AreaName=""; ///<地区名 + m_CompanyName=""; ///<油公司名 + m_WellType=0; ///<井类型 + m_XCode=0; ///& infos); + + /** + * @brief 同时保存多条井次数据 + * @param[in] welllogrounds 井次信息 + */ + void SaveWelllogRound(std::vector& welllogrounds); + + void SetTopDepth(float dep) + { + this->TopDepth = dep; + } + + void SetBottomDepth(float dep) + { + this->BottomDepth = dep; + } + + float GetTopDepth() + { + return TopDepth; + } + + float GetBottomDepth() + { + return BottomDepth; + } + +public: + std::string GetAreaName() const + { + return m_AreaName; + } + + float GetAsl() const + { + return m_Asl; + } + + std::string GetBit1Prog() const + { + return m_Bit1Prog; + } + + std::string GetBit2Prog() const + { + return m_Bit2Prog; + } + + std::string GetBit3Prog() const + { + return m_Bit3Prog; + } + + std::string GetBit4Prog() const + { + return m_Bit4Prog; + } + + std::string GetBit5Prog() const + { + return m_Bit5Prog; + } + + float GetBsl() const + { + return m_Bsl; + } + + std::string GetCWMethod() const + { + return m_CWMethod; + } + + std::string GetCas1Prog() const + { + return m_Cas1Prog; + } + + float GetCas1Shot() const + { + return m_Cas1Shot; + } + + std::string GetCas2Prog() const + { + return m_Cas2Prog; + } + + float GetCas2Shot() const + { + return m_Cas2Shot; + } + + std::string GetCas3Prog() const + { + return m_Cas3Prog; + } + + std::string GetCas4Prog() const + { + return m_Cas4Prog; + } + + std::string GetCas5Prog() const + { + return m_Cas5Prog; + } + + std::string GetCompanyName() const + { + return m_CompanyName; + } + + std::string GetCompleteDate() const + { + return m_CompleteDate; + } + + std::string GetEDrillDate() const + { + return m_EDrillDate; + } + + std::string GetRemark() const + { + return m_Remark; + } + + float GetSC1EDep() const + { + return m_SC1EDep; + } + + float GetSC1SDep() const + { + return m_SC1SDep; + } + + float GetSC2EDep() const + { + return m_SC2EDep; + } + + float GetSC2SDep() const + { + return m_SC2SDep; + } + + std::string GetSDrillDate() const + { + return m_SDrillDate; + } + + int GetWellType() const + { + return m_WellType; + } + + double GetXCode() const + { + return m_XCode; + } + + double GetYCode() const + { + return m_YCode; + } + std::vector GetPoint() const + { + return m_Points; + } + void SetAreaName(std::string areaName) + { + this->m_AreaName = areaName; + } + + void SetAsl(float asl) + { + this->m_Asl = asl; + } + + void SetBit1Prog(std::string bit1Prog) + { + this->m_Bit1Prog = bit1Prog; + } + + void SetBit2Prog(std::string bit2Prog) + { + this->m_Bit2Prog = bit2Prog; + } + + void SetBit3Prog(std::string bit3Prog) + { + this->m_Bit3Prog = bit3Prog; + } + + void SetBit4Prog(std::string bit4Prog) + { + this->m_Bit4Prog = bit4Prog; + } + + void SetBit5Prog(std::string bit5Prog) + { + this->m_Bit5Prog = bit5Prog; + } + + void SetBsl(float bsl) + { + this->m_Bsl = bsl; + } + + void SetCWMethod(std::string cWMethod) + { + this->m_CWMethod = cWMethod; + } + + void SetCas1Prog(std::string cas1Prog) + { + this->m_Cas1Prog = cas1Prog; + } + + void SetCas1Shot(float cas1Shot) + { + this->m_Cas1Shot = cas1Shot; + } + + void SetCas2Prog(std::string cas2Prog) + { + this->m_Cas2Prog = cas2Prog; + } + + void SetCas2Shot(float cas2Shot) + { + this->m_Cas2Shot = cas2Shot; + } + + void SetCas3Prog(std::string cas3Prog) + { + this->m_Cas3Prog = cas3Prog; + } + + void SetCas4Prog(std::string cas4Prog) + { + this->m_Cas4Prog = cas4Prog; + } + + void SetCas5Prog(std::string cas5Prog) + { + this->m_Cas5Prog = cas5Prog; + } + + void SetCompanyName(std::string companyName) + { + this->m_CompanyName = companyName; + } + + void SetCompleteDate(std::string completeDate) + { + this->m_CompleteDate = completeDate; + } + + void SetEDrillDate(std::string eDrillDate) + { + this->m_EDrillDate = eDrillDate; + } + + void SetRemark(std::string remark) + { + this->m_Remark = remark; + } + + void SetSC1EDep(float sC1EDep) + { + this->m_SC1EDep = sC1EDep; + } + + void SetSC1SDep(float sC1SDep) + { + this->m_SC1SDep = sC1SDep; + } + + void SetSC2EDep(float sC2EDep) + { + this->m_SC2EDep = sC2EDep; + } + + void SetSC2SDep(float sC2SDep) + { + this->m_SC2SDep = sC2SDep; + } + + void SetSDrillDate(std::string sDrillDate) + { + this->m_SDrillDate = sDrillDate; + } + + void SetWellType(int wellType) + { + this->m_WellType = wellType; + } + + void SetXCode(double xCode) + { + this->m_XCode = xCode; + } + + void SetYCode(double yCode) + { + this->m_YCode = yCode; + } + void SetPoint(const std::vector& pts) + { + this->m_Points = pts; + } + void LoadMeesge(QString filename) + { + if(filename=="") return; + CMemRdWt *logio=new CMemRdWt(); + if(filename==""||!logio->Open(filename.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; +// QMessageBox::information(NULL,"提示","SLF文件打开失败，请检查！！",QMessageBox::Yes); + return; + } +// FILE*fp=fopen("d:\\oa.txt","a"); +// fprintf(fp,"3-mess!\n\n"); +// fclose(fp); + + logio->GetFileMessage(filemessage); +// fp=fopen("d:\\oa.txt","a"); +// fprintf(fp,"4-mess!\n\n"); +// fclose(fp); + delete logio; +// fp=fopen("d:\\oa.txt","a"); +// fprintf(fp,"5-mess!\n\n"); +// fclose(fp); + } + + void SaveMeesge(QString filename) + { + if(filename=="") return; + CMemRdWt *logio=new CMemRdWt(); + if(filename==""||!logio->Open(filename.toStdString().c_str(),CSlfIO::modeReadWrite)) + { + delete logio; +// QMessageBox::information(NULL,"提示","SLF文件打开失败，请检查！！",QMessageBox::Yes); + return; + } + logio->SetFileMessage(filemessage); + delete logio; + } + + +private: + std::string m_AreaName; ///<地区名 + std::string m_CompanyName; ///<油公司名 + int m_WellType; ///<井类型 + double m_XCode; /// m_Points; ///<井轨迹点 + + float TopDepth; + float BottomDepth; + std::string m_name; + Slf_FILE_MESSAGE filemessage; + +}; + +} +} +} + +#endif diff --git a/OSGDataModel/include/WelllogRound.h b/OSGDataModel/include/WelllogRound.h new file mode 100644 index 0000000..4c31716 --- /dev/null +++ b/OSGDataModel/include/WelllogRound.h @@ -0,0 +1,556 @@ +/** + * @file WelllogRound.h + * @brief 测井对象基类 + */ + +#ifndef PAI_FRAME_IOSERVICE_WELLLOGROUND_H +#define PAI_FRAME_IOSERVICE_WELLLOGROUND_H + +#include +#include +#include "DataObject.h" +// #include "WelllogCurve.h" +// #include "CoreImg.h" +// #include "CorePhysics.h" +// #include "DrillCore.h" +// #include "Gujing1Result.h" +// #include "SwallCore.h" +// #include "OgResult.h" +// #include "CoreDesc.h" +// #include "Wavefile.h" +// #include "Geostratum.h" +// #include "OgResult2.h" +// #include "Zone.h" +#include "OSGDataModel.h" +#include "MemRdWt.h" +namespace pai { +namespace ios { +namespace welllog { + + +class OSGDATAMODEL_EXPORT TableDataName +{ +public: + long long GetTableID() const + { + return m_TableID; + } + std::string GetTableName() const + { + return m_TableName; + } + std::string GetTableDataTableName() const + { + return m_TableDataTableName; + } + void SetTableID(long long tableID) + { + this->m_TableID = tableID; + } + void SetTableName(std::string tableName) + { + this->m_TableName = tableName; + } + void SetTableDataTableName(std::string tableDataTableName) + { + this->m_TableDataTableName = tableDataTableName; + } +private: + long long m_TableID; ///<表数据ID + std::string m_TableName; ///<表数据名 + std::string m_TableDataTableName; ///<表格数据所在的表名 +}; + +/** + *@class WelllogRound + *@brief 定义井次类 + */ +class OSGDATAMODEL_EXPORT WelllogRound : public DataObject +{ +public: + /** + * @brief 构造函数 + */ + WelllogRound():DataObject(){ + Init(); + } + void Init() + { + memset(&filemessage,0,sizeof(filemessage)); + m_CompanyName=""; ///<测井公司名 + m_Team=""; ///<测井小队 + m_Operator=""; ///<操作员 + m_Date=""; ///<测井日期 + m_Serial=""; ///<测井系列 + m_Item=""; ///<测井项目 + m_MudType=""; ///<泥浆类型 + m_MudViscosity=0; ///<泥浆粘度 + m_WaterLoss=0; ///<失水量 + m_Density=0; ///<泥浆密度 + m_Resi=0; ///<泥浆电阻率 + m_Temp=0; ///<泥浆温度 + TopDepth=0; + BottomDepth=0; + m_INTLog=""; ///<测井井段 + m_NITINT=""; ///<解释井段 + m_TempBot=0; ///<井底温度 + m_IntProg=""; ///<解释程序 + m_InteDress=""; ///<解释员 + m_Audit=""; ///<审核 + m_Remark=""; ///<备注 + m_name=""; + }; + + void SetTopDepth(float dep) + { + this->TopDepth = dep; + } + + void SetBottomDepth(float dep) + { + this->BottomDepth = dep; + } + + float GetTopDepth() + { + return TopDepth; + } + + float GetBottomDepth() + { + return BottomDepth; + } + + /** + * @brief 析构函数 + */ + virtual ~WelllogRound() + { + } + /** + * @brief 拷贝构造函数 + */ + WelllogRound(const WelllogRound& welllogRound); + /** + * @brief 赋值 + */ + WelllogRound & operator=(const WelllogRound& welllogRound); + /** + * @brief 保存数据 + */ + virtual void Save(); + + /** + * @brief 根据ID获取对象信息 + * @param[in] id 数据ID + */ + virtual void Get(long long id); + /** + * @brief 修改数据 + */ + virtual void Update(); + /** + * @brief 删除数据 + * @param[in] id 数据ID + */ + virtual void Delete(long long id = 0); + // /** + // * @brief 获得该井次下所有的曲线 + // * @param[out] infos 曲线列表 + // */ + // void GetWelllogCurve(std::vector& infos); + + // /** + // * @brief 同时保存多条曲线 + // * @param[in] welllogcurves 曲线列表 + // */ + // void SaveWelllogCurve(std::vector& welllogcurves); + + /** + * @brief 获得该井次下所有表 + * @param[out] infos 井次下所有表 + */ + // void GetTableDataName(std::vector& infos); + + // /** + // * @brief 获得该井次下所有的岩心图片数据 + // * @param[out] coreimgs 所有的岩心图片数据 + // */ + // void GetCoreimg(std::vector& coreimgs); + + // /** + // * @brief 同时保存多条岩心图片数据 + // * @param[in] coreimgs 多条岩心图片数据 + // */ + // void SaveCoreimg(std::vector& coreimgs); + + // /** + // * @brief 获得该井次下所有的物性分析数据 + // * @param[out] corephysicss 物性分析数据 + // */ + // void GetCorePhysics(std::vector& corephysicss); + + // /** + // * @brief 同时保存多条物性分析数据 + // * @param[in] corephysicss 物性分析数据 + // */ + // void SaveCorePhysics(std::vector& corephysicss); + + // /** + // * @brief 获得该井次下所有的钻井取心数据 + // * @param[out] drillcores 钻井取心数据 + // */ + // void GetDrillCore(std::vector& drillcores); + + // /** + // * @brief 同时保存多条钻井取心数据 + // * @param[in] drillcores 钻井取心数据 + // */ + // void SaveDrillCore(std::vector& drillcores); + + // /** + // * @brief 获得该井次下所有的固井结论数据 + // * @param[out] gujing1results 固井结论数据 + // */ + // void GetGujing1Result(std::vector& gujing1results); + + // /** + // * @brief 同时保存多条固井结论数据 + // * @param[in] gujing1results 固井结论数据 + // */ + // void SaveGujing1Result(std::vector& gujing1results); + + // /** + // * @brief 获得该井次下所有的井壁取心数据 + // * @param[out] swallcores 井壁取心数据 + // */ + // void GetSwallCore(std::vector& swallcores); + + // /** + // * @brief 同时保存多条井壁取心数据 + // * @param[in] swallcores 井壁取心数据 + // */ + // void SaveSwallCore(std::vector& swallcores); + + // /** + // * @brief 获得该井次下所有的油气结论数据 + // * @param[out] ogresults 油气结论数据 + // */ + // void GetOgResult(std::vector& ogresults); + + // /** + // * @brief 同时保存多条油气结论数据 + // * @param[in] ogresults 油气结论数据 + // */ + // void SaveOgResult(std::vector& ogresults); + + // /** + // * @brief 获得该井次下所有的岩心描述数据 + // * @param[out] coredescs 岩心描述数据 + // */ + // void GetCoreDesc(std::vector& coredescs); + + // /** + // * @brief 同时保存多条岩心描述数据 + // * @param[in] coredescs 岩心描述数据 + // */ + // void SaveCoreDesc(std::vector& coredescs); + + // /** + // * @brief 获得该井次下所有的地质分层数据 + // * @param[out] geostratums 地质分层数据 + // */ + // void GetGeostratum(std::vector& geostratums); + + // /** + // * @brief 同时保存多条地质分层数据 + // * @param[in] geostratums 地质分层数据 + // */ + // void SaveGeostratum(std::vector& geostratums); + + // /** + // * @brief 获得该井次下所有的二次解释结论数据 + // * @param[out] ogresult2s 二次解释结论数据 + // */ + // void GetOgResult2(std::vector& ogresult2s); + + // /** + // * @brief 同时保存多条二次解释结论数据 + // * @param[in] ogresult2s 二次解释结论数据 + // */ + // void SaveOgResult2(std::vector& ogresult2s); + + // /** + // * @brief 获得该井次下所有的多维曲线索引 + // * @param[out] wavefiles 多维曲线索引 + // */ + // void GetWavefile(std::vector& wavefiles); + + // /** + // * @brief 同时保存多条多维曲线索引 + // * @param[in] wavefiles 多维曲线索引 + // */ + // void SaveWavefile(std::vector& wavefiles); + + // /** + // * @brief 获得该井次下所有的层段数据 + // * @param[out] zones 层段数据 + // */ + // void GetZone(std::vector& zones); + + // /** + // * @brief 同时保存多条层段数据 + // * @param[in] zones 层段数据 + // */ + // void SaveZone(std::vector& zones); + +public: + std::string GetAudit() const + { + return m_Audit; + } + + std::string GetCompanyName() const + { + return m_CompanyName; + } + + std::string GetDate() const + { + return m_Date; + } + + float GetDensity() const + { + return m_Density; + } + + std::string GetINTLog() const + { + return m_INTLog; + } + + std::string GetIntProg() const + { + return m_IntProg; + } + + std::string GetInteDress() const + { + return m_InteDress; + } + + std::string GetItem() const + { + return m_Item; + } + + std::string GetMudType() const + { + return m_MudType; + } + + float GetMudViscosity() const + { + return m_MudViscosity; + } + + std::string GetNITINT() const + { + return m_NITINT; + } + + std::string GetOperator() const + { + return m_Operator; + } + + std::string GetRemark() const + { + return m_Remark; + } + + float GetResi() const + { + return m_Resi; + } + + std::string GetSerial() const + { + return m_Serial; + } + + std::string GetTeam() const + { + return m_Team; + } + + float GetTemp() const + { + return m_Temp; + } + + float GetTempBot() const + { + return m_TempBot; + } + + float GetWaterLoss() const + { + return m_WaterLoss; + } + + void SetAudit(std::string audit) + { + this->m_Audit = audit; + } + + void SetCompanyName(std::string companyName) + { + this->m_CompanyName = companyName; + } + + void SetDate(std::string mdate) + { + this->m_Date = mdate; + } + + void SetDensity(float density) + { + this->m_Density = density; + } + + void SetINTLog(std::string mINTLog) + { + this->m_INTLog = mINTLog; + } + + void SetIntProg(std::string intProg) + { + this->m_IntProg = intProg; + } + + void SetInteDress(std::string inteDress) + { + this->m_InteDress = inteDress; + } + + void SetItem(std::string item) + { + this->m_Item = item; + } + + void SetMudType(std::string mudType) + { + this->m_MudType = mudType; + } + + void SetMudViscosity(float mudViscosity) + { + this->m_MudViscosity = mudViscosity; + } + + void SetNITINT(std::string mNITINT) + { + this->m_NITINT = mNITINT; + } + + void SetOperator(std::string moperator) + { + this->m_Operator = moperator; + } + + void SetRemark(std::string remark) + { + this->m_Remark = remark; + } + + void SetResi(float resi) + { + this->m_Resi = resi; + } + + void SetSerial(std::string serial) + { + this->m_Serial = serial; + } + + void SetTeam(std::string team) + { + this->m_Team = team; + } + + void SetTemp(float temp) + { + this->m_Temp = temp; + } + + void SetTempBot(float tempBot) + { + this->m_TempBot = tempBot; + } + + void SetWaterLoss(float waterLoss) + { + this->m_WaterLoss = waterLoss; + } + + void LoadMeesge(QString filename) + { + if(filename=="") return; + CMemRdWt *logio=new CMemRdWt(); + if(filename==""||!logio->Open(filename.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; +// QMessageBox::information(NULL,"提示","SLF文件打开失败，请检查！！",QMessageBox::Yes); + return; + } + logio->GetFileMessage(filemessage); + delete logio; + } + + void SaveMeesge(QString filename) + { + if(filename=="") return; + CMemRdWt *logio=new CMemRdWt(); + if(filename==""||!logio->Open(filename.toStdString().c_str(),CSlfIO::modeReadWrite)) + { + delete logio; +// QMessageBox::information(NULL,"提示","SLF文件打开失败，请检查！！",QMessageBox::Yes); + return; + } + logio->SetFileMessage(filemessage); + delete logio; + } + +private: + std::string m_CompanyName; ///<测井公司名 + std::string m_Team; ///<测井小队 + std::string m_Operator; ///<操作员 + std::string m_Date; ///<测井日期 + std::string m_Serial; ///<测井系列 + std::string m_Item; ///<测井项目 + std::string m_MudType; ///<泥浆类型 + float m_MudViscosity; ///<泥浆粘度 + float m_WaterLoss; ///<失水量 + float m_Density; ///<泥浆密度 + float m_Resi; ///<泥浆电阻率 + float m_Temp; ///<泥浆温度 + std::string m_INTLog; ///<测井井段 + std::string m_NITINT; ///<解释井段 + float m_TempBot; ///<井底温度 + std::string m_IntProg; ///<解释程序 + std::string m_InteDress; ///<解释员 + std::string m_Audit; ///<审核 + std::string m_Remark; ///<备注 + float TopDepth; + float BottomDepth; + std::string m_name; + Slf_FILE_MESSAGE filemessage; +}; + +} +} +} + +#endif diff --git a/OSGDataModel/src/ObjWell.cpp b/OSGDataModel/src/ObjWell.cpp new file mode 100644 index 0000000..0b498ad --- /dev/null +++ b/OSGDataModel/src/ObjWell.cpp @@ -0,0 +1,1441 @@ +#pragma warning( push ,0) +#include +#include "ObjWell.h" +#include "ObjWelllog.h" +#include "ObjWelllogRound.h" +// #include "ObjWellTrack.h" +// #include "ObjectFolder.h" +// #include "ObjProject.h" +// #include "ViewInfoMetaProperty.h" +#include +#include +#include +// #include "ObjectEvent.h" +#include +#include + +#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(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 &wellroundchildren) +// { +// this->GetObjectByType(wellroundchildren,GetClassID_WellLogRound()); +// return wellroundchildren.size(); +// } + +// int CObjWell::GetWellRoundCount() +// { +// QList wellroundchildren; +// this->GetObjectByType(wellroundchildren,GetClassID_WellLogRound()); +// return wellroundchildren.size(); +// } +void CObjWell::SetCurrentObjWellRound(CObjWelllogRound*pWellRound) +{ + m_pCurrentWelllogRound=pWellRound; +} + +CObjWelllogRound* CObjWell::GetCurrentObjWellRound() +{ +/* QList 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 objs; +// if(this->GetParent() != NULL) +// { +// GetParent()->GetChildren(objs); +// }else +// { +// GetProject()->GetWellsFolder(true)->GetPaiObject()->GetChildren(objs); +// } + + +// foreach(PaiObject* obj, objs) +// { +// CObjWell* pWell = dynamic_cast(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( 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 ;ifMD&&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) +// { +// QListchilds; +// int rcount=GetAllWellRound(childs); +// int flag=0; +// for(int j=0;j(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;iCopyCurve(*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;iCopyCurve(*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;iOpenCurve("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;ifMD&&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) +// { +// QListchilds; +// pWell->GetAllWellRound(childs); +// double stardep=99999,enddep=-99999; +// float rlev=100; +// for(int i=0;i(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;k1GetObjectName(k1,buf); +// int a=logio->OpenCurve(buf); +// if(a>-1) +// { +// Slf_CURVE acurveinfo; +// logio->GetCurveInfo(a,&acurveinfo); +// if(acurveinfo.StartDepthenddep) 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.StartDepthenddep) 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::vectorvX; +// std::vectorvY; +// std::vectorvZ; +// std::vectorvTVD; +// 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;iGetObjectStatus(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;iCreateCurve(&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=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.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.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_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 -1&&i=0&&iGetForebear(GetClassID_Project()); +// if(paiProject) +// { +// pai::datamodel::CObjProject *currentProject = dynamic_cast(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(CPaiObjectHelper::GetSubtree(::GetProject(),wellroundPath.append("/").append(templateKey.toString()))); +// } +// pai::datamodel::CObjWellLog* CObjWell::GetWellLogByTemplate(const QVariant& templateKey) +// { +// QList wellLogsUnderRounds; +// QList welllogOrRounds; +// this->GetChildren(welllogOrRounds); +// for(int i= welllogOrRounds.size()-1; i>=0; --i) +// { + +// if(welllogOrRounds[i]->GetTypeID() == GetClassID_WellLogRound() ) +// { +// CObjWelllogRound* currentround=dynamic_cast(welllogOrRounds[i]); +// QString wellroundspath=currentround->GetWellRoundPath(); +// CObjWellLog* result=dynamic_cast(CPaiObjectHelper::GetSubtree(::GetProject(),wellroundspath.append("/").append(templateKey.toString()))); +// if(result) return result; +// QList welllogsUnderRound; +// welllogOrRounds[i]->GetChildren(welllogsUnderRound); +// wellLogsUnderRounds << welllogsUnderRound; + +// welllogOrRounds.removeAt(i); +// } +// } +// welllogOrRounds << wellLogsUnderRounds ; +// foreach(PaiObject* welllog, welllogOrRounds) +// { +// pai::datamodel::CBaseObject* welllogCurve = dynamic_cast(welllog); +// if(welllogCurve!= NULL && welllogCurve->GetTemplateKey() == templateKey) +// { +// return dynamic_cast(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(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(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 diff --git a/OSGDataModel/src/ObjWelllogRound.cpp b/OSGDataModel/src/ObjWelllogRound.cpp new file mode 100644 index 0000000..847038e --- /dev/null +++ b/OSGDataModel/src/ObjWelllogRound.cpp @@ -0,0 +1,383 @@ +#pragma warning( push ,0) +#include +#include "ObjWelllogRound.h" +#include "ObjWelllog.h" +#include "ObjWell.h" +#include +// #include "WellLogWorkflowDataModel.h" +#pragma warning( pop ) + +BEGIN_OSGDATAMODEL_NAMESPACE; +CObjWelllogRound *g_pObjWelllogRound(NULL); + +OSGDATAMODEL_EXPORT CObjWelllogRound *GetCurrentObjWelllogRound() +{ + return g_pObjWelllogRound; +} + +OSGDATAMODEL_EXPORT void SetCurrentObjWelllogRound( CObjWelllogRound *pObjWelllogRound ) +{ + g_pObjWelllogRound = pObjWelllogRound; + if(pObjWelllogRound)SetCurrentObjWell(pObjWelllogRound->GetWell()); +} +// OSGDATAMODEL_EXPORT QString GetCurrentWellRoundPath() +// { +// if(g_pObjWelllogRound) +// { +// return g_pObjWelllogRound->GetWellRoundPath(); +// } +// else +// { +// //TODO 输出日志提醒 +// return ""; +// } +// } +// OSGDATAMODEL_EXPORT QString GetSingleWellFolderID() +// { +// if(g_pObjWelllogRound) +// { +// return g_pObjWelllogRound->GetParent()->GetChildByType(GetClassID_SingleMethodFolder())->GetID(); +// } +// else +// { +// //TODO 输出日志提醒 +// return ""; +// } +// } +// QString CObjWelllogRound::GetWellRoundPath() +// { +// QString CurrentWellRoundPath=GetFullPathName(); +// QStringList strList = CurrentWellRoundPath.split("/",QString::SkipEmptyParts); +// strList.takeFirst(); +// CurrentWellRoundPath = strList.join("/"); +// return CurrentWellRoundPath; +// } +QString CObjWelllogRound::GetDescription() +{ + CLogIO *logio=new CLogIO(); + QString slfFileName=GetSlfFileName(); + if(slfFileName.isEmpty()) return ""; + if(!logio->Open(slfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; + return ""; + } + float StartDepth=999999; + float EndDepth=-999999; + float MinDepLevel=999999; + float MaxDepLevel=-999999; + int nCurve=0; + int nTable=0; + int nWave=0; + int nCard=0; + int nOther=0; + int nDelete=0; + int count=logio->GetObjectCount(); + for(int i=0;iGetObjectStatus(i)!=OBJECT_NORMAL) { + nDelete++; + continue; + } + short curvetype=logio->GetObjectType(i); + short Attribute=0,SubAttribute=0; + logio->GetObjectAttribute(i,&Attribute,&SubAttribute); + if(curvetype==CURVE_OBJECT) + { + Slf_CURVE acurveinfo; + logio->GetCurveInfo(i,&acurveinfo); + nCurve++; + if(acurveinfo.DepLevel>MaxDepLevel) MaxDepLevel=acurveinfo.DepLevel; + if(acurveinfo.DepLevelEndDepth) EndDepth=acurveinfo.EndDepth; + } + else if(curvetype==WAVE_OBJECT) + { + Slf_WAVE acurveinfo; + logio->GetWaveInfo(i,&acurveinfo); + nWave++; + if(acurveinfo.DepLevel>MaxDepLevel) MaxDepLevel=acurveinfo.DepLevel; + if(acurveinfo.DepLevelEndDepth) EndDepth=acurveinfo.EndDepth; + } + else if(curvetype==CARD_OBJECT) + { + nCard++; + } + else if(curvetype==FMT_OBJECT) + { + nOther++; + } + else if(curvetype==TDT_OBJECT) + { + nOther++; + } + else if(curvetype>CARD_OBJECT||curvetype==0) + { + nTable++; + } + } + delete logio; + QString result=""; + result.append("对象类型:井次文件\n"); + result.append("总对象数:").append(QString::number(count)).append("\n");; + result.append("标记为删除对象数:").append(QString::number(nDelete)).append("\n");; + result.append("曲线数:").append(QString::number(nCurve)).append("\n"); + result.append("表格数:").append(QString::number(nTable)).append("\n"); + result.append("参数卡:").append(QString::number(nCard)).append("\n"); + result.append("其它:").append(QString::number(nOther)).append("\n"); + result.append("最小深度:").append(QString::number(StartDepth)).append("\n"); + result.append("最大深度:").append(QString::number(EndDepth)).append("\n"); + result.append("最小采样间隔:").append(QString::number(MinDepLevel)).append("\n"); + result.append("最小采样间隔:").append(QString::number(MaxDepLevel)).append("\n"); + return result; +} + +CObjWell *CObjWelllogRound::GetWell() +{ + return m_pWell; +} +void CObjWelllogRound::SetWell(CObjWell *pWell) +{ + m_pWell=pWell; +} + +// CObjWelllogRound::CObjWelllogRound() +// { +// SetIconName( "icon/WellRound.png"); +// m_pObject = NULL; +// m_pWell=NULL; +// isFLAG=false; +// } +// void CObjWelllogRound::SetSlfFileName(QString val) +// { +// QString oldf=m_strAttachedSlfFile; +// m_strAttachedSlfFile=val; +// std::vector PaiObjects; +// CPaiObjectHelper::RecursionGetAllChildren(this,PaiObjects ); +// for(int j=0;j(PaiObjects[j]); +// if(tempWellLog) { +// tempWellLog->SetSlfFileName(val); +// continue; +// } +// PaiObject *pObj=PaiObjects[j]->GetPaiObject()->GetObjectByType(GetClassID_WorkflowFolder()); +// if(pObj) { +// QList childs; +// pObj->GetChildren(childs); +// for (int n=0;n(childs[n]); +// if(tempWellLog) { +// CBaseObject *pBaseObject=tempWellLog->GetMWVecWindowDocument(); +// if(pBaseObject) { +// QList childObjects; +// pBaseObject->GetPaiObject()->GetChildren(childObjects); +// for(int i=0;i(childObjects[i]); +// if(pWellTrack) { +// if(!pWellTrack->GetWelllogRound()) continue; +// CObjWell*pWell=pWellTrack->GetWelllogRound()->GetWell(); +// if(pWell==this->GetWell()) continue; +// if(pWell) { +// int index0=val.lastIndexOf("."); +// QString nf=val.left(index0); +// QString old=pWell->GetWellMessageFileName(); +// int index=old.lastIndexOf("."); +// int index1=oldf.lastIndexOf("."); +// QString onf=oldf.left(index1); +// if(old.compare(onf,Qt::CaseInsensitive)==0&&nf.compare(old,Qt::CaseInsensitive)) { +// pWell->SetWellFileName(m_strAttachedSlfFile); +// QList pWellRs; +// int count=pWell->GetAllWellRound(pWellRs); +// for(int k=0;k(pWellRs[k]); +// if(pWellR==this) continue; +// pWellR->SetSlfFileName(val); +// } +// } +// } +// } +// } +// } +// } +// } +// } +// } +// } + +CObjWelllogRound::~CObjWelllogRound() +{ + if(g_pObjWelllogRound==this) g_pObjWelllogRound=NULL; + CObjWell *pWell=GetWell(); + if(pWell) pWell->SetCurrentObjWellRound(NULL); + return; +} + +// void CObjWelllogRound::setParent(PaiObject* pObject) +// { +// m_pObject = pObject; +// } +// bool CObjWelllogRound::isExistsName(QString name) +// { +// QList objs; +// if(this->GetParent() != NULL) +// { +// GetParent()->GetChildren(objs); +// }else +// { +// if(m_pObject != NULL) +// { +// m_pObject->GetChildren(objs); +// } + +// } + +// foreach(PaiObject* obj, objs) +// { +// CObjWelllogRound* pTempRound = dynamic_cast(obj); +// if(pTempRound != NULL && pTempRound != this && pTempRound->GetName().compare(name,Qt::CaseInsensitive)==0) +// { +// return true; +// } +// } +// return false; +// } + +void CObjWelllogRound::SetBelongID() +{ + // pai::objectmodel::PaiObject* paiWell = this->GetForebear(GetClassID_Well()); + // if(paiWell) + // { + // pai::datamodel::CObjWell *currentWell= dynamic_cast(paiWell); + // if(currentWell) + // { + // pai::ios::welllog::DataObject* dbWell = currentWell->GetDbObject(); + // if(dbWell) + // { + // m_DbWelllogRound.SetDataBelongID(dbWell->GetDataID()); + // } + // } + // } +} +QUuid CObjWelllogRound::GetTypeID()const +{ + return GetClassID_WellLogRound(); +} + + +// bool CObjWelllogRound::Serialize( CObjectArchive &ar ) +// { +// if(ar.IsStoring()) +// { + +// BEGIN_WRITE_OBJECT( ar,1 ); + +// BEGIN_WRITE_BLOCK( ar, 1); + +// CBaseObjectImpl::Serialize( ar ); +// ar<>m_strAttachedSlfFile; +// END_READ_BLOCK( 1 ); + +// END_READ_OBJECT( ar ); +// } +// return true; +// } + + +// void CObjWelllogRound::SetDBWelllogRound( pai::ios::welllog::WelllogRound DbWelllogRound ) +// { +// m_DbWelllogRound=DbWelllogRound; +// } + +pai::ios::welllog::WelllogRound &CObjWelllogRound::GetDBWelllogRound() +{ + return m_DbWelllogRound; + +} + +pai::ios::welllog::DataObject * CObjWelllogRound::GetDbObject() +{ + SetBelongID(); + return &m_DbWelllogRound; +} + + +void CObjWelllogRound::CopyFrom( CBaseObject *pOSGObjectOther ) +{ + CBaseObject::CopyFrom( pOSGObjectOther ); + + CObjWelllogRound *pWellRound = dynamic_cast( pOSGObjectOther ); + if( pWellRound ) + { + m_DbWelllogRound= pWellRound->m_DbWelllogRound ; + } +} +// +// bool CObjWelllogRound::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; +// } + +//往井次下加入曲线时，根据曲线的类型返回其对应的目录id +QUuid CObjWelllogRound::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() + + ;} +// //根据folderid找到对应的folder，如果没有则创建 +// CObjectFolder* CObjWelllogRound::GetTragetFolder(QUuid aFolderTypeid) +// { +// CObjectFolder* target=dynamic_cast(GetChildByType(aFolderTypeid)); +// if(target==NULL){ +// target=new CObjectFolder(aFolderTypeid); +// CBaseObjectImpl::AddChild(target,true); +// } +// return target; +// } + + +// CObjWellLog* CObjWelllogRound::GetWellLogByName(QString name) +// { +// CObjWellLog* result=NULL; +// result=dynamic_cast(GetObjectByName(name,3)); +// return result; +// } + +// BEGIN_REGISTER_OBJECT(CObjWelllogRound) +// QUuid(GetClassID_WellLogRound()) +// END_REGISTER_OBJECT( CObjWelllogRound ); + + + + + +END_OSGDATAMODEL_NAMESPACE diff --git a/OSGDataModel/src/Well.cpp b/OSGDataModel/src/Well.cpp new file mode 100644 index 0000000..48b5fb0 --- /dev/null +++ b/OSGDataModel/src/Well.cpp @@ -0,0 +1,329 @@ +#include "Well.h" +#include "../include/WelllogRound.h" +// #include "orm/sqlite/Persistence.h" +// #include "orm/gen/Well.h" +// #include "orm/gen/Wellloground.h" +#include + +// using namespace pai::error; +// using namespace pai::turtle; +using namespace std; + +namespace pai { +namespace ios { +namespace welllog { + + +Well::Well(const Well& well):DataObject(well),m_AreaName(well.GetAreaName()), m_CompanyName(well.GetCompanyName()), + m_WellType(well.GetWellType()),m_XCode(well.GetXCode()), + m_YCode(well.GetYCode()),m_Asl(well.GetAsl()),m_Bsl(well.GetBsl()),m_SDrillDate(well.GetSDrillDate()), + m_EDrillDate(well.GetEDrillDate()),m_CompleteDate(well.GetCompleteDate()),m_CWMethod(well.GetCWMethod()), + m_Bit1Prog(well.GetBit1Prog()),m_Bit2Prog(well.GetBit2Prog()),m_Bit3Prog(well.GetBit3Prog()),m_Bit4Prog(well.GetBit4Prog()), + m_Bit5Prog(well.GetBit5Prog()),m_Cas1Prog(well.GetCas1Prog()),m_Cas2Prog(well.GetCas2Prog()),m_Cas3Prog(well.GetCas3Prog()), + m_Cas4Prog(well.GetCas4Prog()),m_Cas5Prog(well.GetCas5Prog()),m_Cas1Shot(well.GetCas1Shot()),m_SC1SDep(well.GetSC1SDep()), + m_SC1EDep(well.GetSC1EDep()),m_Cas2Shot(well.GetCas2Shot()),m_SC2SDep(well.GetSC2SDep()),m_SC2EDep(well.GetSC2EDep()), + m_Remark(well.GetRemark()),m_Points(well.GetPoint()),m_name(well.m_name) +{ + filemessage=well.filemessage; +} + +Well & Well::operator=(const Well& well) +{ + if(this == &well) + return *this; + DataObject::operator=(well); + this->SetAreaName(well.GetAreaName()); + this->SetCompanyName(well.GetCompanyName()); + this->SetWellType(well.GetWellType()); + this->SetXCode(well.GetXCode()); + this->SetYCode(well.GetYCode()); + this->SetAsl(well.GetAsl()); + this->SetBsl(well.GetBsl()); + this->SetSDrillDate(well.GetSDrillDate()); + this->SetEDrillDate(well.GetEDrillDate()); + this->SetCompleteDate(well.GetCompleteDate()); + this->SetCWMethod(well.GetCWMethod()); + this->SetBit1Prog(well.GetBit1Prog()); + this->SetBit2Prog(well.GetBit2Prog()); + this->SetBit3Prog(well.GetBit3Prog()); + this->SetBit4Prog(well.GetBit4Prog()); + this->SetBit5Prog(well.GetBit5Prog()); + this->SetCas1Prog(well.GetCas1Prog()); + this->SetCas2Prog(well.GetCas2Prog()); + this->SetCas3Prog(well.GetCas3Prog()); + this->SetCas4Prog(well.GetCas4Prog()); + this->SetCas5Prog(well.GetCas5Prog()); + this->SetCas1Shot(well.GetCas1Shot()); + this->SetSC1SDep(well.GetSC1SDep()); + this->SetSC1EDep(well.GetSC1EDep()); + this->SetCas2Shot(well.GetCas2Shot()); + this->SetSC2SDep(well.GetSC2SDep()); + this->SetSC2EDep(well.GetSC2EDep()); + this->SetRemark(well.GetRemark()); + this->SetPoint(well.GetPoint()); + return *this; +} + +void Well::Save() +{ + // pai::orm::Well well; + + // well.SetProjectId(this->GetDataBelongID()); + // well.SetAreaName(m_AreaName); + // well.SetCompanyName(m_CompanyName); + // well.SetWellName(this->GetName()); + // well.SetWellType(m_WellType); + // well.SetXCoordinate(m_XCode); + // well.SetYCoordinate(m_YCode); + // well.SetAsl(m_Asl); + // well.SetBsl(m_Bsl); + // well.SetDateSdrill(m_SDrillDate); + // well.SetDateEdrill(m_EDrillDate); + // well.SetDateComplete(m_CompleteDate); + // well.SetMethodCwell(m_CWMethod); + // well.SetBit1Prog(m_Bit1Prog); + // well.SetBit2Prog(m_Bit2Prog); + // well.SetBit3Prog(m_Bit3Prog); + // well.SetBit4Prog(m_Bit4Prog); + // well.SetBit5Prog(m_Bit5Prog); + // well.SetCas1Prog(m_Cas1Prog); + // well.SetCas2Prog(m_Cas2Prog); + // well.SetCas3Prog(m_Cas3Prog); + // well.SetCas4Prog(m_Cas4Prog); + // well.SetCas5Prog(m_Cas5Prog); + // well.SetShotCas1(m_Cas1Shot); + // well.SetSc1Sdep(m_SC1SDep); + // well.SetSc1Edep(m_SC1EDep); + // well.SetShotCas2(m_Cas2Shot); + // well.SetSc2Sdep(m_SC2SDep); + // well.SetSc2Edep(m_SC2EDep); + // well.SetRemark(m_Remark); + // //存入井轨迹点 + // size_t bufferLength = sizeof(size_t) + m_Points.size()*sizeof(Point); + // char *buffer = new char[bufferLength]; + // size_t pointSize = m_Points.size(); + + // memcpy(buffer, &pointSize, sizeof(size_t)); + // if (pointSize > 0) + // { + // memcpy(buffer+sizeof(size_t), reinterpret_cast(&(m_Points[0])), m_Points.size()*sizeof(Point)); + // } + // pai::orm::Blob blob; + // blob.FromBuffer(buffer, bufferLength); + // if (buffer != NULL) + // { + // delete[] buffer; + // buffer = NULL; + // } + + // well.SetTrajectory(blob); + + // pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + // long long wlogId = pdb.Persist(well, true); + // this->SetDataID(wlogId); +} + +void Well::Get(long long id) +{ + // if(id <= 0) + // { + // std::stringstream ss; + // ss << PAI_CURRENT_FUNCTION << ": WelllogID <= 0."; + // throw pai::error::db_error(ss.str(), ERR_PARAMETER_ERROR); + // } + + // pai::orm::Well well; + // pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + // pdb.Load(pai::orm::Well::Well_id == id, well, true); + + // this->SetDataID(well.GetWellId()); + // this->SetDataBelongID(well.GetProjectId()); + // this->SetAreaName(well.GetAreaName()); + // this->SetCompanyName(well.GetCompanyName()); + // this->SetName(well.GetWellName()); + // this->SetWellType(well.GetWellType()); + // this->SetXCode(well.GetXCoordinate()); + // this->SetYCode(well.GetYCoordinate()); + // this->SetAsl(well.GetAsl()); + // this->SetBsl(well.GetBsl()); + // this->SetSDrillDate(well.GetDateSdrill()); + // this->SetEDrillDate(well.GetDateEdrill()); + // this->SetCompleteDate(well.GetDateComplete()); + // this->SetCWMethod(well.GetMethodCwell()); + // this->SetBit1Prog(well.GetBit1Prog()); + // this->SetBit2Prog(well.GetBit2Prog()); + // this->SetBit3Prog(well.GetBit3Prog()); + // this->SetBit4Prog(well.GetBit4Prog()); + // this->SetBit5Prog(well.GetBit5Prog()); + // this->SetCas1Prog(well.GetCas1Prog()); + // this->SetCas2Prog(well.GetCas2Prog()); + // this->SetCas3Prog(well.GetCas3Prog()); + // this->SetCas4Prog(well.GetCas4Prog()); + // this->SetCas5Prog(well.GetCas5Prog()); + // this->SetCas1Shot(well.GetShotCas1()); + // this->SetSC1SDep(well.GetSc1Sdep()); + // this->SetSC1EDep(well.GetSc1Edep()); + // this->SetCas2Shot(well.GetShotCas2()); + // this->SetSC2SDep(well.GetSc2Sdep()); + // this->SetSC2EDep(well.GetSc2Edep()); + // this->SetRemark(well.GetRemark()); + // //获取井轨迹点 + // pai::orm::Blob blob; + // blob = well.GetTrajectory(); + // char *buffer = blob.GetData(); + + // size_t pointSize; + // memcpy(&pointSize, buffer,sizeof(size_t)); + // if (pointSize > 0) + // { + // m_Points.resize(pointSize); + // memcpy(&(m_Points[0]), buffer+sizeof(size_t), sizeof(Point)*pointSize); + // } +} + +void Well::Update() +{ + // pai::orm::Well well; + // well.SetWellId(this->GetDataID()); + // well.SetProjectId(this->GetDataBelongID()); + // well.SetAreaName(m_AreaName); + // well.SetCompanyName(m_CompanyName); + // well.SetWellName(this->GetName()); + // well.SetWellType(m_WellType); + // well.SetXCoordinate(m_XCode); + // well.SetYCoordinate(m_YCode); + // well.SetAsl(m_Asl); + // well.SetBsl(m_Bsl); + // well.SetDateSdrill(m_SDrillDate); + // well.SetDateEdrill(m_EDrillDate); + // well.SetDateComplete(m_CompleteDate); + // well.SetMethodCwell(m_CWMethod); + // well.SetBit1Prog(m_Bit1Prog); + // well.SetBit2Prog(m_Bit2Prog); + // well.SetBit3Prog(m_Bit3Prog); + // well.SetBit4Prog(m_Bit4Prog); + // well.SetBit5Prog(m_Bit5Prog); + // well.SetCas1Prog(m_Cas1Prog); + // well.SetCas2Prog(m_Cas2Prog); + // well.SetCas3Prog(m_Cas3Prog); + // well.SetCas4Prog(m_Cas4Prog); + // well.SetCas5Prog(m_Cas5Prog); + // well.SetShotCas1(m_Cas1Shot); + // well.SetSc1Sdep(m_SC1SDep); + // well.SetSc1Edep(m_SC1EDep); + // well.SetShotCas2(m_Cas2Shot); + // well.SetSc2Sdep(m_SC2SDep); + // well.SetSc2Edep(m_SC2EDep); + // well.SetRemark(m_Remark); + // //存入井轨迹点 + // size_t bufferLength = sizeof(size_t) + m_Points.size()*sizeof(Point); + // char *buffer = new char[bufferLength]; + // size_t pointSize = m_Points.size(); + // memcpy(buffer, &pointSize, sizeof(size_t)); + // if (pointSize > 0) + // { + // memcpy(buffer+sizeof(size_t), reinterpret_cast(&(m_Points[0])), m_Points.size()*sizeof(Point)); + // } + // pai::orm::Blob blob; + // blob.FromBuffer(buffer, bufferLength); + // if (buffer != NULL) + // { + // delete[] buffer; + // buffer = NULL; + // } + + // well.SetTrajectory(blob); + + // pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + // pdb.Update(well, true); +} + +void Well::Delete(long long id) +{ + // if(id <= 0) + // { + // std::stringstream ss; + // ss << PAI_CURRENT_FUNCTION << ": WellID <= 0."; + // throw pai::error::db_error(ss.str(), ERR_PARAMETER_ERROR); + // } + + // pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + + // pdb.Delete(pai::orm::Well::Well_id == id); +} + +void Well::GetWelllogRound(std::vector& infos) +{ + // pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + + // vector wRounds; + + // pdb.Load((pai::orm::Wellloground::Well_id == this->GetDataID()), wRounds); + // for(size_t i = 0; i < wRounds.size(); i++) + // { + // WelllogRound welllogRound; + // welllogRound.SetDataID(wRounds[i].GetWelllogroundId()); + // welllogRound.SetDataBelongID(wRounds[i].GetWellId()); + // welllogRound.SetName(wRounds[i].GetWelllogroundName()); + // welllogRound.SetCompanyName(wRounds[i].GetLogCompanyName()); + // welllogRound.SetTeam(wRounds[i].GetTeam()); + // welllogRound.SetOperator(wRounds[i].GetOperator()); + // welllogRound.SetDate(wRounds[i].GetDate()); + // welllogRound.SetSerial(wRounds[i].GetSerial()); + // welllogRound.SetItem(wRounds[i].GetItem()); + // welllogRound.SetMudType(wRounds[i].GetMudType()); + // welllogRound.SetMudViscosity(wRounds[i].GetMudViscosity()); + // welllogRound.SetWaterLoss(wRounds[i].GetWaterLoss()); + // welllogRound.SetDensity(wRounds[i].GetMudDensity()); + // welllogRound.SetResi(wRounds[i].GetMudResi()); + // welllogRound.SetTemp(wRounds[i].GetMudTemp()); + // welllogRound.SetINTLog(wRounds[i].GetIntLog()); + // welllogRound.SetNITINT(wRounds[i].GetNitInt()); + // welllogRound.SetTempBot(wRounds[i].GetTempBot()); + // welllogRound.SetIntProg(wRounds[i].GetIntProg()); + // welllogRound.SetInteDress(wRounds[i].GetInteDress()); + // welllogRound.SetAudit(wRounds[i].GetAudit()); + // welllogRound.SetRemark(wRounds[i].GetRemark()); + // infos.push_back(welllogRound); + // } +} + +void Well::SaveWelllogRound(std::vector& welllogrounds) +{ + // std::vector ormwelllogrounds; + // pai::orm::Wellloground ormwellloground; + // for(size_t i = 0; i < welllogrounds.size(); ++i) + // { + // ormwellloground.SetWelllogroundId(welllogrounds[i].GetDataID()); + // ormwellloground.SetWellId(welllogrounds[i].GetDataBelongID()); + // ormwellloground.SetWelllogroundName(welllogrounds[i].GetName()); + // ormwellloground.SetLogCompanyName(welllogrounds[i].GetCompanyName()); + // ormwellloground.SetTeam(welllogrounds[i].GetTeam()); + // ormwellloground.SetOperator(welllogrounds[i].GetOperator()); + // ormwellloground.SetDate(welllogrounds[i].GetDate()); + // ormwellloground.SetSerial(welllogrounds[i].GetSerial()); + // ormwellloground.SetItem(welllogrounds[i].GetItem()); + // ormwellloground.SetMudType(welllogrounds[i].GetMudType()); + // ormwellloground.SetMudViscosity(welllogrounds[i].GetMudViscosity()); + // ormwellloground.SetWaterLoss(welllogrounds[i].GetWaterLoss()); + // ormwellloground.SetMudDensity(welllogrounds[i].GetDensity()); + // ormwellloground.SetMudResi(welllogrounds[i].GetResi()); + // ormwellloground.SetMudTemp(welllogrounds[i].GetTemp()); + // ormwellloground.SetIntLog(welllogrounds[i].GetINTLog()); + // ormwellloground.SetNitInt(welllogrounds[i].GetNITINT()); + // ormwellloground.SetTempBot(welllogrounds[i].GetTempBot()); + // ormwellloground.SetIntProg(welllogrounds[i].GetIntProg()); + // ormwellloground.SetInteDress(welllogrounds[i].GetInteDress()); + // ormwellloground.SetAudit(welllogrounds[i].GetAudit()); + // ormwellloground.SetRemark(welllogrounds[i].GetRemark()); + + // ormwelllogrounds.push_back(ormwellloground); + // } + + // pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + // pdb.Persist(ormwelllogrounds); +} + +} +} +} diff --git a/OSGDataModel/src/WelllogRound.cpp b/OSGDataModel/src/WelllogRound.cpp new file mode 100644 index 0000000..ed43abc --- /dev/null +++ b/OSGDataModel/src/WelllogRound.cpp @@ -0,0 +1,801 @@ +#include "WelllogRound.h" +// #include "WelllogCurve.h" +// #include "TableData.h" +// #include "orm/sqlite/Persistence.h" +// #include "orm/gen/Wellloground.h" +// #include "orm/gen/Welllogcurve.h" +// #include "orm/gen/Tableinfo.h" +// #include "orm/WelllogResultSet.h" +// #include "orm/gen/Coreimg.h" +// #include "orm/gen/CorePhysics.h" +// #include "orm/gen/DrillCore.h" +// #include "orm/gen/Gujing1Result.h" +// #include "orm/gen/SwallCore.h" +// #include "orm/gen/OgResult.h" +// #include "orm/gen/CoreDesc.h" +// #include "orm/gen/Geostratum.h" +// #include "orm/gen/OgResult2.h" +// #include "orm/gen/Wavefile.h" +// #include "orm/gen/Zone.h" +#include + +using namespace std; +// using namespace pai::error; +// using namespace pai::turtle; + +namespace pai { +namespace ios { +namespace welllog { + +/** + * @brief 构造函数 + */ + +WelllogRound::WelllogRound(const WelllogRound& welllogRound):DataObject(welllogRound),m_CompanyName(welllogRound.GetCompanyName()),m_Team(welllogRound.GetTeam()), + m_Operator(welllogRound.GetOperator()),m_Date(welllogRound.GetDate()),m_Serial(welllogRound.GetSerial()),m_Item(welllogRound.GetItem()), + m_MudType(welllogRound.GetMudType()),m_MudViscosity(welllogRound.GetMudViscosity()),m_WaterLoss(welllogRound.GetWaterLoss()),m_Density(welllogRound.GetDensity()), + m_Resi(welllogRound.GetResi()),m_Temp(welllogRound.GetTemp()),m_INTLog(welllogRound.GetINTLog()),m_NITINT(welllogRound.GetNITINT()), + m_TempBot(welllogRound.GetTempBot()),m_IntProg(welllogRound.GetIntProg()),m_InteDress(welllogRound.GetInteDress()),m_Audit(welllogRound.GetAudit()), + m_Remark(welllogRound.GetRemark()),filemessage(welllogRound.filemessage),m_name(welllogRound.m_name) +{ + +} + +WelllogRound & WelllogRound::operator=(const WelllogRound& welllogRound) +{ + if(this == &welllogRound) + return *this; + DataObject::operator=(welllogRound); + this->SetCompanyName(welllogRound.GetCompanyName()); + this->SetTeam(welllogRound.GetTeam()); + this->SetOperator(welllogRound.GetOperator()); + this->SetDate(welllogRound.GetDate()); + this->SetSerial(welllogRound.GetSerial()); + this->SetItem(welllogRound.GetItem()); + this->SetMudType(welllogRound.GetMudType()); + this->SetMudViscosity(welllogRound.GetMudViscosity()); + this->SetWaterLoss(welllogRound.GetWaterLoss()); + this->SetDensity(welllogRound.GetDensity()); + this->SetResi(welllogRound.GetResi()); + this->SetTemp(welllogRound.GetTemp()); + this->SetINTLog(welllogRound.GetINTLog()); + this->SetNITINT(welllogRound.GetNITINT()); + this->SetTempBot(welllogRound.GetTempBot()); + this->SetIntProg(welllogRound.GetIntProg()); + this->SetInteDress(welllogRound.GetInteDress()); + this->SetAudit(welllogRound.GetAudit()); + this->SetRemark(welllogRound.GetRemark()); + return *this; +} + +void WelllogRound::Save() +{ + // pai::orm::Wellloground wRound; + // wRound.SetWellId(this->GetDataBelongID()); + // wRound.SetWelllogroundName(this->GetName()); + // wRound.SetLogCompanyName(m_CompanyName); + // wRound.SetTeam(m_Team); + // wRound.SetOperator(m_Operator); + // wRound.SetDate(m_Date); + // wRound.SetSerial(m_Serial); + // wRound.SetItem(m_Item); + // wRound.SetMudType(m_MudType); + // wRound.SetMudViscosity(m_MudViscosity); + // wRound.SetWaterLoss(m_WaterLoss); + // wRound.SetMudDensity(m_Density); + // wRound.SetMudResi(m_Resi); + // wRound.SetMudTemp(m_Temp); + // wRound.SetIntLog(m_INTLog); + // wRound.SetNitInt(m_NITINT); + // wRound.SetTempBot(m_TempBot); + // wRound.SetIntProg(m_IntProg); + // wRound.SetInteDress(m_InteDress); + // wRound.SetAudit(m_Audit); + // wRound.SetRemark(m_Remark); + + // pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + // long long wroundId = pdb.Persist(wRound); + // this->SetDataID(wroundId); +} + +void WelllogRound::Get(long long id) +{ + // if(id <= 0) + // { + // std::stringstream ss; + // ss << PAI_CURRENT_FUNCTION << ": WelllogRoundID <= 0."; + // throw pai::error::db_error(ss.str(), ERR_PARAMETER_ERROR); + // } + + // pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + + // pai::orm::Wellloground wRound; + // pdb.Load(pai::orm::Wellloground::Wellloground_id == id, wRound); + // this->SetDataID(wRound.GetWelllogroundId()); + // this->SetDataBelongID(wRound.GetWellId()); + // this->SetName(wRound.GetWelllogroundName()); + // this->SetCompanyName(wRound.GetLogCompanyName()); + // this->SetTeam(wRound.GetTeam()); + // this->SetOperator(wRound.GetOperator()); + // this->SetDate(wRound.GetDate()); + // this->SetSerial(wRound.GetSerial()); + // this->SetItem(wRound.GetItem()); + // this->SetMudType(wRound.GetMudType()); + // this->SetMudViscosity(wRound.GetMudViscosity()); + // this->SetWaterLoss(wRound.GetWaterLoss()); + // this->SetDensity(wRound.GetMudDensity()); + // this->SetResi(wRound.GetMudResi()); + // this->SetTemp(wRound.GetMudTemp()); + // this->SetINTLog(wRound.GetIntLog()); + // this->SetNITINT(wRound.GetNitInt()); + // this->SetTempBot(wRound.GetTempBot()); + // this->SetIntProg(wRound.GetIntProg()); + // this->SetInteDress(wRound.GetInteDress()); + // this->SetAudit(wRound.GetAudit()); + // this->SetRemark(wRound.GetRemark()); +} + +void WelllogRound::Update() +{ + // pai::orm::Wellloground wRound; + // wRound.SetWelllogroundId(this->GetDataID()); + // wRound.SetWellId(this->GetDataBelongID()); + // wRound.SetWelllogroundName(this->GetName()); + // wRound.SetLogCompanyName(m_CompanyName); + // wRound.SetTeam(m_Team); + // wRound.SetOperator(m_Operator); + // wRound.SetDate(m_Date); + // wRound.SetSerial(m_Serial); + // wRound.SetItem(m_Item); + // wRound.SetMudType(m_MudType); + // wRound.SetMudViscosity(m_MudViscosity); + // wRound.SetWaterLoss(m_WaterLoss); + // wRound.SetMudDensity(m_Density); + // wRound.SetMudResi(m_Resi); + // wRound.SetMudTemp(m_Temp); + // wRound.SetIntLog(m_INTLog); + // wRound.SetNitInt(m_NITINT); + // wRound.SetTempBot(m_TempBot); + // wRound.SetIntProg(m_IntProg); + // wRound.SetInteDress(m_InteDress); + // wRound.SetAudit(m_Audit); + // wRound.SetRemark(m_Remark); + + // pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + // pdb.Update(wRound); +} + +void WelllogRound::Delete(long long id) +{ +// if(id <= 0) +// { +// std::stringstream ss; +// ss << PAI_CURRENT_FUNCTION << ": WelllogRoundID <= 0."; +// throw pai::error::db_error(ss.str(), ERR_PARAMETER_ERROR); +// } + +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + +// pdb.Delete(pai::orm::Wellloground::Wellloground_id == id); +} + +// void WelllogRound::GetWelllogCurve(std::vector& infos) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector wCurves; +// pdb.Load(pai::orm::Welllogcurve::Wellloground_id == this->GetDataID(), wCurves, true); +// for(size_t i = 0; i < wCurves.size(); i++) +// { +// WelllogCurve welllogCurve; +// welllogCurve.SetDataID(wCurves[i].GetWelllogcurveId()); +// welllogCurve.SetDataBelongID(wCurves[i].GetWelllogroundId()); +// welllogCurve.SetName(wCurves[i].GetCurveName()); +// welllogCurve.SetCurveAlias(wCurves[i].GetCurveAlias()); +// welllogCurve.SetUnit(wCurves[i].GetUnit()); +// welllogCurve.SetUnitAlias(wCurves[i].GetUnitAlias()); +// welllogCurve.SetFamilyType(wCurves[i].GetFamilytype()); +// welllogCurve.SetDepUnit(wCurves[i].GetDepUnit()); +// welllogCurve.SetSampleInterval(wCurves[i].GetSpInterval()); +// welllogCurve.SetDim2Name(wCurves[i].GetDim2Name()); +// welllogCurve.SetDim2Unit(wCurves[i].GetDim2Unit()); +// welllogCurve.SetDim2Start(wCurves[i].GetDim2S()); +// welllogCurve.SetDim2Increment(wCurves[i].GetDim2Increment()); +// welllogCurve.SetDim2Max(wCurves[i].GetDim2Max()); +// welllogCurve.SetDim2PointNum(wCurves[i].GetDim2Pnum()); +// welllogCurve.SetRemark(wCurves[i].GetRemark()); + +// pai::orm::Blob blob; +// blob = wCurves[i].GetCurveData(); +// char *buffer = blob.GetData(); +// size_t depLeng; +// memcpy(&depLeng,buffer,sizeof(size_t)); +// if(depLeng >0) +// { +// std::vector tmpDimDepData; +// tmpDimDepData.resize(depLeng); +// memcpy(&(tmpDimDepData[0]), buffer+sizeof(size_t), depLeng*sizeof(float)); +// welllogCurve.SetDimDepData(tmpDimDepData); +// } + +// size_t tmpSize = sizeof(size_t) + welllogCurve.GetDimDepData().size()*sizeof(float); //m_DimDepData占用的buffer长度 +// size_t dimDataLeng; +// memcpy(&dimDataLeng, buffer+tmpSize, sizeof(size_t)); +// if(dimDataLeng >0) +// { +// std::vector tmpDimData; +// tmpDimData.resize(dimDataLeng); +// memcpy(&(tmpDimData[0]), buffer+tmpSize+sizeof(size_t), dimDataLeng*sizeof(float)); +// welllogCurve.SetDimData(tmpDimData); +// } + +// tmpSize += sizeof(size_t) + welllogCurve.GetDimData().size()*sizeof(float); //m_DimInfo占用的buffer长度 +// size_t dimInfoLeng; +// memcpy(&dimInfoLeng, buffer+tmpSize, sizeof(size_t)); +// if(dimInfoLeng >0) +// { +// std::vector tmpDimInfo; +// tmpDimInfo.resize(dimInfoLeng); +// memcpy(&(tmpDimInfo[0]), buffer+tmpSize+sizeof(size_t), dimInfoLeng*sizeof(float)); +// welllogCurve.SetDimInfo(tmpDimInfo); +// } +// infos.push_back(welllogCurve); +// } +// } + +// void WelllogRound::SaveWelllogCurve(std::vector& welllogcurves) +// { +// std::vector ormwelllogcurves; +// pai::orm::Welllogcurve ormwelllogcurve; +// for(size_t i = 0; i < welllogcurves.size(); ++i) +// { +// ormwelllogcurve.SetWelllogroundId(welllogcurves[i].GetDataBelongID()); +// ormwelllogcurve.SetCurveName(welllogcurves[i].GetName()); +// ormwelllogcurve.SetCurveAlias(welllogcurves[i].GetCurveAlias()); +// ormwelllogcurve.SetUnit(welllogcurves[i].GetUnit()); +// ormwelllogcurve.SetUnitAlias(welllogcurves[i].GetUnitAlias()); +// ormwelllogcurve.SetFamilytype(welllogcurves[i].GetFamilyType()); +// ormwelllogcurve.SetDepUnit(welllogcurves[i].GetDepUnit()); +// ormwelllogcurve.SetSpInterval(welllogcurves[i].GetSampleInterval()); +// ormwelllogcurve.SetDim2Name(welllogcurves[i].GetDim2Name()); +// ormwelllogcurve.SetDim2Unit(welllogcurves[i].GetDim2Unit()); +// ormwelllogcurve.SetDim2S(welllogcurves[i].GetDim2Start()); +// ormwelllogcurve.SetDim2Increment(welllogcurves[i].GetDim2Increment()); +// ormwelllogcurve.SetDim2Max(welllogcurves[i].GetDim2Max()); +// ormwelllogcurve.SetDim2Pnum(welllogcurves[i].GetDim2PointNum()); +// ormwelllogcurve.SetRemark(welllogcurves[i].GetRemark()); + +// int bufferLength = sizeof(size_t) + welllogcurves[i].GetDimDepData().size()*sizeof(float) +// + sizeof(size_t) + welllogcurves[i].GetDimData().size()*sizeof(float) +// + sizeof(size_t) + welllogcurves[i].GetDimInfo().size()*sizeof(int); +// char *buffer = new char[bufferLength]; + +// size_t size1 = welllogcurves[i].GetDimDepData().size(); +// memcpy(buffer, &size1, sizeof(size_t)); +// if(size1 >0) +// { +// memcpy(buffer+sizeof(size_t), reinterpret_cast(&(welllogcurves[i].GetDimDepData()[0])), welllogcurves[i].GetDimDepData().size()*sizeof(float)); +// } + +// size_t size2 = welllogcurves[i].GetDimData().size(); +// size_t tmpSize = sizeof(size_t) + welllogcurves[i].GetDimDepData().size()*sizeof(float); //m_DimDepData已占用的buffer长度 +// memcpy(buffer+tmpSize, &size2, sizeof(size_t)); +// if(size2 >0) +// { +// memcpy(buffer+tmpSize+sizeof(size_t), reinterpret_cast(&(welllogcurves[i].GetDimData()[0])), welllogcurves[i].GetDimData().size()*sizeof(float)); +// } + +// size_t size3 = welllogcurves[i].GetDimInfo().size(); +// size_t tmpSize2 = sizeof(size_t) + welllogcurves[i].GetDimDepData().size()*sizeof(float) + sizeof(size_t) + welllogcurves[i].GetDimData().size()*sizeof(float); //m_DimDepData+m_DimData已占用的buffer长度 +// memcpy(buffer+tmpSize2, &size3, sizeof(size_t)); +// if(size3 >0) +// { +// memcpy(buffer+tmpSize2+sizeof(size_t), reinterpret_cast(&(welllogcurves[i].GetDimInfo()[0])), welllogcurves[i].GetDimInfo().size()*sizeof(float)); +// } + +// pai::orm::Blob blob; +// blob.FromBuffer(buffer, bufferLength); +// if(buffer !=NULL) +// { +// delete[] buffer; +// buffer = NULL; +// } +// ormwelllogcurve.SetCurveData(blob); + +// ormwelllogcurves.push_back(ormwelllogcurve); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormwelllogcurves); +// } + +// void WelllogRound::GetTableDataName(std::vector& infos) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); + +// std::string tdtName; +// tdtName = TableData::GetDBTableName(this->GetDataID()); +// TableDataName tableDataName; +// tableDataName.SetTableDataTableName(tdtName); + +// std::stringstream sql; +// sql << "select distinct FILE_ID,FILE_NAME from \"" << tdtName << "\" where WELLLOGROUND_ID = " << this->GetDataID() << " order by FILE_ID"; +// pai::orm::sqlite::WelllogResultSet wrSet; +// try{ +// pdb.SetSQL(sql.str()); +// pdb.ExecuteQuery(wrSet); +// while(wrSet.HasNext()) +// { +// long long tabId = wrSet.GetLongLong(0); +// std::string dataname = wrSet.GetString(1); + +// tableDataName.SetTableID(tabId); +// tableDataName.SetTableName(dataname); + +// infos.push_back(tableDataName); +// } +// } +// catch(pai::error::db_error& e) +// { +// std::stringstream ss; +// ss << PAI_CURRENT_FUNCTION << ": Can't get table data name."; +// throw pai::error::db_error(ss.str(), ERR_NO_RESULT); +// } +// } + +// void WelllogRound::GetCoreimg(std::vector& coreimgs) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormcoreimgs; +// pdb.Load(pai::orm::Coreimg::Wellloground_id == this->GetDataID(), ormcoreimgs, true); +// for(size_t i = 0; i < ormcoreimgs.size(); i++) +// { +// Coreimg coreimg; +// coreimg.SetDataID(ormcoreimgs[i].GetCoreimgId()); +// coreimg.SetWellId(ormcoreimgs[i].GetWellId()); +// coreimg.SetDataBelongID(ormcoreimgs[i].GetWelllogroundId()); +// coreimg.SetNo(ormcoreimgs[i].GetNo()); +// coreimg.SetSdep(ormcoreimgs[i].GetSdep()); +// coreimg.SetEdep(ormcoreimgs[i].GetEdep()); +// coreimg.SetImgfullname(ormcoreimgs[i].GetImgfullname()); + +// coreimgs.push_back(coreimg); +// } +// } + +// void WelllogRound::SaveCoreimg(std::vector& coreimgs) +// { +// std::vector ormcoreimgs; +// pai::orm::Coreimg ormcoreimg; +// for(size_t i = 0; i < coreimgs.size(); ++i) +// { +// ormcoreimg.SetWelllogroundId(coreimgs[i].GetDataBelongID()); +// ormcoreimg.SetWellId(coreimgs[i].GetWellId()); +// ormcoreimg.SetNo(coreimgs[i].GetNo()); +// ormcoreimg.SetSdep(coreimgs[i].GetSdep()); +// ormcoreimg.SetEdep(coreimgs[i].GetEdep()); +// ormcoreimg.SetImgfullname(coreimgs[i].GetImgfullname()); + +// ormcoreimgs.push_back(ormcoreimg); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormcoreimgs); +// } + +// void WelllogRound::GetCorePhysics(std::vector& corephysicss) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormcorephysicss; +// pdb.Load(pai::orm::CorePhysics::Wellloground_id == this->GetDataID(), ormcorephysicss, true); +// for(size_t i = 0; i < ormcorephysicss.size(); i++) +// { +// CorePhysics corephysics; +// corephysics.SetDataID(ormcorephysicss[i].GetCorePhysicsId()); +// corephysics.SetDataBelongID(ormcorephysicss[i].GetWelllogroundId()); +// corephysics.SetWellId(ormcorephysicss[i].GetWellId()); +// corephysics.SetNo(ormcorephysicss[i].GetNo()); +// corephysics.SetDepth(ormcorephysicss[i].GetDepth()); +// corephysics.SetCorrDepth(ormcorephysicss[i].GetCorrdepth()); +// corephysics.SetDen(ormcorephysicss[i].GetDen()); +// corephysics.SetPor(ormcorephysicss[i].GetPor()); +// corephysics.SetPerm(ormcorephysicss[i].GetPerm()); +// corephysics.SetSw(ormcorephysicss[i].GetSw()); +// corephysics.SetVcal(ormcorephysicss[i].GetVcal()); +// corephysics.SetXmd(ormcorephysicss[i].GetXmd()); + +// corephysicss.push_back(corephysics); +// } +// } + +// void WelllogRound::SaveCorePhysics(std::vector& corephysicss) +// { +// std::vector ormcorephysicss; +// pai::orm::CorePhysics ormcorephysics; +// for(size_t i = 0; i < corephysicss.size(); ++i) +// { +// ormcorephysics.SetWelllogroundId(corephysicss[i].GetDataBelongID()); +// ormcorephysics.SetWellId(corephysicss[i].GetWellId()); +// ormcorephysics.SetNo(corephysicss[i].GetNo()); +// ormcorephysics.SetDepth(corephysicss[i].GetDepth()); +// ormcorephysics.SetCorrdepth(corephysicss[i].GetCorrDepth()); +// ormcorephysics.SetDen(corephysicss[i].GetDen()); +// ormcorephysics.SetPor(corephysicss[i].GetPor()); +// ormcorephysics.SetPerm(corephysicss[i].GetPerm()); +// ormcorephysics.SetSw(corephysicss[i].GetSw()); +// ormcorephysics.SetVcal(corephysicss[i].GetVcal()); +// ormcorephysics.SetXmd(corephysicss[i].GetXmd()); + +// ormcorephysicss.push_back(ormcorephysics); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormcorephysicss); +// } + +// void WelllogRound::GetDrillCore(std::vector& drillcores) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormdrillcores; +// pdb.Load(pai::orm::DrillCore::Wellloground_id == this->GetDataID(), ormdrillcores, true); +// for(size_t i = 0; i < ormdrillcores.size(); i++) +// { +// DrillCore drillcore; +// drillcore.SetDataID(ormdrillcores[i].GetDrillCoreId()); +// drillcore.SetDataBelongID(ormdrillcores[i].GetWelllogroundId()); +// drillcore.SetWellId(ormdrillcores[i].GetWellId()); +// drillcore.SetNum(ormdrillcores[i].GetNo()); +// drillcore.SetSdep(ormdrillcores[i].GetSdep()); +// drillcore.SetEdep(ormdrillcores[i].GetEdep()); +// drillcore.SetFootage(ormdrillcores[i].GetFootage()); +// drillcore.SetCoreLen(ormdrillcores[i].GetCoreLen()); +// drillcore.SetOilLen(ormdrillcores[i].GetOilLen()); +// drillcore.SetDescribe(ormdrillcores[i].GetDescribe()); + +// drillcores.push_back(drillcore); +// } +// } + +// void WelllogRound::SaveDrillCore(std::vector& drillcores) +// { +// std::vector ormdrillcores; +// pai::orm::DrillCore ormdrillcore; +// for(size_t i = 0; i < drillcores.size(); ++i) +// { +// ormdrillcore.SetWelllogroundId(drillcores[i].GetDataBelongID()); +// ormdrillcore.SetWellId(drillcores[i].GetWellId()); +// ormdrillcore.SetNo(drillcores[i].GetNum()); +// ormdrillcore.SetSdep(drillcores[i].GetSdep()); +// ormdrillcore.SetEdep(drillcores[i].GetEdep()); +// ormdrillcore.SetFootage(drillcores[i].GetFootage()); +// ormdrillcore.SetCoreLen(drillcores[i].GetCoreLen()); +// ormdrillcore.SetOilLen(drillcores[i].GetOilLen()); +// ormdrillcore.SetDescribe(drillcores[i].GetDescribe()); + +// ormdrillcores.push_back(ormdrillcore); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormdrillcores); +// } + +// void WelllogRound::GetGujing1Result(std::vector& gujing1results) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormgujing1results; +// pdb.Load(pai::orm::Gujing1Result::Wellloground_id == this->GetDataID(), ormgujing1results, true); +// for(size_t i = 0; i < ormgujing1results.size(); i++) +// { +// Gujing1Result ormgujing1result; +// ormgujing1result.SetDataID(ormgujing1results[i].GetGujing1ResultId()); +// ormgujing1result.SetDataBelongID(ormgujing1results[i].GetWelllogroundId()); +// ormgujing1result.SetWellId(ormgujing1results[i].GetWellId()); +// ormgujing1result.SetNo(ormgujing1results[i].GetNo()); +// ormgujing1result.SetSdep(ormgujing1results[i].GetSdep()); +// ormgujing1result.SetEdep(ormgujing1results[i].GetEdep()); +// ormgujing1result.SetResult(ormgujing1results[i].GetResult()); + +// gujing1results.push_back(ormgujing1result); +// } +// } + +// void WelllogRound::SaveGujing1Result(std::vector& gujing1results) +// { +// std::vector ormgujing1results; +// pai::orm::Gujing1Result ormgujing1result; +// for(size_t i = 0; i < gujing1results.size(); ++i) +// { +// ormgujing1result.SetWelllogroundId(gujing1results[i].GetDataBelongID()); +// ormgujing1result.SetWellId(gujing1results[i].GetWellId()); +// ormgujing1result.SetNo(gujing1results[i].GetNo()); +// ormgujing1result.SetSdep(gujing1results[i].GetSdep()); +// ormgujing1result.SetEdep(gujing1results[i].GetEdep()); +// ormgujing1result.SetResult(gujing1results[i].GetResult()); + +// ormgujing1results.push_back(ormgujing1result); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormgujing1results); +// } + +// void WelllogRound::GetSwallCore(std::vector& swallcores) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormswallcores; +// pdb.Load(pai::orm::SwallCore::Wellloground_id == this->GetDataID(), ormswallcores, true); +// for(size_t i = 0; i < ormswallcores.size(); i++) +// { +// SwallCore swallcore; +// swallcore.SetDataID(ormswallcores[i].GetSwallCoreId()); +// swallcore.SetDataBelongID(ormswallcores[i].GetWelllogroundId()); +// swallcore.SetWellId(ormswallcores[i].GetWellId()); +// swallcore.SetNo(ormswallcores[i].GetNo()); +// swallcore.SetDepth(ormswallcores[i].GetDepth()); +// swallcore.SetOil(ormswallcores[i].GetOil()); +// swallcore.SetLith(ormswallcores[i].GetLith()); +// swallcore.SetColor(ormswallcores[i].GetColor()); + +// swallcores.push_back(swallcore); +// } +// } + +// void WelllogRound::SaveSwallCore(std::vector& swallcores) +// { +// std::vector ormswallcores; +// pai::orm::SwallCore ormswallcore; +// for(size_t i = 0; i < swallcores.size(); ++i) +// { +// ormswallcore.SetWelllogroundId(swallcores[i].GetDataBelongID()); +// ormswallcore.SetWellId(swallcores[i].GetWellId()); +// ormswallcore.SetNo(swallcores[i].GetNo()); +// ormswallcore.SetDepth(swallcores[i].GetDepth()); +// ormswallcore.SetOil(swallcores[i].GetOil()); +// ormswallcore.SetLith(swallcores[i].GetLith()); +// ormswallcore.SetColor(swallcores[i].GetColor()); + +// ormswallcores.push_back(ormswallcore); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormswallcores); +// } + +// void WelllogRound::GetOgResult(std::vector& ogresults) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormogresults; +// pdb.Load(pai::orm::OgResult::Wellloground_id == this->GetDataID(), ormogresults, true); +// for(size_t i = 0; i < ormogresults.size(); i++) +// { +// OgResult ogresult; +// ogresult.SetDataID(ormogresults[i].GetOgResultId()); +// ogresult.SetDataBelongID(ormogresults[i].GetWelllogroundId()); +// ogresult.SetWellId(ormogresults[i].GetWellId()); +// ogresult.SetNo(ormogresults[i].GetNo()); +// ogresult.SetSdep(ormogresults[i].GetSdep()); +// ogresult.SetEdep(ormogresults[i].GetEdep()); +// ogresult.SetResultNo(ormogresults[i].GetResultno()); +// ogresult.SetResult(ormogresults[i].GetResult()); +// ogresult.SetThick(ormogresults[i].GetThick()); +// ogresult.SetTt(ormogresults[i].GetTt()); + +// ogresults.push_back(ogresult); +// } +// } + +// void WelllogRound::SaveOgResult(std::vector& ogresults) +// { +// std::vector ormogresults; +// pai::orm::OgResult ormogresult; +// for(size_t i = 0; i < ogresults.size(); ++i) +// { +// ormogresult.SetWelllogroundId(ogresults[i].GetDataBelongID()); +// ormogresult.SetWellId(ogresults[i].GetWellId()); +// ormogresult.SetNo(ogresults[i].GetNo()); +// ormogresult.SetSdep(ogresults[i].GetSdep()); +// ormogresult.SetEdep(ogresults[i].GetEdep()); +// ormogresult.SetResultno(ogresults[i].GetResultNo()); +// ormogresult.SetResult(ogresults[i].GetResult()); +// ormogresult.SetThick(ogresults[i].GetThick()); +// ormogresult.SetTt(ogresults[i].GetTt()); + +// ormogresults.push_back(ormogresult); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormogresults); +// } + +// void WelllogRound::GetCoreDesc(std::vector& coredescs) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormcoredescs; +// pdb.Load(pai::orm::CoreDesc::Wellloground_id == this->GetDataID(), ormcoredescs, true); +// for(size_t i = 0; i < ormcoredescs.size(); i++) +// { +// CoreDesc coredesc; +// coredesc.SetDataID(ormcoredescs[i].GetCoreDescId()); +// coredesc.SetWellId(ormcoredescs[i].GetWellId()); +// coredesc.SetDataBelongID(ormcoredescs[i].GetWelllogroundId()); +// coredesc.SetSdep(ormcoredescs[i].GetSdep()); +// coredesc.SetEdep(ormcoredescs[i].GetEdep()); +// coredesc.SetDesc(ormcoredescs[i].GetDesc()); + +// coredescs.push_back(coredesc); +// } +// } + +// void WelllogRound::SaveCoreDesc(std::vector& coredescs) +// { +// std::vector ormcoredescs; +// pai::orm::CoreDesc ormcoredesc; +// for(size_t i = 0; i < coredescs.size(); ++i) +// { +// ormcoredesc.SetWelllogroundId(coredescs[i].GetDataBelongID()); +// ormcoredesc.SetWellId(coredescs[i].GetWellId()); +// ormcoredesc.SetSdep(coredescs[i].GetSdep()); +// ormcoredesc.SetEdep(coredescs[i].GetEdep()); +// ormcoredesc.SetDesc(coredescs[i].GetDesc()); + +// ormcoredescs.push_back(ormcoredesc); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormcoredescs); +// } + +// void WelllogRound::GetGeostratum(std::vector& geostratums) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormgeostratums; +// pdb.Load(pai::orm::Geostratum::Wellloground_id == this->GetDataID(), ormgeostratums, true); +// for(size_t i = 0; i < ormgeostratums.size(); i++) +// { +// Geostratum geostratum; +// geostratum.SetDataID(ormgeostratums[i].GetGeostratumId()); +// geostratum.SetWellId(ormgeostratums[i].GetWellId()); +// geostratum.SetDataBelongID(ormgeostratums[i].GetWelllogroundId()); +// geostratum.SetName(ormgeostratums[i].GetName()); +// geostratum.SetType(ormgeostratums[i].GetType()); +// geostratum.SetSdep(ormgeostratums[i].GetSdep()); +// geostratum.SetEdep(ormgeostratums[i].GetEdep()); +// geostratum.SetLith(ormgeostratums[i].GetLith()); + +// geostratums.push_back(geostratum); +// } +// } + +// void WelllogRound::SaveGeostratum(std::vector& geostratums) +// { +// std::vector ormgeostratums; +// pai::orm::Geostratum ormgeostratum; +// for(size_t i = 0; i < geostratums.size(); ++i) +// { +// ormgeostratum.SetWellId(geostratums[i].GetWellId()); +// ormgeostratum.SetWelllogroundId(geostratums[i].GetDataBelongID()); +// ormgeostratum.SetName(geostratums[i].GetName()); +// ormgeostratum.SetType(geostratums[i].GetType()); +// ormgeostratum.SetSdep(geostratums[i].GetSdep()); +// ormgeostratum.SetEdep(geostratums[i].GetEdep()); +// ormgeostratum.SetLith(geostratums[i].GetLith()); + +// ormgeostratums.push_back(ormgeostratum); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormgeostratums); +// } + +// void WelllogRound::GetOgResult2(std::vector& ogresult2s) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormogresult2s; +// pdb.Load(pai::orm::OgResult2::Wellloground_id == this->GetDataID(), ormogresult2s, true); +// for(size_t i = 0; i < ormogresult2s.size(); i++) +// { +// OgResult2 ogresult2; +// ogresult2.SetDataID(ormogresult2s[i].GetOgResult2Id()); +// ogresult2.SetDataBelongID(ormogresult2s[i].GetWelllogroundId()); +// ogresult2.SetWellId(ormogresult2s[i].GetWellId()); +// ogresult2.SetNo(ormogresult2s[i].GetNo()); +// ogresult2.SetSdep(ormogresult2s[i].GetSdep()); +// ogresult2.SetEdep(ormogresult2s[i].GetEdep()); +// ogresult2.SetResultno(ormogresult2s[i].GetResultno()); +// ogresult2.SetResult(ormogresult2s[i].GetResult()); +// ogresult2.SetThick(ormogresult2s[i].GetThick()); +// ogresult2.SetTt(ormogresult2s[i].GetTt()); + +// ogresult2s.push_back(ogresult2); +// } +// } + +// void WelllogRound::SaveOgResult2(std::vector& ogresult2s) +// { +// std::vector ormogresult2s; +// pai::orm::OgResult2 ormogresult2; +// for(size_t i = 0; i < ogresult2s.size(); ++i) +// { +// ormogresult2.SetWelllogroundId(ogresult2s[i].GetDataBelongID()); +// ormogresult2.SetWellId(ogresult2s[i].GetWellId()); +// ormogresult2.SetNo(ogresult2s[i].GetNo()); +// ormogresult2.SetSdep(ogresult2s[i].GetSdep()); +// ormogresult2.SetEdep(ogresult2s[i].GetEdep()); +// ormogresult2.SetResultno(ogresult2s[i].GetResultno()); +// ormogresult2.SetResult(ogresult2s[i].GetResult()); +// ormogresult2.SetThick(ogresult2s[i].GetThick()); +// ormogresult2.SetTt(ogresult2s[i].GetTt()); + +// ormogresult2s.push_back(ormogresult2); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormogresult2s); +// } + +// void WelllogRound::GetWavefile(std::vector& wavefiles) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormwavefiles; +// pdb.Load(pai::orm::Wavefile::Wellloground_id == this->GetDataID(), ormwavefiles, true); +// for(size_t i = 0; i < ormwavefiles.size(); i++) +// { +// Wavefile wavefile; +// wavefile.SetDataID(ormwavefiles[i].GetWavefileId()); +// wavefile.SetWellId(ormwavefiles[i].GetWellId()); +// wavefile.SetDataBelongID(ormwavefiles[i].GetWelllogroundId()); +// wavefile.SetPath(ormwavefiles[i].GetPath()); +// wavefile.SetFilename(ormwavefiles[i].GetFilename()); +// wavefile.SetRemark(ormwavefiles[i].GetRemark()); + +// wavefiles.push_back(wavefile); +// } +// } + +// void WelllogRound::SaveWavefile(std::vector& wavefiles) +// { +// std::vector ormwavefiles; +// pai::orm::Wavefile ormwavefile; +// for(size_t i = 0; i < wavefiles.size(); ++i) +// { +// ormwavefile.SetWellId(wavefiles[i].GetWellId()); +// ormwavefile.SetWelllogroundId(wavefiles[i].GetDataBelongID()); +// ormwavefile.SetPath(wavefiles[i].GetPath()); +// ormwavefile.SetFilename(wavefiles[i].GetFilename()); +// ormwavefile.SetRemark(wavefiles[i].GetRemark()); + +// ormwavefiles.push_back(ormwavefile); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormwavefiles); +// } + +// void WelllogRound::GetZone(std::vector& zones) +// { +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// std::vector ormzones; +// pdb.Load(pai::orm::Zone::Wellloground_id == this->GetDataID(), ormzones, true); +// for(size_t i = 0; i < ormzones.size(); i++) +// { +// Zone zone; +// zone.SetDataID(ormzones[i].GetZoneId()); +// zone.SetWellId(ormzones[i].GetWellId()); +// zone.SetDataBelongID(ormzones[i].GetWelllogroundId()); +// zone.SetName(ormzones[i].GetName()); +// zone.SetSdep(ormzones[i].GetSdep()); +// zone.SetEdep(ormzones[i].GetEdep()); + +// zones.push_back(zone); +// } +// } + +// void WelllogRound::SaveZone(std::vector& zones) +// { +// std::vector ormzones; +// pai::orm::Zone ormzone; +// for(size_t i = 0; i < zones.size(); ++i) +// { +// ormzone.SetWelllogroundId(zones[i].GetDataBelongID()); +// ormzone.SetWellId(zones[i].GetWellId()); +// ormzone.SetName(zones[i].GetName()); +// ormzone.SetSdep(zones[i].GetSdep()); +// ormzone.SetEdep(zones[i].GetEdep()); + +// ormzones.push_back(ormzone); +// } +// pai::orm::sqlite::Persistence &pdb = pai::orm::sqlite::Persistence::Get(); +// pdb.Persist(ormzones); +// } + +} +} +} diff --git a/Slfio/src/slf.cpp b/Slfio/src/slf.cpp index 8f910ca..3ef7ade 100644 --- a/Slfio/src/slf.cpp +++ b/Slfio/src/slf.cpp @@ -6,6 +6,8 @@ #include "slf.h" #include #include +#include +#pragma execution_character_set("utf-8") int RepSize[12]={4, sizeof(int), sizeof(short), @@ -3369,7 +3371,9 @@ int CSlfIO::FindSlfObjectIndex(const char* namee,int status) char name[128]; strcpy(name,namee); for(int i=0;itreeWidget); initSlfNameTreeMenu(_menuSlfName, ui->treeWidget); + _menuTableFolder = new QMenu(ui->treeWidget); + initTableFolderTreeMenu(_menuTableFolder, ui->treeWidget); + // //评估方案-右键菜单 // _menuEvaluate = new QMenu(ui->treeWidget); // initEvaluateTreeMenu(_menuEvaluate, ui->treeWidget); @@ -677,6 +680,15 @@ void QtProjectWidgets::initSlfNameTreeMenu(QMenu *menu, QTreeWidget *treeWidget) menu->addAction(action_New); } +//初始化根节点(表目录)-右键菜单 +void QtProjectWidgets::initTableFolderTreeMenu(QMenu *menu, QTreeWidget *treeWidget) +{ + QAction* action_New = new QAction("创建新表", treeWidget); + action_New->setIcon(QIcon(":/image/u174.png")); // 设置图标 + connect(action_New, SIGNAL(triggered(bool)), this, SLOT(onCreateNewTable())); + menu->addAction(action_New); +} + //新建项目 void QtProjectWidgets::onNewProject(bool checked) { @@ -741,6 +753,65 @@ void QtProjectWidgets::onShowTable(bool checked) void QtProjectWidgets::onWelllogInformation() { emit CallManage::getInstance()->sig_WelllogInformation(m_strSlfName, m_strCurveObjectName); + foreach(QTreeWidgetItem *pItem, ui->treeWidget->selectedItems()) + { + QTreeWidgetItem *parentItem = pItem; + if (parentItem && m_strSlfName == parentItem->data(0, Qt::UserRole+1).toString()) + { + // qDeleteAll(parentItem->takeChildren()); + QTreeWidgetItem *pWellItem = parentItem->parent(); + QString Wellname = parentItem->text(0); + // parentItem->setExpanded(false); + loadWellTree(parentItem->parent(), m_strSlfName, Wellname); + pWellItem->removeChild(parentItem); + pWellItem->setExpanded(true); + + int WellCount = pWellItem->childCount(); + for (int i = 0; i < WellCount; ++i) + { + QTreeWidgetItem *childItem = pWellItem->child(i); + childItem->setExpanded(true); + int childCount = childItem->childCount(); + for (int j = 0; j < childCount; ++j) + { + childItem->child(j)->setExpanded(true); + } + } + } + } +} + +//创建新表 +void QtProjectWidgets::onCreateNewTable() +{ + CDataManagger DataManagger; + DataManagger.CreateNewTable(m_strSlfName); + foreach(QTreeWidgetItem *pItem, ui->treeWidget->selectedItems()) + { + QTreeWidgetItem *parentItem = pItem->parent(); + if (parentItem && m_strSlfName == parentItem->data(0, Qt::UserRole+1).toString()) + { + // qDeleteAll(parentItem->takeChildren()); + QTreeWidgetItem *pWellItem = parentItem->parent(); + QString Wellname = parentItem->text(0); + // parentItem->setExpanded(false); + loadWellTree(parentItem->parent(), m_strSlfName, Wellname); + pWellItem->removeChild(parentItem); + pWellItem->setExpanded(true); + + int WellCount = pWellItem->childCount(); + for (int i = 0; i < WellCount; ++i) + { + QTreeWidgetItem *childItem = pWellItem->child(i); + childItem->setExpanded(true); + int childCount = childItem->childCount(); + for (int j = 0; j < childCount; ++j) + { + childItem->child(j)->setExpanded(true); + } + } + } + } } void QtProjectWidgets::onEditWelllogRound() @@ -889,6 +960,12 @@ void QtProjectWidgets::onItemClicked(QTreeWidgetItem* item, int index) popMenu = _menuSlfName; m_strSlfName = item->data(0, Qt::UserRole+1).toString(); } + else if (strTreeTag == "Sheet") + { + //根节点(项目名称)-右键菜单 + popMenu = _menuTableFolder; + m_strSlfName = item->parent()->data(0, Qt::UserRole+1).toString(); + } // if (qApp->mouseButtons() == Qt::RightButton) // 只针对鼠标右键，弹出菜单 diff --git a/logPlus/qtprojectwidgets.h b/logPlus/qtprojectwidgets.h index 1049a94..656ad3a 100644 --- a/logPlus/qtprojectwidgets.h +++ b/logPlus/qtprojectwidgets.h @@ -45,6 +45,7 @@ public slots: void onImportSlfTable(); void onOutWellLogRound(); void onWelllogInformation(); //编辑测井信息 + void onCreateNewTable(); //创建新表 public: //初始化树图控件 void initTreeWidget(QString fullPath, QString strProjectName); @@ -52,10 +53,11 @@ public: public: //右键菜单 QMenu *_menuRoot; - QMenu *_menuCurveObject;//曲线对象(AC、BS...) - QMenu *_menuTableObject;//表格对象 - QMenu *_menuWellName; //井名 - QMenu *_menuSlfName; //井次 + QMenu *_menuCurveObject; //曲线对象(AC、BS...) + QMenu *_menuTableObject; //表格对象 + QMenu *_menuWellName; //井名 + QMenu *_menuSlfName; //井次 + QMenu *_menuTableFolder; //表目录 //根节点(项目名称)-右键菜单 QAction* m_action_New; @@ -86,6 +88,8 @@ public: void initWellNameTreeMenu(QMenu *menu, QTreeWidget *treeWidget); //初始化根节点(井次名称)-右键菜单 void initSlfNameTreeMenu(QMenu *menu, QTreeWidget *treeWidget); + //初始化根节点(表目录)-右键菜单 + void initTableFolderTreeMenu(QMenu *menu, QTreeWidget *treeWidget); private: };