diff --git a/CallManage/CallManage.h b/CallManage/CallManage.h index 443d342..3311aac 100644 --- a/CallManage/CallManage.h +++ b/CallManage/CallManage.h @@ -6,6 +6,7 @@ #include #include #include +#include //#include "qmycustomplot.h" class Q_DECL_EXPORT CallManage : public QObject @@ -37,6 +38,7 @@ signals: void sig_CloseProject();//关闭项目 void sig_ShowCurve(QString strSlfName, QString strName);//曲线数据查看 + void sig_ShowTable(QString strSlfName, QString strName);//表格数据查看 void sig_NewTrack(QString strUuid, QString strWellName, QString strSlfName, QString strLineName);//新建道 void sig_NewTrack_No_Line(QString strUuid, QString strWellName, QString strTrackName);//新建空白道，没有曲线 diff --git a/OSGDataModel/include/BaseObject.h b/OSGDataModel/include/BaseObject.h new file mode 100644 index 0000000..e440a1a --- /dev/null +++ b/OSGDataModel/include/BaseObject.h @@ -0,0 +1,430 @@ +/** +* @file BaseObject.h +* @brief 成图框架依赖的数据层的最小化接口定义 +* @date 2014-5-29 +* @author: liyonggang +*/ +#ifndef PAI_FRAME_OSGOBJECT_H +#define PAI_FRAME_OSGOBJECT_H +#pragma warning( push ,0) +#include +#include +#include "ObjectGenralFactory.h" +// #include "ObjectArchive.h" +// #include "PaiObject.h" +#include "DataObject.h" +// using namespace pai::objectmodel; + +#pragma warning( pop ) + +BEGIN_OSGDATAMODEL_NAMESPACE; + +/** +* @class sObjectClassIDKey +* @brief 唯一标识Object class ID +*/ +struct OSGDATAMODEL_EXPORT sObjectClassIDKey +{ +public: + sObjectClassIDKey(); + + sObjectClassIDKey( QUuid ObjectClassID ); + + bool operator !=( const sObjectClassIDKey& s ); + + bool operator< ( const sObjectClassIDKey& s ) const; + +public: + QUuid m_ObjectClassID; +}; + +/** +* @class 成图框架依赖的数据层的基类接口 +*/ +class OSGDATAMODEL_EXPORT CBaseObject +{ +public: + CBaseObject() + { + // m_pPaiObject = NULL; + ghostName=""; + // m_TemplateKey=QVariant(); + }; + + virtual ~CBaseObject() {}; + + + /** + * @brief 得到DB Object + */ + virtual pai::ios::welllog::DataObject *GetDbObject() { return NULL;}; + virtual CBaseObject * GetVecWindowDocument(){return NULL;}; + + + static CObjectGenralFactory< sObjectClassIDKey,CBaseObject >& GetFatory(); + + /** + * @brief 设置Object在数据树上的check状态 + */ + void SetCheckState( Qt::CheckState state ) + { + m_eCheckState = state; + // PaiObject::m_EventAgent.ObjectPropertyChanged( dynamic_cast(this),"checkstate",state); + } + Qt::CheckState GetCheckState() + { + return m_eCheckState ; + } + + /** + * @brief 序列化此对象 + */ + // virtual bool Serialize( CObjectArchive &ar ) = 0; + + virtual void Delete() = 0; + + /** + * @brief Add a child object in general way. + * @param pChild the child object handle + * @param mountNow 是否将其挂载到树上 + */ + // virtual bool AddChild(PaiObject* pChild, bool mountNow = true) =0; + + /** + * @brief 在iIndex之前插入一个孩子,插入后这个孩子指向了iIndex + * @param iIndex 插入的索引 + * @param pChild 待插入的孩子 + */ + // virtual bool InsertChild(int iIndex,PaiObject* pChild)=0; + + /** + * @brief Remove a child object in general way. + * @param pChild the child object handle + */ + // virtual bool RemoveChild(PaiObject* pChild, bool bDelete = false)=0; + + + /** + * @brief 删除所有的孩子 + */ + virtual void DeleteAllChild() = 0; + + // PaiObject *GetPaiObject() + // { + // if( !m_pPaiObject ) + // { + // m_pPaiObject = dynamic_cast( this ); + // } + // return m_pPaiObject; + // } + /** + * @brief 克隆，深拷贝 + */ + virtual CBaseObject *CloneObject(); + //为了满足一条曲线测井图中多处显示的需求而来 + //本质是复制一个对象并将其隐藏 + virtual CBaseObject *GhostObject(); + virtual void CopyFrom( CBaseObject *pOSGObjectOther ); + + /** + * @brief 判断子孙后代中是否有指定ID的孩子，包括自己 + * @param id 孩子id + */ + // virtual bool Contains(const QUuid& id); + /************************************************************************/ + /* @brief 得到该对象的模板关键字，例如井曲线对象的family名字 */ + /************************************************************************/ + // virtual void SetTemplateKey(QVariant TemplateKey); + // virtual QVariant GetTemplateKey(); + //一个对象多处显示时，需要有gohostname来区分和查找 + //规则ghostName=name+_+Ghost+timeStamp + virtual QString GetGhostName(){return ghostName; }; + virtual void SetGhostName(QString aGhostname){ + ghostName=aGhostname; + }; + //得到对数据对象的描述性信息，由各个子类实现 + virtual QString GetDescription(){return "";}; +protected: + Qt::CheckState m_eCheckState; + // PaiObject *m_pPaiObject; +private: + QString ghostName; + // QVariant m_TemplateKey; +}; + +#define DECLARE_COSGOBJECT_H \ +virtual void Delete();\ + virtual bool Serialize( CObjectArchive &ar );\ + virtual bool AddChild(PaiObject* pChild, bool mountNow = true);\ + virtual bool InsertChild(int iIndex,PaiObject* pChild);\ + virtual bool RemoveChild(PaiObject* pChild, bool bDelete = false);\ + virtual void DeleteAllChild();\ + +#define IMP_SERIALIZE_CPP( ClassName,BaseClassName)\ +bool ClassName::Serialize( CObjectArchive &ar )\ +{\ + pai::ios::welllog::DataObject* pDbObject = GetDbObject();\ + QFile *pFile = dynamic_cast( ar.GetDevice() );\ + bool bToDisk = pFile ? true :false;\ + if(ar.IsStoring())\ + {\ + BEGIN_WRITE_OBJECT( ar,1 );\ + BEGIN_WRITE_BLOCK( ar, 1);\ + if( bToDisk)\ + {\ + CPaiObjectHelper::SerializeDB( ar,pDbObject,this );\ + }\ + /*保存自己的信息*/ \ + ar << GetID();\ + ar << GetName();\ + /*save 所有的孩子*/\ + if( bToDisk)\ + {\ + QList lstChildren;\ + GetChildren(lstChildren);\ + int nChildCout = lstChildren.size();\ + ar << nChildCout;\ + for( long i = 0 ; i< nChildCout;++i )\ + {\ + CBaseObject* pChild = dynamic_cast( lstChildren[i] );\ + assert( pChild );\ + ar << lstChildren[i] ->GetTypeID().toString();\ + pChild->Serialize( ar );\ + }\ + }\ + END_WRITE_BLOCK( ar, 1 );\ + \ + END_WRITE_OBJECT( ar );\ + }\ + else\ + {\ + BEGIN_READ_OBJECT( ar,1 );\ + \ + BEGIN_READ_BLOCK( 1 ); \ + if( bToDisk)\ + {\ + \ + CPaiObjectHelper::SerializeDB( ar,pDbObject,this );\ + }\ + \ + /*加载自己的信息*/\ + QString strTmp;\ + ar >> strTmp; \ + SetID(strTmp );\ + QString strName;\ + ar >> strName;\ + SetName( strName);\ + if( bToDisk)\ + {\ + /*加载所有的孩子*/\ + DeleteAllChild();\ + int nChildCout(0);\ + ar >> nChildCout;\ + for( long i = 0 ; i< nChildCout;++i )\ + { \ + QApplication::processEvents();\ + ar >> strTmp;\ + QUuid classID = QUuid(strTmp);\ + CBaseObject *pChild = GetFatory().CreateObject( classID );\ + PaiObject *pPaiObject = dynamic_cast( pChild );\ + CBaseObjectImpl *pChildImp = dynamic_cast( pChild );\ + if( pChildImp )\ + {\ + pChildImp->Init( classID );\ + }\ + if( pChild )\ + {\ + pChild->Serialize( ar );\ + AddChild( pPaiObject );\ + }else\ + {\ + assert( false);\ + ar.SkipObject();\ + }\ + }\ + }\ + \ + END_READ_BLOCK( 1 );\ + \ + END_READ_OBJECT( ar );\ + }\ + return true;\ +}\ + +#define IMP_COSGOBJECT_CPP( ClassName,BaseClassName)\ +void ClassName::Delete()\ +{ \ + DeleteAllChild();\ + delete this;\ +}\ +\ +\ +bool ClassName::AddChild(PaiObject* pChild, bool mountNow )\ +{ \ + CObjProject::AddIDMap( pChild->GetID(),dynamic_cast( pChild) );\ + if(mountNow) return BaseClassName::AddChild( pChild,MountOnTree );\ + else return BaseClassName::AddChild( pChild,MountNoTree );\ +}\ + \ +bool ClassName::InsertChild(int iIndex,PaiObject* pChild)\ +{\ + CObjProject::AddIDMap( pChild->GetID(), dynamic_cast( pChild));\ + return BaseClassName::InsertChild( iIndex, pChild );\ +}\ +\ +bool ClassName::RemoveChild(PaiObject* pChild, bool bDelete )\ +{ \ + CObjProject::RemoveIDMap( dynamic_cast(pChild ) );\ + return BaseClassName::RemoveChild( pChild,bDelete );\ + \ +}\ +\ +void ClassName::DeleteAllChild()\ +{\ + QList::iterator it = m_children.begin();\ + while ( it != m_children.end() )\ + {\ + PaiObject* pChild = (*it);\ + CObjProject::RemoveIDMap( dynamic_cast( pChild ) );\ + pChild->Delete();\ + ++it;\ + }\ + m_children.clear();\ +}\ + + +// class OSGDATAMODEL_EXPORT CBaseObjectImpl : public CBaseObject +// { +// Q_OBJECT +// public: +// CBaseObjectImpl(); + +// virtual ~CBaseObjectImpl(); + +// virtual void Init(QUuid classID); + +// virtual QUuid GetTypeID() const; + +// /** +// * @brief 得到DB Object +// */ +// virtual pai::ios::welllog::DataObject *GetDbObject(); + +// virtual void Delete(); + +// /** +// * @brief 序列化此对象 +// */ +// // virtual bool Serialize( CObjectArchive &ar ); + + +// /** +// * @brief Add a child object in general way. +// * @param pChild the child object handle +// * @param mountNow 是否将其挂载到树上 +// */ +// // virtual bool AddChild(PaiObject* pChild, bool mountNow = true); + +// /** +// * @brief 在iIndex之前插入一个孩子,插入后这个孩子指向了iIndex +// * @param iIndex 插入的索引 +// * @param pChild 待插入的孩子 +// */ +// // virtual bool InsertChild(int iIndex,PaiObject* pChild); + +// void MoveChild(int From,int To); +// // int GetChildPos(PaiObject* pChild); + +// /** +// * @brief Remove a child object in general way. +// * @param pChild the child object handle +// */ +// // virtual bool RemoveChild(PaiObject* pChild, bool bDelete = false); + +// /** +// * @brief 把孩子移除出来，但不删除此对象 +// * @param pChild the child object handle +// */ +// // virtual bool TakeChild(PaiObject* pChild); + + +// /** +// * @brief 删除所有的孩子 +// */ +// virtual void DeleteAllChild(); + +// /** +// *@brief 查找是否存在指定的孩子 +// */ +// // virtual bool HasChildren(PaiObject* pChild); + +// /** +// *@brief 是否存在孩子 +// */ +// virtual bool isExistsName(QString name); + +// /** +// *@brief 是否可以在树上显示 +// */ +// void SetVisibleOnTree(bool visible); + +// protected: +// QUuid m_classTypeID; +// signals: +// /** +// *@brief 错误信息 +// */ +// void signalErrorInfo(QString); +// }; + +// class OSGDATAMODEL_EXPORT CPaiObjectHelper +// { +// public: +// /** +// * @brief 把DB Object 序列化到数据库 +// */ +// // static bool SerializeDB( CObjectArchive &ar,pai::ios::welllog::DataObject *pDbObject,pai::objectmodel::PaiObject *pPaiObject ); + + +// //递归得到所有的孩子(包括自己 ,自己在第一个) +// // static void RecursionGetAllChild( PaiObject* pThis,std::vector &vChild ); +// // static void RecursionGetAllChildren( PaiObject* pThis,std::vector &vChild ); + +// /** +// * @brief 得到唯一的不重复的孩子的name +// */ +// // static QString GetUniqueChildName( PaiObject *pPaiObject,QString strPreFixName ); + +// /** +// * @brief 得到根对象，一般是Project +// */ +// // static PaiObject *GetRoot(PaiObject *); + +// //得到所选择的当前item对应viewObject下的所有的子孙 +// static std::vector GetAllSymbolObject(CBaseObject * pOSGObject); + +// //得到某一棵子树 +// static CBaseObject * GetSubtree(CBaseObject* pThis,QString strRelativeFolderPath); + +// // static PaiObject * GetChildByName(PaiObject *pObject,QString name); + +// }; + + +//Object 插件机制和示例代码 +#define BEGIN_REGISTER_OBJECT(className) BEGIN_REGISTER(sObjectClassIDKey,CBaseObject,className) +#define END_REGISTER_OBJECT(className) END_REGISTER( sObjectClassIDKey,CBaseObject,className ) +//BEGIN_REGISTER_OBJECT(CObjWellLog) +//GetClassID_WellLog() +//END_REGISTER_OBJECT( CObjWellLog ) + +//Object 插件工厂 +typedef CObjectGenralFactory< sObjectClassIDKey,CBaseObject > COSGObjectFactory; + + + + +END_OSGDATAMODEL_NAMESPACE + + using namespace pai::datamodel; +#endif diff --git a/OSGDataModel/include/CStringType.h b/OSGDataModel/include/CStringType.h new file mode 100644 index 0000000..ab98f90 --- /dev/null +++ b/OSGDataModel/include/CStringType.h @@ -0,0 +1,167 @@ +/** +* @file CStringTyle.h +* @brief CString数据自定义、井以及井次结构体 +* @date 2014-10-10 +* @author: ZhouWenfei +*/ + +#ifndef PAI_FRAME_CSTRING_H__ +#define PAI_FRAME_CSTRING_H__ +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#pragma execution_character_set("utf-8") +#pragma warning( push ,0) +//#include "BaseFunExport.h" +#pragma warning( pop ) +//#ifdef MessageBox +//#define MessageBox MessageBox +//#endif +#define MAX_PATH 1024 +//#define _MAX_PATH 1024 +#define MaxCurve 1024 +#define curve_name_len 256 +#define curve_unit_len 256 +#define MIN_RANK rank_char +#define MAX_RANK rank_longlong + +#define INTMAX_RANK rank_longlong +#define SIZE_T_RANK rank_long +#define PTRDIFF_T_RANK rank_long +#define MB_OK QMessageBox::Ok +typedef unsigned short WORD; +#ifdef WIN32 +typedef unsigned long DWORD; +typedef DWORD *LPDWORD; +typedef void *HANDLE; +#else +typedef unsigned int DWORD; +typedef DWORD *LPDWORD; +typedef void *HANDLE; +#endif +typedef unsigned char BYTE; +typedef char* LPSTR; +typedef void* LPVOID; + +class CString; +typedef QList CStringList; + +using namespace std; + + + +//#define REPR_INT 1 +//#define REPR_SHORT 2 +//#define REPR_LONG 3 +//#define REPR_FLOAT 4 +//#define REPR_DOUBLE 5 +//#define REPR_STRING 6 +//#define REPR_CHAR 7 +//#define REPR_UCHAR 8 +//#define REPR_USHORT 9 +//#define REPR_UINT 10 +//#define REPR_ULONG 11 +//class BASEFUN_EXPORT CString; + +//构建CString +class CString +{ +public: + CString(const char *str = nullptr); + CString(const QString str); + CString(const CString &other); + ~CString(); + + int GetLength()const; + int Find(char *str); + int Find(char str); + int Find(CString &another); + int Find(char str[],int start); + int ReverseFind(char ch); + int Insert(int pos ,const CString Sctr); + int Replace(const char *Src,const char *Dest); + CString & TrimLeft(); + CString & MakeUpper(); + CString& MakeLower(); + CString & TrimRight(); + bool operator==(const char* other ); + bool operator!=(const char* other ); + bool operator==(const CString& other ); + bool operator!=(const CString& other ); + char operator[](int i); + CString Right(int count)const; + CString Left(int count)const; +// CString operator = (const QString& SrcStr) ; + CString operator + (const CString& SrcStr) ; + CString operator += (CString& SrcStr) ; + CString operator += (const CString& SrcStr) ; + char* GetString()const; + char GetChar(int n); + char GetAt(int n); + CString Mid(int pos,int count)const; + CString Mid(int pos)const; + void Format(const char *format,...); + void Delete(int fromIndex,int length); +// const char *m_temp; + void Alloc(int len); + void Empty(); +private: + QString m_data; +}; + + + + + +enum flags { +FL_SPLAT0 = 0x00,/* Drop the value, do not assign */ + +FL_SPLAT = 0x01,/* Drop the value, do not assign */ +FL_INV = 0x02,/* Character-set with inverse */ +FL_WIDTH = 0x04,/* Field width specified */ +FL_MINUS = 0x08,/* Negative number */ + +}; + +enum ranks { + +rank_char = -2, +rank_short = -1, +rank_int = 0, +rank_long = 1, +rank_longlong = 2, +rank_ptr = INT_MAX/* Special value used for pointers */ + +}; + + + +enum bail { + + bail_none = 0,/* No error condition */ + bail_eof,/* Hit EOF */ + bail_err/* Conversion mismatch */ + +}; +int AfxMessageBox(CString str); +int MessageBox(QWidget *parent,char lpText[128],char*lpCaption, int UINTuType); +void ShowMessage(QString mess); + +//构建AfxMessageBox()函数 +//extern int BASEFUN_EXPORT AfxMessageBox(CString str); +//extern int BASEFUN_EXPORT MessageBox(QWidget *parent,char lpText[128],char*lpCaption, int UINTuType); +// using namespace pai::graphics; +#endif + diff --git a/OSGDataModel/include/DataObject.h b/OSGDataModel/include/DataObject.h new file mode 100644 index 0000000..fbf8715 --- /dev/null +++ b/OSGDataModel/include/DataObject.h @@ -0,0 +1,197 @@ +/** + * @file DataObject.h + * @brief 测井对象基类 + */ + +#ifndef PAI_FRAME_IOSERVICE_DATAOBJECT_H +#define PAI_FRAME_IOSERVICE_DATAOBJECT_H + +#include +#include +// #include "Turtle.h" + +namespace pai { +namespace ios { +namespace welllog { + +/** + *@class DataObject + *@brief 定义测井管理基类 + */ +class DataObject +{ +public: + /** + * @brief 构造函数 + */ + DataObject():m_DataID(0), + m_DataBelongID(0), + m_Name(""), + m_Creator(""), + m_CreateData(0), + m_ModifyData(0), + m_LastAccessData(0) + { + } + /** + * @brief 析构函数 + */ + virtual ~DataObject(){}; + /** + * @brief 拷贝构造函数 + */ + DataObject(const DataObject& wobject):m_DataID(wobject.GetDataID()), + m_DataBelongID(wobject.GetDataBelongID()), + m_Name(wobject.GetName()), + m_Creator(wobject.GetCreator()), + m_CreateData(wobject.GetCreateData()), + m_ModifyData(wobject.GetModifyData()), + m_LastAccessData(wobject.GetLastAccessData()) + { + } + /** + * @brief 赋值 + */ + DataObject & operator=(const DataObject& wobject) + { + if (this == &wobject) + return *this; + this->SetDataID(wobject.GetDataID()); + this->SetDataBelongID(wobject.GetDataBelongID()); + this->SetName(wobject.GetName()); + this->SetCreator(wobject.GetCreator()); + this->SetCreateData(wobject.GetCreateData()); + this->SetModifyData(wobject.GetModifyData()); + this->SetLastAccessData(wobject.GetLastAccessData()); + return *this; + } + /** + * @brief 保存数据 + */ + virtual void Save() = 0; + /** + * @brief 根据ID获取对象信息 + * @param[in]id数据ID + */ + virtual void Get(long long id) = 0; + /** + * @brief 修改数据 + */ + virtual void Update() = 0; + /** + * @brief 删除数据 + */ + virtual void Delete(long long id = 0) = 0; + /** + * @brief 取得创建时间 + */ + long long GetCreateData() const + { + return m_CreateData; + } + /** + * @brief 取得创建者 + */ + std::string GetCreator() const + { + return m_Creator; + } + /** + * @brief 取得数据所属ID + */ + long long GetDataBelongID() const + { + return m_DataBelongID; + } + /** + * @brief 取得数据ID + */ + long long GetDataID() const + { + return m_DataID; + } + /** + * @brief 取得最后访问时间 + */ + long long GetLastAccessData() const + { + return m_LastAccessData; + } + /** + * @brief 取得修改时间 + */ + long long GetModifyData() const + { + return m_ModifyData; + } + /** + * @brief 取得数据名 + */ + std::string GetName() const + { + return m_Name; + } + /** + * @brief 设置创建时间 + */ + void SetCreateData(long long createData) + { + this->m_CreateData = createData; + } + /** + * @brief 设置创建者 + */ + void SetCreator(std::string creator) + { + this->m_Creator = creator; + } + /** + * @brief 设置数据所属ID + */ + void SetDataBelongID(long long dataBelongID) + { + this->m_DataBelongID = dataBelongID; + } + /** + * @brief 设置数据ID + */ + void SetDataID(long long dataID) + { + this->m_DataID = dataID; + } + /** + * @brief 设置最后访问时间 + */ + void SetLastAccessData(long long lastAccessData) + { + this->m_LastAccessData = lastAccessData; + } + /** + * @brief 设置修改时间 + */ + void SetModifyData(long long modifyData) + { + this->m_ModifyData = modifyData; + } + /** + * @brief 设置数据名 + */ + void SetName(std::string name) + { + this->m_Name = name; + } + +private: + long long m_DataID; ///<数据ID + long long m_DataBelongID; ///<数据所属ID + std::string m_Name; ///<数据名 + std::string m_Creator; ///<创建者 + long long m_CreateData; ///<创建时间 + long long m_ModifyData; ///<修改时间 + long long m_LastAccessData; ///<最后访问时间 +}; + +} +} +} +#endif diff --git a/OSGDataModel/include/ObjWelllog.h b/OSGDataModel/include/ObjWelllog.h new file mode 100644 index 0000000..4dfa9f8 --- /dev/null +++ b/OSGDataModel/include/ObjWelllog.h @@ -0,0 +1,286 @@ +/** +* @file ObjWellLog.h +* @brief 测井曲线数据模型 +* @date 2014-6-3 +* @author: liyonggang +*/ +#ifndef PAI_FRAME_OSGWELLLOG_H +#define PAI_FRAME_OSGWELLLOG_H +#pragma warning( push ,0) +#include "MemRdWt.h" +#include +#include +#include +#include "BaseObject.h" +// #include "WelllogCurve.h" +#include "GeometryUtils.h" +#include "BaseFun.h" +// #include "ObjBaseObject.h" +#pragma warning( pop ) + +BEGIN_OSGDATAMODEL_NAMESPACE; + +class CObjWell; +class CObjWelllogRound; +class CObjWellLogTrack; +class CObjWellTrack; +class OSGDATAMODEL_EXPORT CObjWellLog: public QObject +{ + Q_OBJECT +public: + CObjWellLog(); + CObjWellLog(bool visible); + ~CObjWellLog(); + Slf_CURVE acurveinfo; + CObjWell *GetWell(); + CObjWelllogRound *GetWelllogRound(); + std::vector& GetDepths() + { + return m_vDepths; + } + std::vector& GetFlags() + { + return m_vFlags; + } + void SetModify(bool ischange) + { + // SetModified(ischange,false); + } + bool ExpendData(bool isHead,float EDepth); + bool DeleteData(float Stdep,float Endep); + + /** + * @brief 设置对象的名字标识 + * @param[in] name 名字标识 + */ + virtual void SetName(const QString & name); + /** + * @brief 得到属性的最小最大值 + */ + + virtual float GetPropertyMin(); + + virtual float GetPropertyMax(); + + virtual void SetpropertyMin(float Propertymin); + + virtual void SetpropertyMax(float Propertymax); + /** + * @brief 重新计算最大最小值 + */ + void ReCalculateMinMax(); + + // virtual bool Serialize( CObjectArchive &ar ); + + virtual QUuid GetTypeID()const; + + virtual double GetShiftTopDepth(); + virtual double GetTopDepth(); + + virtual double GetShiftBottomDepth(); + virtual double GetBottomDepth(); + + virtual void SetShiftBottomDepth(double bottomDepth); + virtual void SetBottomDepth(double bottomDepth); + + virtual void SetShiftTopDepth(double topDepth); + virtual void SetTopDepth(double topDepth); + + virtual pai::ios::welllog::DataObject *GetDbObject(); + virtual QStringList GetColumnHeadList(); + virtual CBaseObject *CloneObject(); + //从slf加载数据 + virtual bool LoadFromSLF(); + //数据变化后写入slf数据 + virtual bool SaveToSLF(); + //从slf文件删除 + virtual bool DeleteFromSLF(); + virtual bool CopyToSLFFile(QString targetSLFFileName,bool deleteFromSrc=false,char*newCurveName=NULL); + virtual bool RenameToSLF(){return true;}; + virtual bool CloneInSlfFile(QString newname); + virtual bool RenName(const QString & name); + virtual void AddShiftDepth(double shiftdepth); + virtual void ChangeDepth(double shiftdepth); + virtual void ApplyShiftDepth(); + double GetShiftOffset(); + void SetShiftOffset(double DepthOffset); + void EShiftDepth(int count,float *sdeps,float *edeps); + void MoveShift(float sdep,float edep,float dmove); + void MoveShift(); + double GetRlev(); + void SetRlev(float rlev); + bool IsLoaded() { + return isRun; + } + //说明：对象有两个名字，Name和AliasName，name就是slf文件中的curveName + virtual void SetAliasName(QString AliasName) + { + m_AliasName=AliasName; + } + virtual QString GetAliasName() + { + return m_AliasName; + } + + virtual void SetUnit(QString Unit) + { + m_Unit=Unit; + } + virtual QString GetUnit() + { + return m_Unit; + } + + virtual void SetAliasUnit(QString AliasUnit) + { + m_AliasUnit=AliasUnit; + } + virtual QString GetAliasUnit() + { + return m_AliasUnit; + } + + virtual void SetDepthAliasUnit(QString DepthAliasUnit) + { + m_DepthAliasUnit=DepthAliasUnit; + } + virtual QString GetDepthAliasUnit() + { + return m_DepthAliasUnit; + } + + virtual void SetDepthUnit(QString DepthUnit) + { + m_DepthUnit=DepthUnit; + } + virtual QString GetDepthUnit() + { + return m_DepthUnit; + } + + void SetWell(CObjWell *pObjWell) + { + m_pObjWell=pObjWell; + } + + /** + * @brief 根据读取的曲线名称进行自动匹配 + */ + void AutoMatchFamily(); + /** + * @brief familytype初始化曲线名和单位 + */ + void InitCurveNameAndUnitByFamily(std::string familyType); + + //重采样 intervel采样间隔 + void ReSample(double newDelta); + /** + * @brief 得到去掉无效值后的MD,Property + */ + virtual void GetValidMDProperty(PFLOATPROPERTY &vMD,PFLOATPROPERTY &vProperty,float sdep=0,float edep=7000 ); + + /** + * @brief 获得所有的无效和有效的Property + */ + void GetMDProperty(FLOATPROPERTY &vMD,FLOATPROPERTY &vProperty ); + /** + * @brief 获得深度范围内所有的无效和有效的Property + */ + void GetZoneMDProperty(FLOATPROPERTY &vMD,FLOATPROPERTY &vProperty ,float sdep=0,float edep=7000); + + void SetMD(PFLOATPROPERTY *vMD ); + void SetProperty(PFLOATPROPERTY *vMD,PFLOATPROPERTY *vProperty ); + void SetProperty(PFLOATPROPERTY *vMD,FLOATPROPERTY *vProperty ); + /** + * @brief 得到DB 测井对象 + */ + // pai::ios::welllog::WelllogCurve &GetLogCurve(); + + /** + * @brief Get/Set MD,Proeprty + */ + PFLOATPROPERTY &GetProperty( ); + PFLOATPROPERTY &GetMD( ); + void SetProperty(FLOATPROPERTY *vMD, FLOATPROPERTY *vProperty ); + void SetMD(FLOATPROPERTY *vMD ); + //将内存数据清空 + void clearData(); + void SetSlfFileName(QString filePath); + QString GetSlfFileName(); + virtual QString GetDescription(); + void SetData(int repCode,char *buffer,double yy); + double GetData(int repCode,char *buffer,int repLen); + void SetData(int i,float *buffer);//按行写入一个数据 + double GetData(int i,char *buffer=NULL);//按行杜一个数据 + double GetData(float dep,char *buffer=NULL);//按深度取一个数据 + void SetData(float dep,float *value);//按深度写入一个数据 + void SetData(float dep,float value); + CObjWellLogTrack *GetWellLogTrack(); + CObjWellTrack *GetWellTrack(); + /************************************************************************/ + /* @brief 得到该对象的模板关键字，例如井曲线对象的family名字 */ + /************************************************************************/ + virtual QVariant GetTemplateKey(); + QString GetName(){return m_name;} +protected: + QString m_SlfFileName; +//private: + + void _CalculateMinMax(bool force = false); + /** + * @brief 设置数据所属ID + */ + void SetBelongID(); + + + float m_fPropertMin; + float m_fPropertMax; + double m_TopDepth; + double m_BottomDepth; + + double m_ShiftTopDepth; + double m_ShiftBottomDepth; + double m_DepthOffset; + + // pai::ios::welllog::WelllogCurve m_logCurve; +protected: + PFLOATPROPERTY m_vMD; + FLOATPROPERTY m_vMDShifting; + PFLOATPROPERTY m_vProperty; + LPSTR *m_SharedMemory; + HANDLE m_Handle; + QString key; +public: + char m_strValue[200]; + QString m_AliasName; + int m_ObjectType; + float m_Rlev; + int IsObjectExist(QString name); + int m_ChangeNo; + std::vectorm_vLayers; + CObjWell *m_pObjWell; + std::vector m_vDepths; //深度序列. + std::vector m_vFlags; //绘制标志. + bool isRun; + void loadInfo(); + bool isLoad; + bool isUsing; +/////////////////////// + QString m_Unit; + QString m_AliasUnit; + QString m_DepthUnit; + QString m_DepthAliasUnit; + QString m_name; +public slots: + void slotRefreshData(QString slf,QString curname,QObject*rec=NULL); + void slotDeAttchData(QString slf,QString curname); +public: +}; +template +void AddToWellRound(QString objname,T *aclass,char* ID,int Type); + +using namespace pai::datamodel; +using namespace pai::ios::welllog; + +END_OSGDATAMODEL_NAMESPACE +#endif diff --git a/OSGDataModel/include/ObjWelllogTABLE.h b/OSGDataModel/include/ObjWelllogTABLE.h new file mode 100644 index 0000000..587ff1b --- /dev/null +++ b/OSGDataModel/include/ObjWelllogTABLE.h @@ -0,0 +1,33 @@ +/** +* @file ObjWellLogTABLE.h +* @brief 测井多维曲线数据模型 +* @date 2015-2-10 +* @author: WANGWEI +*/ +#ifndef PAI_FRAME_OSGWELLLOGTABLE_H +#define PAI_FRAME_OSGWELLLOGTABLE_H +#pragma warning( push ,0) +#include +#include "BaseObject.h" +#include "ObjWelllog.h" +// #include "ObjectEvent.h" +#pragma warning( pop ) + +BEGIN_OSGDATAMODEL_NAMESPACE; + +class CObjWell; + +class OSGDATAMODEL_EXPORT CObjWellLogTABLE: public CObjWellLog +{ + Q_OBJECT +public: + CObjWellLogTABLE(); + virtual ~CObjWellLogTABLE(); + virtual QUuid GetTypeID()const; +}; + +using namespace pai::datamodel; +using namespace pai::ios::welllog; + +END_OSGDATAMODEL_NAMESPACE +#endif diff --git a/OSGDataModel/src/BaseObject.cpp b/OSGDataModel/src/BaseObject.cpp new file mode 100644 index 0000000..0348257 --- /dev/null +++ b/OSGDataModel/src/BaseObject.cpp @@ -0,0 +1,514 @@ +#pragma warning( push ,0) +#include +#include + +#include + +#include "BaseObject.h" +#include "ObjectID.h" +// #include "ObjProject.h" +// #include "ObjWell.h" +// #include "ObjWelllogRound.h" +// #include "ObjDiscreteWellLog.h" +#pragma warning( pop ) + +BEGIN_OSGDATAMODEL_NAMESPACE; + +sObjectClassIDKey::sObjectClassIDKey() +{ + +} + +sObjectClassIDKey::sObjectClassIDKey( QUuid ObjectClassID ) +{ + m_ObjectClassID = ObjectClassID ; +} + +bool sObjectClassIDKey::operator !=( const sObjectClassIDKey& s ) +{ + return m_ObjectClassID != s.m_ObjectClassID; +} + +bool sObjectClassIDKey::operator < ( const sObjectClassIDKey& s ) const +{ + return m_ObjectClassID < s.m_ObjectClassID; +} + + +// CBaseObjectImpl::~CBaseObjectImpl() +// { +// DeleteAllChild(); +// } + + +// QString CPaiObjectHelper::GetUniqueChildName(PaiObject *pPaiObject,QString strPreFixName ) +// { +// if(! pPaiObject->GetObjectByName ( strPreFixName ) ) +// return strPreFixName; +// return pPaiObject->GetNextChildName(strPreFixName); +// } + +// void CBaseObjectImpl::Init(QUuid classID) +// { +// m_classTypeID = classID; +// } + +// QUuid CBaseObjectImpl::GetTypeID() const +// { +// return m_classTypeID; +// } + + +// PaiObject *CPaiObjectHelper::GetRoot(PaiObject * pThis) +// { +// PaiObject *pRoot = pThis; +// while( pRoot && pRoot->GetParent() ) +// { +// pRoot = pRoot->GetParent(); +// } + +// return pRoot; +// } + +// bool CBaseObject::Contains(const QUuid& id) +// { +// if(this->m_pPaiObject != NULL) +// { +// return NULL != (m_pPaiObject->GetObject(id)); +// } +// return false; +// } + +// std::vector CPaiObjectHelper::GetAllSymbolObject( CBaseObject * pOSGObject ) +// { +// std::vector vAllChildrenandSelf; +// std::vector vAllChildren; +// CPaiObjectHelper::RecursionGetAllChild( dynamic_cast(pOSGObject),vAllChildrenandSelf); +// foreach (PaiObject* pChild,vAllChildrenandSelf) +// { +// QString t_name = pChild->GetName(); +// if ( !(pChild->GetChildrenCount()) ) +// { +// //判断是否为图像 如果不是则continue +// if (t_name.right(4).left(1) != ".") continue; +// if( dynamic_cast( pChild ) ) +// vAllChildren.push_back(dynamic_cast( pChild )); +// } +// } +// return vAllChildren; +// } + +// CBaseObject * CPaiObjectHelper::GetSubtree( CBaseObject * pThis,QString strRelativeFolderPath ) +// { +// QStringList folderNamelist = strRelativeFolderPath.split("/"); + +// CBaseObject * pViewObject= pThis; +// foreach ( QString strfolderName, folderNamelist ) +// { +// pViewObject = dynamic_cast(GetChildByName(dynamic_cast(pViewObject),strfolderName) ); +// if( !pViewObject) return NULL; +// } +// return pViewObject; +// } + +// PaiObject* CPaiObjectHelper::GetChildByName(PaiObject*pObject,QString name) +// { +// QList lstChildren; +// pObject->GetChildren(lstChildren); + +// foreach(PaiObject * pChildObject, lstChildren) +// { +// if((pChildObject->GetName()) == name) return pChildObject; +// } +// return NULL; +// } + + +// pai::ios::welllog::DataObject* CBaseObjectImpl::GetDbObject() +// { +// return NULL; +// } + +// bool CPaiObjectHelper::SerializeDB( CObjectArchive &ar,pai::ios::welllog::DataObject *pDbObject ,pai::objectmodel::PaiObject *pPaiObject ) +// { +// if( ar.IsStoring() ) +// { +// //保存到数据库 +// long long dataID = 0; +// if( pDbObject ) +// { +// dataID = pDbObject->GetDataID(); +// if( pPaiObject ) +// { +// pDbObject->SetName( pPaiObject->GetName().toStdString() ); +// } +// if( dataID==0 ) +// { +// pai::datamodel::CObjDiscreteWellLog *discreteWellLog = dynamic_cast(pPaiObject); +// if(discreteWellLog) +// { +// discreteWellLog->SaveDBObject(); + +// } +// else +// { +// pDbObject->Save(); +// } + +// }else +// { +// pDbObject->Update(); +// } +// dataID = pDbObject->GetDataID(); +// } +// ar<< dataID; +// }else +// { +// long long dataID(0); +// ar >> dataID; +// if( pDbObject && dataID > 0) +// { +// pDbObject->SetDataID( dataID ); +// pDbObject->Get( dataID ); +// } +// } +// return true; +// } + +CObjectGenralFactory< sObjectClassIDKey,CBaseObject >& CBaseObject::GetFatory() +{ + static COSGObjectFactory fatory; + return fatory; +} + + +/*void CPaiObjectHelper::RecursionGetAllChild(PaiObject* pThis,std::vector &vChild) +{ + if( !pThis ) return; + + vChild.push_back( pThis ) ; + + QListvChildThis ; + pThis->GetChildren(vChildThis); + foreach( PaiObject *pChild,vChildThis ) + { + RecursionGetAllChild(pChild, vChild ); + } +} + +void CPaiObjectHelper::RecursionGetAllChildren( PaiObject* pThis,std::vector &vChild ) +{ + std::vector vPaiChild; + RecursionGetAllChild( pThis,vPaiChild ); + + foreach( PaiObject* pObject,vPaiChild ) + { + if( dynamic_cast( pObject ) ) + { + vChild.push_back( dynamic_cast( pObject ) ); + } + } +}*/ + +// void CBaseObjectImpl::Delete() +// { +// // PaiObject*pPai=GetParent(); +// // if(pPai) pPai->RemoveChild(this,false); +// // SetParent(NULL); +// DeleteAllChild(); +// delete this; +// } + +// bool CBaseObjectImpl::Serialize( CObjectArchive &ar ) +// { +// pai::ios::welllog::DataObject* pDbObject = GetDbObject(); + +// QFile *pFile = dynamic_cast( ar.GetDevice() ); +// bool bToDisk = pFile ? true :false; + +// if(ar.IsStoring()) +// { +// BEGIN_WRITE_OBJECT( ar,1 ); + +// BEGIN_WRITE_BLOCK( ar, 1); + +// //保存到数据库 +// if( bToDisk &&pDbObject) +// { +// CPaiObjectHelper::SerializeDB( ar,pDbObject,this ); +// } + +// //保存自己的信息 +// ar << GetID(); +// ar << GetName(); +// ar < lstChildren; +// GetChildren(lstChildren); +// int nChildCout = lstChildren.size(); +// ar << nChildCout; +// for( long i = 0 ; i< nChildCout;++i ) +// { +// CBaseObject* pChild = dynamic_cast( lstChildren[i] ); +// assert( pChild ); +// ar << lstChildren[i] ->GetTypeID().toString(); +// pChild->Serialize( ar ); +// } +// } +// END_WRITE_BLOCK( ar, 1 ); + +// END_WRITE_OBJECT( ar ); +// } +// else +// { +// BEGIN_READ_OBJECT( ar,1 ); + +// BEGIN_READ_BLOCK( 1 ); + +// if( bToDisk &&pDbObject) +// { +// CPaiObjectHelper::SerializeDB( ar,pDbObject,this ); +// } + +// //加载自己的信息 +// QString strTmp; +// ar >> strTmp; +// SetID(strTmp ); + +// QString strName; +// ar >> strName; +// SetName( strName); +// QString gstrName; +// ar >>gstrName; +// SetGhostName(gstrName); +// //加载所有的孩子 +// if( bToDisk ) +// { +// DeleteAllChild(); +// int nChildCout(0); +// ar >> nChildCout; +// for( long i = 0 ; i< nChildCout;++i ) +// { +// ar >> strTmp; +// QUuid classID = QUuid(strTmp); +// CBaseObject *pChild = GetFatory().CreateObject( classID ); +// PaiObject *pPaiObject = dynamic_cast( pChild ); +// CBaseObjectImpl *pChildImp = dynamic_cast( pChild ); +// if( pChildImp ) +// { +// pChildImp->Init( classID ); +// } +// if( pChild ) +// { +// pChild->Serialize( ar ); +// AddChild( pPaiObject ); +// }else +// { +// assert( false); +// ar.SkipObject(); +// } +// } +// } + +// END_READ_BLOCK( 1 ); + +// END_READ_OBJECT( ar ); +// } +// return true; +// } + +CBaseObject *CBaseObject::CloneObject() +{ + // PaiObject *pPaiObject = this->GetPaiObject(); + // if( pPaiObject ) + // { + // CBaseObject *pClone = GetFatory().CreateObject( pPaiObject->GetTypeID() ); + // if( pClone ) + // { + // pClone->CopyFrom( this ); + // pClone->GetPaiObject()->SetID(QUuid::createUuid()); + // return pClone; + // } + // } + + return NULL; +} + +CBaseObject *CBaseObject::GhostObject() +{ + return NULL; + // CBaseObjectImpl* result=dynamic_cast(CloneObject()); + // if(!result) return NULL; + // result->SetGhostName(result->GetPaiObject()->GetName()+OBJ_GHOST_MARK+QString::fromStdString(GenTimeStamp())); + // result->SetVisibleOnTree(false); + // return result; +} + +void CBaseObject::CopyFrom( CBaseObject *pOSGObjectOther ) +{ + // QByteArray byteArr; + // { + // CObjectArchive ar( byteArr, eStore ); + // pOSGObjectOther->Serialize( ar ); + // } + // CObjectArchive ar( byteArr, eLoad ); + // this->Serialize( ar ); +} +// void CBaseObject::SetTemplateKey(QVariant TemplateKey) +// { +// m_TemplateKey=TemplateKey; +// } + +// QVariant CBaseObject::GetTemplateKey() +// { +// if(m_TemplateKey!=QVariant()) return m_TemplateKey; +// PaiObject* paiObject = this->GetPaiObject(); +// if(paiObject != NULL) +// { +// // QUuid val=QUuid::createUuid(); +// // m_TemplateKey=QVariant(val); +// return QVariant(paiObject->GetTypeID()); +// } +// return QVariant(); +// } + +// bool CBaseObjectImpl::HasChildren(PaiObject* pChild) +// { +// QList objectList; +// PaiObject::GetChildren(objectList); +// if(objectList.size() > 0) +// { +// foreach(PaiObject* obj,objectList) +// { +// if(obj == pChild) +// { +// return true; +// } +// } +// } +// return false; +// } +// bool CBaseObjectImpl::AddChild(PaiObject* pChild, bool mountNow ) +// { +// CObjProject::AddIDMap( pChild->GetID(),dynamic_cast( pChild) ); +// QUuid id=GetTypeID(); +// if(id==GetClassID_SingleWellMapFolder() +// ||id==GetClassID_WorkflowFolder() +// ||id==GetClassID_SingleMethodFolder() +// ) +// { +// if(GetChildrenCount()==0){ +// PaiObject *pPai=GetParent(); +// CObjProject::RemoveIDMap( dynamic_cast(this ) ); +// if(pPai) +// pPai->RemoveChild(this,false); +// SetVisibleOnTree(true); +// CObjProject::AddIDMap( GetID(), dynamic_cast( this)); +// pPai=GetParent(); +// if(pPai) +// pPai->AddChild(this,MountOnTree); +// } + +// } +// if(mountNow) return PaiObject::AddChild( pChild,MountOnTree ); +// else return PaiObject::AddChild( pChild,MountNoTree ); +// } + +// bool CBaseObjectImpl::InsertChild(int iIndex,PaiObject* pChild) +// { +// CObjProject::AddIDMap( pChild->GetID(), dynamic_cast( pChild)); +// /* +// if(pChild&&pChild->GetParent()&&pChild->GetParent()) { +// QListlists; +// pChild->GetParent()->GetChildren(lists); +// if(lists.size()GetParent()->AddChild(pChild); +// } +// else if(iIndex<1) { +// iIndex=0; +// return PaiObject::InsertChild( iIndex, pChild ); +// } +// return true; +// } +// */ +// return PaiObject::InsertChild( iIndex, pChild ); +// } + +// bool CBaseObjectImpl::RemoveChild(PaiObject* pChild, bool bDelete ) +// { +// CObjProject::RemoveIDMap( dynamic_cast(pChild ) ); +// // m_EventAgent.RemoveObjectChild(this, pChild ); +// return PaiObject::RemoveChild( pChild,bDelete ); + +// } +// bool CBaseObjectImpl::isExistsName(QString name) +// { +// QList objs; +// if(this->GetParent() != NULL) +// { +// GetParent()->GetChildren(objs); +// } +// foreach(PaiObject* obj, objs) +// { +// if(obj != NULL && obj != this && obj->GetName().compare(name,Qt::CaseInsensitive)==0) +// { +// return true; +// } +// } +// return false; +// } + + +// void CBaseObjectImpl::DeleteAllChild() +// { +// QList::iterator it = m_children.begin(); +// while ( it != m_children.end() ) +// { +// PaiObject* pChild = (*it); +// // m_EventAgent.RemoveObjectChild(this, pChild ); +// CObjProject::RemoveIDMap( dynamic_cast( pChild ) ); +// pChild->Delete(); +// ++it; +// } +// m_children.clear(); +// } + +// void CBaseObjectImpl::SetVisibleOnTree(bool visible) +// { +// SetFlagEnable(PaiObject::VisibibleOnTree,visible); +// } + +// CBaseObjectImpl::CBaseObjectImpl() +// { + +// } + +// bool CBaseObjectImpl::TakeChild(PaiObject* pChild) +// { +// if( m_children.contains( pChild ) ) +// { +// // m_EventAgent.RemoveObjectChild( this,pChild ); +// m_children.removeAll( pChild ); +// return true; +// } +// return false; +// } +// int CBaseObjectImpl::GetChildPos(PaiObject* pChild) +// { +// int o=-1; +// for(int i=0;i +char *m_temp=NULL; +CString::CString(const char *str) +{ + m_temp=NULL; + if(str==NULL) + m_data =""; + else + m_data=QString::fromLocal8Bit(str); +} +CString::CString(const QString str) +{ + m_temp=NULL; + if(str==NULL) + m_data =""; + else + m_data=str; +} + +CString::~CString() +{ + if(m_temp) delete m_temp; + m_temp=NULL; +}; +void CString::Empty() +{ + m_data =""; +} + +CString::CString(const CString &other) +{ + m_temp=NULL; + m_data=other.m_data; +} +int CString::GetLength()const +{ + return m_data.length(); +} +int CString::Find(char *str) +{ + std::string dataStr=m_data.toStdString(); + return dataStr.find(str); +} +int CString::Find(CString &another) +{ + return m_data.toStdString().find(another.m_data.toStdString()); +} +int CString::Find(char str) +{ + std::string dataStr=m_data.toStdString(); + return dataStr.find(str); +} +/* + +*/ +int CString::Find(char str[],int start) +{ + std::string dataStr=m_data.toStdString(); + int npos=dataStr.find(str); + if(npos==-1) + return -1; + if(nposStrVector; + int left=0; + for (int i=0;i-1;i--) + { + if(tempstr[i]==findStr.at(0)) { + continue; + } + else { + flag=i; + break; + } + } + m_data=temp.left(flag+1); + return *this; +} +bool CString::operator==(const char* other ) +{ + QString srcStr=QString::fromLocal8Bit(other); + if(this->m_data==srcStr) + return true; + return false; +} +bool CString::operator!=(const char* other ) +{ + QString srcStr=QString::fromLocal8Bit(other); + if(this->m_data!=srcStr) + return true; + return false; +} +char CString::operator[](int i) +{ + char ch=GetChar(i); + return ch; +} +CString CString::Right(int count)const +{ + if (count<0) + { + count=0; + } + if (count>m_data.length()) + { + return *this; + } + int length=m_data.length(); + QString temp=m_data; + QString lastdata=temp.remove(0,length-count); + CString RightStr(lastdata); + return RightStr; +} +CString CString::Mid(int pos,int count)const +{ + if (count<0) + { + count=0; + } + QString temp=m_data.mid(pos,count); + CString mstr(temp); + return mstr; +} +CString CString::Mid(int pos)const +{ + QString temp=m_data.mid(pos); + CString mstr(temp); + return mstr; +} + +CString CString::Left(int count)const +{ + if (count<0) + { + count=0; + } + if (count>m_data.length()) + { + return *this; + } + int length=m_data.length(); + QString temp=m_data; + QString lastdata=temp.remove(count,length-count); + CString leftStr(lastdata); + return leftStr; +} + +CString CString::operator + (const CString& SrcStr) +{ + CString str; + str.m_data=m_data+SrcStr.m_data; + return str; +} +/* +CString CString::operator = (const QString& SrcStr) +{ +CString str; +str.m_data=SrcStr; +return str; +} +*/ +CString CString::operator += (CString& SrcStr) +{ + m_data = m_data+SrcStr.m_data ; + return *this; +} +CString CString::operator += (const CString& SrcStr) +{ + m_data = m_data+SrcStr.m_data ; + return *this; +} +bool CString::operator!=(const CString& other ) +{ + return m_data!=other.m_data; +} +bool CString::operator==(const CString& other ) +{ + return m_data==other.m_data; +} + +void CString::Alloc(int len) +{ +} +char* CString::GetString() const +{ + int length=((string)(m_data.toLocal8Bit().data())).length(); + if(m_temp) delete m_temp; + m_temp=new char[length+1]; + // Alloc(length); + strcpy(m_temp,m_data.toLocal8Bit().data()); + return m_temp; +} +char CString::GetChar(int n) +{ + return GetString()[n]; +} +char CString::GetAt(int n) +{ + return GetChar(n); +} + +void CString::Format(const char *format,...) +{ + //char *str=GetString(); + va_list args; + va_start(args,format); + m_data.vsprintf(format,args); + char *buf=new char[2*strlen(m_data.toStdString().c_str())+1]; + vsprintf(buf,format,args); + m_data=buf; + delete buf; + va_end(args); +} +void ShowMessage(QString mess) +{ + QDialog dialog(NULL); + dialog.setModal(false); + Qt::WindowFlags flags = dialog.windowFlags(); + flags |= Qt::WindowStaysOnTopHint; + flags &= ~Qt::WindowContextHelpButtonHint; + dialog.setWindowFlags(flags); + dialog.setWindowTitle("提示"); + QFormLayout form(&dialog); + QLabel edit(&dialog); + form.addRow(&edit); + edit.setText(mess); +// QDialogButtonBox buttonBox(QDialogButtonBox::Yes,Qt::Horizontal, &dialog); +// form.addRow(&buttonBox); +// if(buttonBox.button(QDialogButtonBox::Yes)) buttonBox.button(QDialogButtonBox::Yes)->setText("退出"); +// QObject::connect(buttonBox.button(QDialogButtonBox::Yes), SIGNAL(clicked()), NULL, SLOT(reject())); + dialog.show(); + dialog.exec(); +} +int AfxMessageBox(CString str) +{ + QDialog dialog(NULL); + dialog.setModal(false); + Qt::WindowFlags flags = dialog.windowFlags(); + flags |= Qt::WindowStaysOnTopHint; + flags &= ~Qt::WindowContextHelpButtonHint; + dialog.setWindowFlags(flags); + dialog.setWindowTitle("提示"); + QFormLayout form(&dialog); + form.addWidget(new QLabel(str.GetString())); +// dialog.show(); + if (dialog.exec() == QDialog::Accepted) { + // Do something here + } +// return MessageBox(NULL,"提示",str.GetString(),NULL ); +// QString cstr=str.GetString(); +// QMessageBox msgBox; +// msgBox.setText(cstr); +// return msgBox.exec(); + return 1; +} + +int MessageBox(QWidget *parent,char lpText[128],char*lpCaption, int UINTuType) +{ + if (!parent) + { + char *tempName=lpCaption; + QString addStr=QString::fromLocal8Bit(tempName); + return QMessageBox::information(NULL,lpText,addStr,QMessageBox::Ok); + } + return 0; +} diff --git a/OSGDataModel/src/OSGDataModel.pro b/OSGDataModel/src/OSGDataModel.pro index 4ae271c..c8c1d0d 100644 --- a/OSGDataModel/src/OSGDataModel.pro +++ b/OSGDataModel/src/OSGDataModel.pro @@ -31,6 +31,10 @@ DEFINES += QT_DLL HeadS += ../include/*.h SOURCES += *.cpp +HEADERS += \ + ../include/BaseObject.h \ + ../include/ObjWelllog.h \ + ../include/ObjWelllogTABLE.h #CPATH = $$system(pwd) # 目标文件夹 diff --git a/OSGDataModel/src/ObjWellLog.cpp b/OSGDataModel/src/ObjWellLog.cpp new file mode 100644 index 0000000..8370724 --- /dev/null +++ b/OSGDataModel/src/ObjWellLog.cpp @@ -0,0 +1,1877 @@ +#pragma warning( push ,0) +#include +#include +#include +#include +#include "LogIO.h" +#include "ObjWelllog.h" +// #include "ObjWell.h" +// #include "ObjWelllogRound.h" +// #include "ObjWellTrack.h" +// #include "ObjWellLogTrack.h" +// #include "FamilyAliases.h" +// #include "Family.h" +#include "MemRdWt.h" +#include "BaseFun.h" +// #include "ObjectEvent.h" +#include "ObjectID.h" +#pragma warning( pop ) + +BEGIN_OSGDATAMODEL_NAMESPACE; +CObjWellLog::CObjWellLog(bool visible) +{ + // SetFlagEnable(PaiObject::VisibibleOnTree, visible); + m_fPropertMin = 200; + m_fPropertMax = 100; + m_DepthOffset = 0; + // SetIconName("icon/Log.png"); + m_BottomDepth=0.0; + m_TopDepth=0.0; + SetName("AC"); + m_ShiftTopDepth=-9999.0; + m_ShiftBottomDepth=-9999.0; + m_ObjectType=0; + m_Rlev=0.125; + m_ChangeNo=0; + m_pObjWell=NULL; + m_strValue[0]=0; + isRun=0; + m_SharedMemory=NULL; + m_Handle=NULL; + // connect( (const QObject*)( &GetObjectEvent() ),SIGNAL(RefreshData(QString,QString,QObject*)),this,SLOT(slotRefreshData(QString ,QString,QObject*))); + // connect( (const QObject*)( &GetObjectEvent() ),SIGNAL(DeAttchData(QString,QString)),this,SLOT(slotDeAttchData(QString ,QString))); +} +CObjWellLog::CObjWellLog() +{ + m_fPropertMin = 0; + m_fPropertMax = 100; + m_DepthOffset = 0; + // SetIconName("icon/Log.png"); + m_BottomDepth=0.0; + m_TopDepth=0.0; + m_ShiftTopDepth=-9999.0; + m_ShiftBottomDepth=-9999.0; + SetName("AC"); + m_ObjectType=0; + m_Rlev=0.125; + m_ChangeNo=0; + m_pObjWell=NULL; + isRun=false; + isLoad=false; + isUsing = false; + m_SharedMemory=NULL; + m_Handle=NULL; + // connect( (const QObject*)( &GetObjectEvent() ), + // SIGNAL(RefreshData(QString,QString,QObject*)), + // this,SLOT(slotRefreshData(QString ,QString,QObject*))); + // connect( (const QObject*)( &GetObjectEvent() ),SIGNAL(DeAttchData(QString,QString)),this,SLOT(slotDeAttchData(QString ,QString))); +} +void CObjWellLog::slotRefreshData(QString slf,QString curname,QObject*re) +{ +// if(re==this) { +// return; +// } +// QString slf1=m_SlfFileName; +// slf1.replace("\\","/"); +// QString slf2=slf; +// slf2.replace("\\","/"); +// slf1.toUpper(); +// slf2.toUpper(); +// if(slf1==slf2) { +// if(!curname.isEmpty()) { +// if(GetName()==curname&&isRun) { +// // isLoad=false; +// GetValidMDProperty(m_vMD,m_vProperty,-99999,-99999); +// // LoadFromSLF(); +// } +// return; +// } +// else { +// if(isRun) { +// // isLoad=false; +// GetValidMDProperty(m_vMD,m_vProperty,-99999,-99999); +// // LoadFromSLF(); +// } +// } +// } +} +void CObjWellLog::slotDeAttchData(QString slf,QString curname) +{ + QString slf1=m_SlfFileName; + slf1.replace("\\","/"); + QString slf2=slf; + slf2.replace("\\","/"); + slf1.toUpper(); + slf2.toUpper(); + if(slf1==slf2) { + if(!curname.isEmpty()) { + if(GetName()==curname&&isRun) { + QString name=GetSlfFileName()+GetName(); + if(IsMappingMem(name.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + m_vMD.clear(); + m_vProperty.clear(); + m_vMDShifting.clear(); + } + isLoad=false; + } + } + } +} +CObjWellLogTrack *CObjWellLog::GetWellLogTrack() +{ + // PaiObject *pPai=GetPaiObject(); + // while(pPai) { + // CObjWellLogTrack *pTWellLogTrack=dynamic_cast(pPai); + // if(pTWellLogTrack) { + // return pTWellLogTrack; + // } + // pPai=pPai->GetParent(); + // } + return NULL; +} +CObjWellTrack *CObjWellLog::GetWellTrack() +{ + // PaiObject *pPai=GetPaiObject(); + // while(pPai) { + // CObjWellTrack *pTWellTrack=dynamic_cast(pPai); + // if(pTWellTrack) { + // return pTWellTrack; + // } + // else { + // CObjWellLogTrack *pTWellLogTrack=dynamic_cast(pPai); + // if(pTWellLogTrack) { + // CObjWellTrack *pTWellTrack=dynamic_cast(pTWellLogTrack->GetWellTrack()); + // if(pTWellTrack) { + // return pTWellTrack; + // } + // } + // } + // pPai=pPai->GetParent(); + // } + return NULL; +} + + QString CObjWellLog::GetDescription() +{ + //if(!isRun) + { + CLogIO *logio=new CLogIO(); + QString slfFileName=GetSlfFileName(); + if(slfFileName.isEmpty()) return ""; + if(!logio->Open(slfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; + return ""; + } + QString name=GetName(); + int i=logio->OpenCurve(name.toStdString().c_str()); + if(i<0) { + delete logio; + return ""; + } + logio->GetCurveInfo(i,&acurveinfo); + if(acurveinfo.DepLevel!=0&&acurveinfo.EndDepth-acurveinfo.StartDepth>0) + { + if(acurveinfo.MaxValue==acurveinfo.MinValue||acurveinfo.MaxValue==-99999||acurveinfo.MaxValue==-9999||acurveinfo.MinValue==999999||acurveinfo.MinValue==999999||acurveinfo.MinValue==99999||acurveinfo.MinValue==99999||acurveinfo.MinValue==-9999) + { + MyDataTypeEnum vVdl; + DWORD count=(acurveinfo.EndDepth-acurveinfo.StartDepth)/acurveinfo.DepLevel+1.5; + DWORD len=count*acurveinfo.CodeLen; + acurveinfo.MinValue=99999999; + acurveinfo.MaxValue=-99999999; + if(acurveinfo.CodeLen==8) acurveinfo.MinValue=99999999; + vVdl.vchar=new char[len]; + len=logio->ReadCurve(i, acurveinfo.StartDepth,count,(void *)vVdl.vchar); + if(!len) { + delete vVdl.vchar; + delete logio; + return "data error！"; + } + for(int kk=0;kkGetData(acurveinfo.RepCode,&vVdl.vchar[kk*acurveinfo.CodeLen],buf); + if(temp==-9999.0||temp==-999.25||temp==-99999.0) continue; + if(_isnan(temp)||!_finite(temp)) continue; + if(acurveinfo.MaxValuetemp) acurveinfo.MinValue=temp; + } + logio->SetCurveInfo(i,&acurveinfo); + delete vVdl.vchar; + } + } + logio->CloseCurve(i); + delete logio; + } + if(acurveinfo.RepCode<1) acurveinfo.RepCode=1; + if(acurveinfo.RepCode>12) acurveinfo.RepCode=12; + QString result=""; + result.append("对象类型:曲线\n"); + result.append("曲线名:").append(acurveinfo.Name).append("\n"); + result.append("曲线别名:").append(QString::fromStdString(acurveinfo.AliasName)).append("\n"); + result.append("本地数据文件：").append(GetSlfFileName()).append("\n"); + result.append("顶深:").append(QString::number(acurveinfo.StartDepth)).append("\n"); + result.append("底深:").append(QString::number(acurveinfo.EndDepth)).append("\n"); + result.append("采样间隔:").append(QString::number(acurveinfo.DepLevel)).append("\n"); + result.append("数据类型:").append(Rep_STR[acurveinfo.RepCode-1]).append("\n"); + result.append("字节长度:").append(QString::number(acurveinfo.CodeLen)).append("\n"); + result.append("最小值:").append(QString::number(acurveinfo.MinValue)).append("\n"); + result.append("最大值:").append(QString::number(acurveinfo.MaxValue)).append("\n"); + result.append("单位:").append(QString::fromStdString(acurveinfo.Unit)).append("\n"); + return result; +} + +double CObjWellLog::GetRlev() +{ + if(m_Rlev==0) m_Rlev=0.125; + return m_Rlev; +} +void CObjWellLog::SetRlev(float rlev) +{ + m_Rlev=rlev; +} +double CObjWellLog::GetShiftOffset() +{ + return m_DepthOffset; +} +void CObjWellLog::SetShiftOffset(double DepthOffset) +{ + m_DepthOffset=DepthOffset; +} + +float CObjWellLog::GetPropertyMin() +{ + return m_fPropertMin; +} + +// pai::ios::welllog::WelllogCurve & CObjWellLog::GetLogCurve() +// { +// return m_logCurve; +// } + +float CObjWellLog::GetPropertyMax() +{ + return m_fPropertMax; +} + +void CObjWellLog::ReCalculateMinMax() +{ + _CalculateMinMax(true); +} +void CObjWellLog::_CalculateMinMax(bool force) +{ + if( m_fPropertMin < m_fPropertMax && force == false) return; + + if(!m_vMD.size()) { + return; + } + if( m_vProperty.size() ) + { + double val=0; + int size=m_vProperty.size(); + m_fPropertMin =99999999999.0; + m_fPropertMax =-99999999999.0; + for(int i=0;ival) m_fPropertMin=val;//m_vProperty.m_vProperty[i]; + if(m_fPropertMax wellLogTracks; + // this->GetChildren(wellLogTracks); + // for(int j=0;j(wellLogTracks[j]); + // if(tempWellLog) { + // tempWellLog->SetSlfFileName(filePath); + // } + // } +} + +QString CObjWellLog::GetSlfFileName() +{ + return m_SlfFileName; +} + +QUuid CObjWellLog::GetTypeID()const +{ + return GetClassID_WellLog(); +} + +void CObjWellLog::SetBelongID() +{ + // pai::objectmodel::PaiObject* paiWelllogRound = this->GetForebear(GetClassID_WellLogRound()); + // if(paiWelllogRound) + // { + // pai::datamodel::CObjWelllogRound *currentWelllogRound= dynamic_cast(paiWelllogRound); + // if(currentWelllogRound) + // { + // pai::ios::welllog::DataObject* dbWelllogRound = currentWelllogRound->GetDbObject(); + // if(dbWelllogRound) + // { + // m_logCurve.SetDataBelongID(dbWelllogRound->GetDataID()); + // } + // } + // } +} + +void CObjWellLog::SetShiftBottomDepth( double bottomDepth ) +{ + m_ShiftBottomDepth=bottomDepth; +} + +void CObjWellLog::SetShiftTopDepth( double topDepth ) +{ + m_ShiftTopDepth=topDepth; +} + +void CObjWellLog::SetBottomDepth( double bottomDepth ) +{ + m_BottomDepth=bottomDepth; +} + +void CObjWellLog::SetTopDepth( double topDepth ) +{ + m_TopDepth=topDepth; +} + +void CObjWellLog::SetpropertyMin( float Propertymin ) +{ + m_fPropertMin= Propertymin; +} + +void CObjWellLog::SetpropertyMax( float Propertymax ) +{ + m_fPropertMax=Propertymax; +} + +// bool CObjWellLog::Serialize( CObjectArchive &ar ) +// { +// if(ar.IsStoring()) +// { +// BEGIN_WRITE_OBJECT( ar,1 ); + +// BEGIN_WRITE_BLOCK( ar, 1); +// ar << HasFlag(PaiObject::VisibibleOnTree); +// ar <> visible; +// SetFlagEnable(PaiObject::VisibibleOnTree, visible); +// ar >>m_SlfFileName; + +// CBaseObjectImpl::Serialize( ar ); +// ar >>m_fPropertMin; +// ar >>m_fPropertMax; +// ar >>m_TopDepth; +// ar >>m_BottomDepth; + +// QString strtmp; + +// ar >>strtmp;m_logCurve.SetCurveAlias(strtmp.toStdString()); +// ar >>strtmp;m_logCurve.SetFamilyType(strtmp.toStdString()); +// ar >>strtmp;m_logCurve.SetUnit(strtmp.toStdString()); +// float tmpfloat; +// ar >>tmpfloat;m_logCurve.SetSampleInterval(tmpfloat); + +// END_READ_BLOCK( 1 ); + +// END_READ_OBJECT( ar ); +// } +// return true; +// } +void CObjWellLog::GetValidMDProperty( PFLOATPROPERTY &vMD,PFLOATPROPERTY &vProperty,float sdep,float edep) +{ + if(m_SlfFileName=="") return; + if(sdep>=edep){ + if(sdep!=-99999) return; + } + isRun=true; + QString name=m_SlfFileName+GetName(); + if(key!=name) { + vMD.SetSize(0); + vMD.m_vProperty=0; + vProperty.SetSize(0); + vProperty.m_vProperty=NULL; + if(IsMappingMem(key.toStdString().c_str())) + { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + key=""; + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; + return; + } + int curveindex=logio->OpenCurve(GetName().toStdString().c_str()); + if(curveindex<0) + { + delete logio; + return; + } + Slf_CURVE acurveinfo; + logio->GetCurveInfo(curveindex,&acurveinfo); + if(acurveinfo.DepLevel==0) { + acurveinfo.DepLevel=0.125; + logio->DiscardObject(curveindex); + delete logio; + return; + } + m_ObjectType=CURVE_OBJECT; + int samplenum=(acurveinfo.EndDepth-acurveinfo.StartDepth)/acurveinfo.DepLevel+1.5; + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + key=name; + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,3*sizeof(float)+sizeof(int)+acurveinfo.CodeLen*(samplenum+1),name.toStdString().c_str()); + if(!m_Handle||!m_SharedMemory) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + key=""; + return; + } + float *buffer=(float*)m_SharedMemory; + buffer[0]=acurveinfo.StartDepth; + buffer[1]=acurveinfo.EndDepth; + buffer[2]=acurveinfo.DepLevel; + ((int *)buffer)[3]=samplenum; + logio->ReadCurve(curveindex,acurveinfo.StartDepth,samplenum,(void *)&buffer[4]); + if(acurveinfo.MaxValue==acurveinfo.MinValue||acurveinfo.MaxValue==-99999||acurveinfo.MaxValue==-9999||acurveinfo.MinValue==999999||acurveinfo.MinValue==999999||acurveinfo.MinValue==99999||acurveinfo.MinValue==99999||acurveinfo.MinValue==-9999) + { + if(acurveinfo.MaxValue==acurveinfo.MinValue||acurveinfo.MaxValue==-99999||acurveinfo.MaxValue==-9999||acurveinfo.MinValue==999999||acurveinfo.MinValue==999999||acurveinfo.MinValue==99999||acurveinfo.MinValue==99999||acurveinfo.MinValue==-9999) + { + ReCalculateMinMax(); + acurveinfo.MaxValue=m_fPropertMax; + acurveinfo.MinValue=m_fPropertMin; + logio->SetCurveInfo(curveindex,&acurveinfo); + } + } + delete logio; + } + + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + if(IsMappingMem(name.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + delete logio; + vMD.SetSize(0); + vMD.m_vProperty=0; + vProperty.SetSize(0); + vProperty.m_vProperty=NULL; + key=""; + return; + } + int curveindex=logio->OpenCurve((char *)GetName().toStdString().c_str()); + if(curveindex<0) { + if(IsMappingMem(name.toStdString().c_str())) + { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + delete logio; + vMD.SetSize(0); + vMD.m_vProperty=0; + vProperty.SetSize(0); + vProperty.m_vProperty=NULL; + key=""; + return; + } + logio->GetCurveInfo(curveindex,&acurveinfo); + delete logio; + vMD.clear(); + vProperty.clear(); + vMD.SetSize(3); + int samplenum=(acurveinfo.EndDepth-acurveinfo.StartDepth)/acurveinfo.DepLevel+1.5; + if(!m_SharedMemory) + { + m_SharedMemory=NULL; + m_Handle=NULL; + int len=3*sizeof(float)+sizeof(int)+acurveinfo.CodeLen*(samplenum+1); + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,len,key.toStdString().c_str()); + } + else { + vMD.m_vProperty=(float *)m_SharedMemory; + if(m_vMD.m_vProperty) + { + int samplenum1=(m_vMD.m_vProperty[1]-m_vMD.m_vProperty[0])/m_vMD.m_vProperty[2]+1.5; + if(samplenum1==samplenum){ + m_vMD.m_vProperty[0]=acurveinfo.StartDepth; + m_vMD.m_vProperty[1]=acurveinfo.EndDepth; + m_vMD.m_vProperty[2]=acurveinfo.DepLevel; + } + else { + isLoad=false; + LoadFromSLF(); + vMD.m_vProperty=(float *)m_SharedMemory; + m_vProperty.m_vProperty=&m_vMD.m_vProperty[4]; + } + } + } + if(!vMD.m_vProperty) { + vMD.SetSize(0); + vProperty.SetSize(0); + vProperty.m_vProperty=NULL; + if(IsMappingMem(name.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + key=""; + return; + } + int size=((int *)m_SharedMemory)[3]; + vProperty.SetSize(size); + vProperty.m_vProperty=&vMD.m_vProperty[4]; + if(m_vMD.size()>0){ + m_TopDepth=m_vMD.m_vProperty[0]; + m_BottomDepth=m_vMD.m_vProperty[1]; + m_Rlev=m_vMD.m_vProperty[2]; + } +} + +void CObjWellLog::MoveShift() +{ + MoveShift(m_ShiftTopDepth,m_ShiftBottomDepth,m_DepthOffset); +} +void CObjWellLog::EShiftDepth(int count,float *sdeps,float *edeps) +{ + if(m_SlfFileName=="") return; + CMemRdWt * logio=new CMemRdWt(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + return; + } + + int curveindex=logio->FindObjectName((char*)GetName().toStdString().c_str()); + if(curveindex<0) + { + delete logio; + return; + } + CString szBuffer1=""; + CString szBuffer=""; + for(int i=0;iEShiftDepth((char*)GetName().toStdString().c_str(),2,sdeps,edeps); + delete logio; + if(isRun) { + isLoad=false; + LoadFromSLF(); + } +} +void CObjWellLog::MoveShift(float sdep,float edep,float delta) +{ + if(sdep>=edep&&delta==0) return; + if(m_SlfFileName=="") return; + CMemRdWt * logio=new CMemRdWt(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + return; + } + + int curveindex=logio->FindObjectName((char*)GetName().toStdString().c_str()); + if(curveindex<0) + { + delete logio; + return; + } + CString szBuffer=""; + + if(sdep==edep&&sdep==-9999.0) { + szBuffer=QString::number(delta,'f',3)+"\r\n"; + WriteShiftMessage(*logio,szBuffer,GetName()); + logio->CorrectObjectDepth(curveindex,delta); + delete logio; + if(isRun) { + isLoad=false; + LoadFromSLF(); + } + return; + } + curveindex=logio->OpenChannel(GetName().toStdString().c_str()); + if(curveindex>-1) { + szBuffer.Format("%10.3f %10.3f %10.3f\r\n",sdep,edep,delta); + WriteShiftMessage(*logio,szBuffer,GetName()); + logio->MoveDepth(curveindex,sdep,edep,delta); + } + else { + int ObjectType=logio->GetObjectType(GetName().toStdString().c_str()); + float sdeps[2],edeps[2]; + sdeps[0]=sdep; + edeps[0]=sdep+delta; + sdeps[1]=edep; + edeps[1]=edep+delta; + szBuffer.Format("%10.3f %10.3f\r\n%10.3f %10.3f\r\n",sdeps[0],edeps[0],sdeps[1],edeps[1]); + WriteShiftMessage(*logio,szBuffer,GetName()); + if(ObjectType >CARD_OBJECT||ObjectType==0) + { + int index=logio->OpenTable(GetName().toStdString().c_str()); + if(index>-1) + { + logio->EShiftTableDepth((char*)GetName().toStdString().c_str(),2,sdeps,edeps); + } + } + else if(ObjectType==CARD_OBJECT) { + logio->EshiftStreamDepth((char *)GetName().toStdString().c_str(),2,sdeps,edeps); + } + } + delete logio; + if(isRun) { + isLoad=false; + LoadFromSLF(); + } +} + +void CObjWellLog::GetZoneMDProperty( FLOATPROPERTY &vMD,FLOATPROPERTY &vProperty ,float sdep,float edep) +{ + if(!m_vMD.size()) { + GetValidMDProperty(m_vMD,m_vProperty,-99999,99999); + } + if(m_vMD.size()<3) return; + if(edep==99999) edep=m_vMD.m_vProperty[1]; + if(sdep==-99999) sdep=m_vMD.m_vProperty[0]; + int size=(edep-sdep)/m_vMD.m_vProperty[2]+1.5; + vProperty.SetSize(size); + int j=(sdep-m_vMD.m_vProperty[0])/m_vMD.m_vProperty[2]; + int i=0; + if(j<0) { + i=(m_vMD.m_vProperty[0]-sdep)/m_vMD.m_vProperty[2]; + j=0; + } + if(j>=m_vProperty.size()) return; + if(edep>m_vMD.m_vProperty[1]) edep=m_vMD.m_vProperty[1]; + int jj=(edep-m_vMD.m_vProperty[0])/m_vMD.m_vProperty[2]; + if(jj<=0) return; + + vMD.SetSize(3); + vMD.m_vProperty[0]=sdep; + vMD.m_vProperty[1]=edep; + vMD.m_vProperty[2]=m_vMD.m_vProperty[2]; + if(acurveinfo.RepCode==REPR_FLOAT) { + memmove(&vProperty.m_vProperty[i],&m_vProperty.m_vProperty[j],sizeof(float)*(jj-j)); + } + else { + for(int k=j;k=200) repLen=199; + if(repLen>0) { + memmove(m_strValue,buffer,repLen); + m_strValue[repLen]=0; + } + else m_strValue[0]=0; + break; + } + return yy; +} +void CObjWellLog::SetData(int repCode,char *buffer,double yy) +{ + if(!buffer) + { + return; + } + switch(repCode) + { + case REPR_INT: //0 + (*((int*)buffer))=(int)yy; + break; + case REPR_SHORT: //1 + (*((short *)buffer))=(short)yy; + break; + case REPR_LONG://2 + (*((long *)buffer))=(long)yy; + break; + case REPR_FLOAT://3 + (*((float *)buffer))=yy; + break; + case REPR_DOUBLE://4 + (*((double *)buffer))=(double)yy; + break; + case REPR_CHAR://5 + (*((char *)buffer))=(char)yy; + break; + case REPR_UCHAR://6 + (*((unsigned char *)buffer))=(unsigned char)yy; + break; + case REPR_USHORT://7 + (*((unsigned short *)buffer))=(unsigned short)yy; + break; + case REPR_UINT://8 + (*((unsigned int *)buffer))=(unsigned int)yy; + break; + case REPR_ULONG://9 + (*((unsigned long *)buffer))=(unsigned long )yy; + break; + case REPR_STRING://10 + // *yy=-99999; + break; + } + return; +} +double CObjWellLog::GetData(float dep,char *buffer) +{ + if(dep>=acurveinfo.StartDepth&&dep<=acurveinfo.EndDepth) { + int i=(dep-acurveinfo.StartDepth)/acurveinfo.DepLevel+0.5; + double yy=GetData(i,buffer); + return yy; + } + else { + if(acurveinfo.RepCode==REPR_STRING&&buffer) buffer[0]=0; + return -9999; + } +} + +double CObjWellLog::GetData(int i,char *buffer) +{ + if(!m_vProperty.size()) return -9999; + if(!m_vProperty.m_vProperty) return -9999; + double yy=-9999; + if(m_vProperty.size()>i) { + yy=GetData(acurveinfo.RepCode,(char *)&((char *)m_vProperty.m_vProperty)[i*acurveinfo.CodeLen],acurveinfo.CodeLen); + } + if(acurveinfo.RepCode==REPR_STRING&&buffer) strcpy(buffer,m_strValue); + return yy; +} +void CObjWellLog::SetData(float dep,float *value) +{ + if(dep>=acurveinfo.StartDepth&&dep<=acurveinfo.EndDepth) { + int i=(dep-acurveinfo.StartDepth)/acurveinfo.DepLevel+0.5; + SetData(i,value); + } +} +void CObjWellLog::SetData(float dep,float value) +{ + if(dep>=acurveinfo.StartDepth&&dep<=acurveinfo.EndDepth) { + int i=(dep-acurveinfo.StartDepth)/acurveinfo.DepLevel+0.5; + SetData(i,&value); + } +} +void CObjWellLog::SetData(int i,float *value) +{ + if(!m_vProperty.m_vProperty) return; + if(acurveinfo.RepCode!=REPR_STRING) { + double val=*value; + SetData(acurveinfo.RepCode,&((char *)m_vProperty.m_vProperty)[i*acurveinfo.CodeLen],val); + } + else { + memmove(&((char *)m_vProperty.m_vProperty)[i*acurveinfo.CodeLen],value,acurveinfo.CodeLen); + } +} + +void CObjWellLog::GetMDProperty(FLOATPROPERTY &vMD,FLOATPROPERTY &vProperty) +{ + if(!m_vMD.size()) { + GetValidMDProperty(m_vMD,m_vProperty,-99999,99999); + } + if(m_vMD.size()<3) return; + vMD.SetSize(m_vMD.size()); + vProperty.SetSize(m_vProperty.size()); + if(acurveinfo.RepCode==REPR_FLOAT) { + memmove(vProperty.m_vProperty,m_vProperty.m_vProperty,sizeof(float)*m_vProperty.size()); + } + else { + for(int k=0;k( pParent ); + // if( pWell ) { + // m_pObjWell=pWell; + // return pWell; + // } + // pParent = pParent->GetParent(); + // } + + return NULL; +} +CObjWelllogRound *CObjWellLog::GetWelllogRound() +{ + // PaiObject *pParent = GetParent(); + // while( pParent ) + // { + // CObjWelllogRound *pWellRound = dynamic_cast( pParent ); + // if( pWellRound ) return pWellRound; + + // pParent = pParent->GetParent(); + // } + + return NULL; +} + +double CObjWellLog::GetShiftTopDepth() +{ + return m_ShiftTopDepth; +} + +double CObjWellLog::GetShiftBottomDepth() +{ + return m_ShiftBottomDepth; +} + +double CObjWellLog::GetTopDepth() +{ + return m_TopDepth; +} + +double CObjWellLog::GetBottomDepth() +{ + return m_BottomDepth; +} + +PFLOATPROPERTY &CObjWellLog::GetProperty( ) +{ + if(!m_vProperty.size()) + { + m_vMD.clear(); + m_vProperty.clear(); + GetValidMDProperty(m_vMD,m_vProperty,-99999.0,99999.0); + } + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + if(IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + key=""; + } + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + m_TopDepth=0; + m_BottomDepth=0; + return m_vProperty; + } + QString name=m_SlfFileName+GetName(); + int index=logio->FindObjectName((char *)GetName().toStdString().c_str()); + if(index<0) { + if(IsMappingMem(name.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + key=""; + } + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + m_TopDepth=0; + m_BottomDepth=0; + return m_vProperty; + } + delete logio; + if(!IsMappingMem(name.toStdString().c_str())) { + isLoad=false; + LoadFromSLF(); + } + if(m_vMD.size()>0&&m_TopDepth!=m_vMD.m_vProperty[0]){ + m_TopDepth=m_vMD.m_vProperty[0]; + m_BottomDepth=m_vMD.m_vProperty[1]; + m_Rlev=m_vMD.m_vProperty[2]; + } + return m_vProperty; +} + +PFLOATPROPERTY &CObjWellLog::GetMD( ) +{ + if(!m_vMD.size()) { + GetValidMDProperty(m_vMD,m_vProperty,-99999.0,99999.0); + } + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + if(IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + key=""; + } + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + m_TopDepth=0; + m_BottomDepth=0; + return m_vProperty; + } + QString name=m_SlfFileName+GetName(); + int index=logio->FindObjectName((char *)GetName().toStdString().c_str()); + if(index<0) { + if(IsMappingMem(name.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + key=""; + } + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + m_TopDepth=0; + m_BottomDepth=0; + return m_vProperty; + } + logio->GetCurveInfo(index,&acurveinfo); + delete logio; + if(!IsMappingMem(name.toStdString().c_str())) { + isLoad=false; + LoadFromSLF(); + } + if(m_vMD.size()>0&&m_TopDepth!=m_vMD.m_vProperty[0]){ + m_TopDepth=m_vMD.m_vProperty[0]; + m_BottomDepth=m_vMD.m_vProperty[1]; + m_Rlev=m_vMD.m_vProperty[2]; + } + return m_vMD; +} +void CObjWellLog::SetProperty(PFLOATPROPERTY *vMD,PFLOATPROPERTY *vProperty ) +{ + if(m_vProperty.m_vProperty!=vProperty->m_vProperty) { + if(m_vProperty.size()!=vProperty->size()) + { + m_vProperty.SetSize(vProperty->size()); + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,vMD->size()*sizeof(float)+sizeof(int)+(vProperty->size()+1)*sizeof(float),key.toStdString().c_str()); + } + m_vProperty.m_vProperty=&((float*)m_SharedMemory)[4]; + memmove(m_vProperty.m_vProperty,vProperty->m_vProperty,sizeof(float)*vProperty->size()); + } + SetMD(vMD); + // SetModified(true,false); + SaveToSLF(); +} +void CObjWellLog::SetProperty(PFLOATPROPERTY *vMD,FLOATPROPERTY *vProperty ) +{ + if(m_vProperty.m_vProperty!=vProperty->m_vProperty) { + if(m_vProperty.size()!=vProperty->size()) + { + m_vProperty.SetSize(vProperty->size()); + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,vMD->size()*sizeof(float)+sizeof(int)+(vProperty->size()+1)*sizeof(float),key.toStdString().c_str()); + } + m_vProperty.m_vProperty=&((float*)m_SharedMemory)[4]; + memmove(m_vProperty.m_vProperty,vProperty->m_vProperty,sizeof(float)*vProperty->size()); + } + SetMD(vMD); + // SetModified(true,false); + SaveToSLF(); +} + +void CObjWellLog::SetMD(PFLOATPROPERTY *vMD ) +{ + if(m_vMD.m_vProperty!=vMD->m_vProperty) { + if(m_vMD.m_vProperty) { + memmove(m_vMD.m_vProperty,vMD->m_vProperty,sizeof(float)*vMD->size()); + } + } +} + +void CObjWellLog::SetProperty(FLOATPROPERTY *vMD,FLOATPROPERTY *vProperty ) +{ + if(m_vProperty.m_vProperty!=vProperty->m_vProperty) { + if(m_vProperty.size()!=vProperty->size()) + { + m_vProperty.SetSize(vProperty->size()); + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,vMD->size()*sizeof(float)+sizeof(int)+(vProperty->size()+1)*sizeof(float),key.toStdString().c_str()); + } + m_vProperty.m_vProperty=&((float*)m_SharedMemory)[4]; + memmove(m_vProperty.m_vProperty,vProperty->m_vProperty,sizeof(float)*vProperty->size()); + } + SetMD(vMD); + // SetModified(true,false); + SaveToSLF(); +} + +void CObjWellLog::SetMD(FLOATPROPERTY *vMD ) +{ + if(m_vMD.m_vProperty!=vMD->m_vProperty) { + if(m_vMD.m_vProperty) { + memmove(m_vMD.m_vProperty,vMD->m_vProperty,sizeof(float)*vMD->size()); + } + } +} + +pai::ios::welllog::DataObject *CObjWellLog::GetDbObject() +{ + // if(m_SlfFileName==""){ + // SetBelongID(); + // return &m_logCurve; + // } + // else //slf文件存储的情况下，不存到数据库 + return NULL; +} + +QVariant CObjWellLog::GetTemplateKey() +{ + QVariant val; + return val; + //TODO + //增加了一级分类，templatekey需要增加这个 +// QVariant val=CBaseObject::GetTemplateKey(); +// QString sTemplateKey=val.toString(); +// int i=sTemplateKey.lastIndexOf("/"); +// if(i<0) { +// /* QString left; +// QString curvename=GetName(); +// if(i>-1) left=sTemplateKey.left(i)+"/"+curvename; +// else left=sTemplateKey+"/"+curvename; +// SetTemplateKey(left); +// val=left; +// */ +// QString categoryName=""; +// if(!GetParent()) return categoryName; +// if(GetParent()->GetTypeID()!=GetClassID_Well()&&GetParent()->GetTypeID()!=GetClassID_WellLogRound()) categoryName=this->GetParent()->GetName(); +// if(categoryName!="") categoryName=categoryName.append("/"); +// if(GetGhostName()!="") categoryName=categoryName+GetGhostName(); +// else categoryName=categoryName+GetName(); +// SetTemplateKey(categoryName); +// val=categoryName; +// } +// return val; +} + +CBaseObject *CObjWellLog::CloneObject() +{ + // CBaseObject * result=CBaseObject::CloneObject(); + // CObjWellLog * pCopyedWellLog = dynamic_cast(result); + // if(pCopyedWellLog) pCopyedWellLog->SetWell(m_pObjWell); + // return pCopyedWellLog; + return NULL; +} + +QStringList CObjWellLog::GetColumnHeadList() +{ + QStringList strlist; + strlist<<"深度值"<<"属性值"; + return strlist; +} + +//从slf加载数据 +bool CObjWellLog::LoadFromSLF() +{ + if(m_SlfFileName=="") { + if(!key.isEmpty()&&IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + key=""; + } + return true; + } + isRun=true; + if(!key.isEmpty()&&IsMappingMem(key.toStdString().c_str())) + { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + key=""; + } + QString name=m_SlfFileName+GetName(); + if(IsMappingMem(name.toStdString().c_str())) + { + // GetObjectEvent().OnDeAttchData(m_SlfFileName,GetName()); + } + m_SharedMemory=NULL; + m_Handle=NULL; + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + return false; + } + + int curveindex=logio->OpenCurve(GetName().toStdString().c_str()); + if(curveindex<0) + { + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + return false; + } + m_ObjectType=CURVE_OBJECT; + logio->GetCurveInfo(curveindex,&acurveinfo); + int samplenum=(acurveinfo.EndDepth-acurveinfo.StartDepth)/acurveinfo.DepLevel+1.5; + if(acurveinfo.DepLevel==0) { + acurveinfo.DepLevel=0.125; + logio->DiscardObject(curveindex); + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + return false; + } + key=name; + int len=3*sizeof(float)+sizeof(int)+acurveinfo.CodeLen*(samplenum+1); + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,len,key.toStdString().c_str()); + if(!m_Handle||!m_SharedMemory) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,3*sizeof(float)+sizeof(int)+acurveinfo.CodeLen*(samplenum+1),key.toStdString().c_str()); + if(!m_Handle||!m_SharedMemory) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + return false; + } + } + float *buffer=(float*)m_SharedMemory; + buffer[0]=acurveinfo.StartDepth; + buffer[1]=acurveinfo.EndDepth; + buffer[2]=acurveinfo.DepLevel; + ((int *)buffer)[3]=samplenum; + logio->ReadCurve(curveindex,acurveinfo.StartDepth,samplenum,(void*)&buffer[4]); + logio->Clear(); + delete logio; + m_vMD.SetSize(3); + m_vMD.m_vProperty=(float *)m_SharedMemory; + int size=((int *)m_SharedMemory)[3]; + m_vProperty.SetSize(size); + m_vProperty.m_vProperty=&m_vMD.m_vProperty[4]; + + if(m_vMD.size()>0){ + m_TopDepth=m_vMD.m_vProperty[0]; + m_BottomDepth=m_vMD.m_vProperty[1]; + m_Rlev=m_vMD.m_vProperty[2]; + } + m_ShiftTopDepth=-9999; + m_ShiftBottomDepth=-9999; + m_DepthOffset=0; + isLoad=true; +// SetModified(false,false); + // GetObjectEvent().OnRefreshData(GetSlfFileName(),GetName(),this); + return true; +} + +//从slf加载数据 +int CObjWellLog::IsObjectExist(QString name) +{ + if(m_SlfFileName=="") return true; + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + return false; + } + + int curveindex=logio->FindObjectName((char *)name.toStdString().c_str()); + delete logio; + return curveindex; +} +bool CObjWellLog::DeleteData(float Stdep,float Endep) +{ + SetModify(true); + SaveToSLF(); + if(m_SlfFileName=="") return true; + isRun=true; + isLoad=false; + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + if(!key.isEmpty()&&IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + return false; + } + int curveindex=logio->OpenCurve(GetName().toStdString().c_str()); + if(curveindex<0) + { + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + if(!key.isEmpty()&&IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + return false; + } + m_ObjectType=CURVE_OBJECT; + logio->GetCurveInfo(curveindex,&acurveinfo); + acurveinfo.StartDepth=Stdep; + acurveinfo.EndDepth=Endep; + int samplenum=(acurveinfo.EndDepth-acurveinfo.StartDepth)/acurveinfo.DepLevel+1.5; + QString name=m_SlfFileName+GetName(); + if(acurveinfo.DepLevel==0) { + acurveinfo.DepLevel=0.125; + logio->DiscardObject(curveindex); + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + if(!key.isEmpty()&&IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + return false; + } + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + if(IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,3*sizeof(float)+sizeof(int)+acurveinfo.CodeLen*(samplenum+1),key.toStdString().c_str()); + if(!m_Handle||!m_SharedMemory) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,3*sizeof(float)+sizeof(int)+acurveinfo.CodeLen*(samplenum+1),key.toStdString().c_str()); + if(!m_Handle||!m_SharedMemory) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + return false; + } + } + float *buffer=(float*)m_SharedMemory; + buffer[0]=acurveinfo.StartDepth; + buffer[1]=acurveinfo.EndDepth; + buffer[2]=acurveinfo.DepLevel; + ((int *)buffer)[3]=samplenum; + logio->ReadCurve(curveindex,acurveinfo.StartDepth,samplenum,(void*)&buffer[4]); + logio->CloseCurve(curveindex); + logio->DiscardObject(curveindex); + curveindex=logio->CreateCurve(&acurveinfo); + if(curveindex>-1) logio->WriteCurve(curveindex,acurveinfo.StartDepth,samplenum,(void*)&buffer[4]); + logio->Clear(); + delete logio; + m_vMD.SetSize(3); + m_vMD.m_vProperty=(float *)m_SharedMemory; + int size=((int *)m_SharedMemory)[3]; + m_vProperty.SetSize(size); + m_vProperty.m_vProperty=&m_vMD.m_vProperty[4]; + + if(m_vMD.size()>0){ + m_TopDepth=m_vMD.m_vProperty[0]; + m_BottomDepth=m_vMD.m_vProperty[1]; + m_Rlev=m_vMD.m_vProperty[2]; + } + isLoad=true; + // SetModified(false,false); + return true; +} + +bool CObjWellLog::ExpendData(bool ishead,float Depth) +{ +// SetModify(true); +// SaveToSLF(); + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + if(m_SlfFileName=="") { + if(!key.isEmpty()&&IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + return true; + } + isLoad=false; + isRun=true; + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + if(!key.isEmpty()&&IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + return false; + } + + int curveindex=logio->OpenCurve(GetName().toStdString().c_str()); + if(curveindex<0) + { + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + if(!key.isEmpty()&&IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + return false; + } + m_ObjectType=CURVE_OBJECT; + logio->GetCurveInfo(curveindex,&acurveinfo); + if(ishead) acurveinfo.StartDepth=Depth; + else acurveinfo.EndDepth=Depth; + if(acurveinfo.EndDepthDiscardObject(curveindex); + delete logio; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + if(!key.isEmpty()&&IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + return false; + } + int samplenum=(acurveinfo.EndDepth-acurveinfo.StartDepth)/acurveinfo.DepLevel+1.5; + QString name=m_SlfFileName+GetName(); + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + if(IsMappingMem(key.toStdString().c_str())) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + } + // GetObjectEvent().OnDeAttchData(GetSlfFileName(),GetName()); + while(IsMappingMem(key.toStdString().c_str())) { + QCoreApplication::processEvents(); + } + key=name; + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,3*sizeof(float)+sizeof(int)+acurveinfo.CodeLen*samplenum,key.toStdString().c_str()); + if(!m_Handle||!m_SharedMemory) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + MappingMem(&m_Handle,(LPSTR*)&m_SharedMemory,3*sizeof(float)+sizeof(int)+acurveinfo.CodeLen*(samplenum+1),key.toStdString().c_str()); + if(!m_Handle||!m_SharedMemory) { + CloseView(m_Handle,m_SharedMemory); + m_SharedMemory=NULL; + m_Handle=NULL; + m_vMD.SetSize(0); + m_vMD.m_vProperty=0; + m_vProperty.SetSize(0); + m_vProperty.m_vProperty=NULL; + return false; + } + } + float *buffer=(float*)m_SharedMemory; + buffer[0]=acurveinfo.StartDepth; + buffer[1]=acurveinfo.EndDepth; + buffer[2]=acurveinfo.DepLevel; + ((int *)buffer)[3]=samplenum; + logio->ReadCurve(curveindex,acurveinfo.StartDepth,samplenum,(void*)&buffer[4]); + logio->Clear(); + delete logio; + m_vMD.SetSize(3); + m_vMD.m_vProperty=(float *)m_SharedMemory; + int size=((int *)m_SharedMemory)[3]; + m_vProperty.SetSize(size); + m_vProperty.m_vProperty=&m_vMD.m_vProperty[4]; + + if(m_vMD.size()>0){ + m_TopDepth=m_vMD.m_vProperty[0]; + m_BottomDepth=m_vMD.m_vProperty[1]; + m_Rlev=m_vMD.m_vProperty[2]; + } + // SetModified(false,false); + isLoad=true; + return true; +} +//数据变化后写入slf数据 + bool CObjWellLog::SaveToSLF() + { + bool m=false;//HasModified(); + if(!m) return false; + int samplenum=m_vProperty.size(); + if(!m_vMD.size()) return false; + if(samplenum<=0) return false; + if(m_SlfFileName=="") return true; + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeRead)) + { + delete logio; + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + return false; + } + + int curveindex=logio->OpenCurve(GetName().toStdString().c_str()); + if(curveindex<0) + { + delete logio; + return false; + } + if(samplenum)logio->WriteCurve(curveindex,m_vMD.m_vProperty[0],samplenum,(void*)(&m_vProperty.m_vProperty[0])); + delete logio; + //qDebug()<Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeReadWrite)) + { + delete logio; + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + return false; + }; + short curvetype=logio->GetObjectType(GetName().toStdString().c_str()); + if(curvetype==CURVE_OBJECT||curvetype==WAVE_OBJECT) + { + Slf_CURVE info; + int index=-1; + if(curvetype==CURVE_OBJECT) index=logio->OpenCurve(GetName().toStdString().c_str()); + else index=logio->OpenWave(GetName().toStdString().c_str()); + logio->GetCurveInfo(index,&info); + unsigned char cs[4]={0xcd,0xcd,0xcd,0xcd}; + unsigned char cs1[4]={0x0,204,204,204}; + unsigned char cs2[4]={204,204,204,204}; + float va=*(float*)&cs; + float va1=*(float*)&cs1; + float va2=*(float*)&cs2; + if(info.DepLevel==0||info.DepLevel==va||info.DepLevel==va1||info.DepLevel==va2|| + info.StartDepth==va||info.EndDepth==va1||info.EndDepth==va2) + { + logio->DeleteObject(GetName().toStdString().c_str()); + delete logio; + return true; + } + } + logio->DiscardObject(GetName().toStdString().c_str()); + delete logio; + //TODO 删掉克隆的对象 +} + + //将内存数据清空 + void CObjWellLog::clearData() + { + FLOATPROPERTY nulldata; + SetMD(&nulldata); + SetProperty(&nulldata,&nulldata); +} +void CObjWellLog::ChangeDepth(double DepthOffset) +{ + //1.修改内存数据 + if(m_vMD.size()) { + m_vMD.m_vProperty[0]+=DepthOffset; + m_vMD.m_vProperty[1]+=DepthOffset; + } + m_TopDepth+=DepthOffset; + m_BottomDepth+=DepthOffset; +} +void CObjWellLog::ApplyShiftDepth() +{ + //1.修改内存数据 + ChangeDepth(m_DepthOffset); + if(m_SlfFileName=="") return ; + CMemRdWt * logio=new CMemRdWt(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeReadWrite)) + { + delete logio; + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + return ; + }; + bool isok=0; + //TODO 目前对于表格类，参数卡类不支持,会崩溃 + int curveindex=logio->FindObjectName((char *)GetName().toStdString().c_str()); + if(curveindex>=0) { + CString szBuffer=""; + szBuffer=QString::number(m_DepthOffset,'f',3)+"\r\n"; + WriteShiftMessage(*logio,szBuffer,GetName()); + logio->CorrectObjectDepth(curveindex,m_DepthOffset); + isok=1; + } + logio->GetCurveInfo(curveindex,&acurveinfo); + delete logio; + m_DepthOffset = 0; + if(isRun&&isok) { + isLoad=false; + LoadFromSLF(); + } + } +void CObjWellLog::loadInfo() +{ + if(m_SlfFileName=="") return ; + CMemRdWt * logio=new CMemRdWt(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeReadWrite)) + { + delete logio; + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + return ; + }; + int curveindex=logio->FindObjectName((char *)GetName().toStdString().c_str()); + if(curveindex>=0) { + logio->GetCurveInfo(curveindex,&acurveinfo); + } + delete logio; +} +void CObjWellLog::AddShiftDepth(double shiftdepth) +{ + m_DepthOffset += shiftdepth; +} +bool CObjWellLog::CloneInSlfFile(QString newname) +{ + if(m_SlfFileName=="") return false; + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeReadWrite)) + { + delete logio; + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + return false; + }; + char* curvename=new char[65]; + curvename[64]='\0'; + strcpy(curvename,GetName().toStdString().c_str()); + char* newcurvename=new char[65]; + newcurvename[64]='\0'; + strcpy(newcurvename,newname.toStdString().c_str()); + logio->CopyObject(curvename,newcurvename,true); + delete[] curvename; + delete[] newcurvename; + delete logio; +} + bool CObjWellLog::CopyToSLFFile(QString targetSLFFileName,bool deleteFromSrc,char*newCurveName) +{ + if(m_SlfFileName=="") return false; + CLogIO a_cslfio; + CLogIO * logio=new CLogIO(); + if(!logio->Open(targetSLFFileName.toStdString().c_str(),CSlfIO::modeReadWrite)) + { + delete logio; + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + return false; + }; + if(!a_cslfio.Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeReadWrite)) + { + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + delete logio; + return false; + }; + char* curvename=new char[65]; + curvename[64]='\0'; + strcpy(curvename,GetName().toStdString().c_str()); + if(newCurveName) logio->CopyFromFile(a_cslfio,curvename,newCurveName); + else logio->CopyFromFile(a_cslfio,curvename); + delete[] curvename; + delete logio; + if(deleteFromSrc) DeleteFromSLF(); +} + +void CObjWellLog::SetName(const QString & name) +{ + QString oldn=GetName(); + if(oldn.compare(name,Qt::CaseInsensitive)==0) return; + m_name = name; + // PaiObject::SetName(name); + if(isRun) { + isLoad=false; + LoadFromSLF(); + } +} +bool CObjWellLog::RenName(const QString & name) +{ + if(isUsing) + return false; + + //将SLF中的对象重命名 + if(m_SlfFileName!="") + { + CSlfIO a_cslfio; + if(!a_cslfio.Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeReadWrite)) + { + m_name = name; + // PaiObject::SetName(name); + if(isRun) { + isLoad=false; + LoadFromSLF(); + } + return true; + }; + if(a_cslfio.RenameObject(GetName().toStdString().c_str(),name.toStdString().c_str())) + { + a_cslfio.Close(); + m_name = name; + // PaiObject::SetName(name); + if(isRun){ + isLoad=false; + LoadFromSLF(); + } + return true; + } + } + return false; + } + +void CObjWellLog::ReSample(double newDelta) +{ + if(m_SlfFileName=="") return ; + CLogIO * logio=new CLogIO(); + if(!logio->Open(m_SlfFileName.toStdString().c_str(),CSlfIO::modeReadWrite)) + { + delete logio; + //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！"); + return ; + }; + bool isok=0; + int curveindex=logio->OpenChannel(GetName().toStdString().c_str()); + if(curveindex>=0) { + logio->ChannelResamples(curveindex,newDelta); + isok=1; + } + delete logio; + m_Rlev=newDelta; + if(isRun&&isok) { + isLoad=false; + LoadFromSLF(); + } +} +//TODO 重构void ImportDataDialog::AutoMatchFamily(WelllogCurve* acurve) +void CObjWellLog::AutoMatchFamily() +{ + return; + // static std::vector familyaliases; + // if(familyaliases.size()<=0){ + // FamilyAliases aAlias; + // aAlias.GetFamilyAliases(familyaliases); + // } + // for(int i=0;i +void AddToWellRound(QString objname,T *aclass,char* ID,int Type) +{ + // CObjWelllogRound *pWelllogRound=dynamic_cast(aclass->GetWelllogRound()); + // if(pWelllogRound) { + // PaiObject*pBase=pWelllogRound->GetObjectByName(objname,ID); + // if(!dynamic_cast(pBase)){ + // CObjWellLog * acurve=new T(); + // if(acurve) { + // acurve->m_ObjectType=Type; + // acurve->SetName(objname); + // acurve->SetAliasName(objname); + // acurve->SetSlfFileName(pWelllogRound->GetSlfFileName()); + // acurve->SetWell(pWelllogRound->GetWell()); + // pWelllogRound->AddChild(acurve); + // } + // } + // } +} +// BEGIN_REGISTER_OBJECT(CObjWellLog) +// QUuid(GetClassID_WellLog()) +// END_REGISTER_OBJECT( CObjWellLog ); + +END_OSGDATAMODEL_NAMESPACE diff --git a/OSGDataModel/src/ObjWellLogTABLE.cpp b/OSGDataModel/src/ObjWellLogTABLE.cpp new file mode 100644 index 0000000..bd0f387 --- /dev/null +++ b/OSGDataModel/src/ObjWellLogTABLE.cpp @@ -0,0 +1,30 @@ +#pragma warning( push ,0) +#include +#include +#include "ObjectID.h" +#include "ObjWelllogTABLE.h" +// #include "ObjWell.h" + +#pragma warning( pop ) + +BEGIN_OSGDATAMODEL_NAMESPACE; + +CObjWellLogTABLE::CObjWellLogTABLE() +{ + // SetIconName("icon/Sheet.png"); +} + +CObjWellLogTABLE::~CObjWellLogTABLE() +{ + +} +QUuid CObjWellLogTABLE::GetTypeID()const +{ + return GetClassID_WellLogTABLE(); +} + +// BEGIN_REGISTER_OBJECT(CObjWellLogTABLE) +// QUuid(GetClassID_WellLogTABLE()) +// END_REGISTER_OBJECT( CObjWellLogTABLE ); + +END_OSGDATAMODEL_NAMESPACE diff --git a/WellLogUI/include/WellLogTableDialogNew.h b/WellLogUI/include/WellLogTableDialogNew.h index 0bec8f5..cd39e95 100644 --- a/WellLogUI/include/WellLogTableDialogNew.h +++ b/WellLogUI/include/WellLogTableDialogNew.h @@ -12,13 +12,14 @@ #include "WellLogUI.h" //#include "Trajectory.h" //#include "WellLogTableModel.h" -//#include "ObjWelllog.h" +#include "ObjWelllog.h" //#include "BaseDialog.h" +#include "LogIO.h" #include "MemRdWt.h" #pragma warning( pop ) //class CDataManagger; -//class GridDataAdapter; +class GridDataAdapter; namespace Ui { @@ -103,7 +104,7 @@ private: Ui::WellLogTableDialogNew* m_pUI; // QList m_rBaseObjectlist; // CObjWell* m_pWell; -// QList m_pWellLogs; + QList m_pWellLogs; // //QList m_pAllWellLogs; // CBaseObjectImpl *m_pBaseObjectImpl; @@ -122,7 +123,7 @@ private: QStringList m_TitleField; dataType m_DataTyle; //luol 20200302 - //GridDataAdapter* m_gridData; + GridDataAdapter* m_gridData; bool m_isShowDig; @@ -133,9 +134,10 @@ public: float *val; DWORD count; float sdep,edep,rlev,curDepth; + int m_ObjectType; public: - void setName(QString strOldPath, QString strOldName); + void setName(QString strOldPath, QString strOldName, int nObjectType); }; #endif /* PAITABLEWIDGET_H_ */ diff --git a/WellLogUI/src/WellLogTableDialogNew.cpp b/WellLogUI/src/WellLogTableDialogNew.cpp index 542d0d4..f9f6a86 100644 --- a/WellLogUI/src/WellLogTableDialogNew.cpp +++ b/WellLogUI/src/WellLogTableDialogNew.cpp @@ -11,12 +11,12 @@ //#include "ui_PaiCoreDialog.h" //#include "ObjCoreImage.h" #include "geometryutils.h" -//#include "ObjWelllog.h" +#include "ObjWelllog.h" #include "LogIO.h" //#include "CurveLineLog.h" -//#include "ObjWelllogTABLE.h" +#include "ObjWelllogTABLE.h" //#include "DataManagger.h" -//#include "griddataadapter.h" +#include "griddataadapter.h" //#include "ConsoleOutputWidget.h" @@ -24,21 +24,21 @@ #include "ShowCurve.h" #include "CurvePropertyEdit.h" #include "CallManage.h" - +#include "ObjectID.h" //float保留4位小数 #define FLOATPREC 4 #define SWITCH_VIEWID "switchId" using namespace std; -Slf_WAVE WaveInfo; +static Slf_WAVE WaveInfo; WellLogTableDialogNew::WellLogTableDialogNew(QWidget *parent, Qt::WindowFlags flags) :QDialog(parent, flags), m_isShowDig(false) { m_pUI = new Ui::WellLogTableDialogNew(); m_pUI->setupUi(this); // //数据局部显示适配器 -// m_gridData = new GridDataAdapter(m_pUI->tableWidget, m_pUI->horizontalScrollBar, m_pUI->verticalScrollBar); + m_gridData = new GridDataAdapter(m_pUI->tableWidget, m_pUI->horizontalScrollBar, m_pUI->verticalScrollBar); // m_pWell = NULL; @@ -98,9 +98,14 @@ void WellLogTableDialogNew::swtichViewSize() QSize size=this->size(); if(isExp) { - int changeSize=size.width()/2.0; + // int changeSize=size.width()/2.0; - spanItem->setMinimumWidth(changeSize); + // spanItem->setMinimumWidth(changeSize); + // spanItem->show(); + + m_pUI->tabWidget->setFixedWidth(0); + spanItem->setMinimumWidth(0); + m_gridData->m_gridWidth=size.width()-10; spanItem->show(); } } @@ -186,11 +191,16 @@ void WellLogTableDialogNew::slotImport() TableFromCSVFile(m_pUI->tableWidget); } -void WellLogTableDialogNew::setName(QString strOldPath, QString strOldName) +void WellLogTableDialogNew::setName(QString strOldPath, QString strOldName, int nObjectType) { FileName = strOldPath; CurveName = strOldName; - + m_ObjectType = nObjectType; + CObjWellLogTABLE* pWellLog = new CObjWellLogTABLE; + pWellLog->SetSlfFileName(strOldPath); + pWellLog->m_name = strOldName; + m_pWellLogs.clear(); + m_pWellLogs.append(pWellLog); //初始化 InitWell(); @@ -211,6 +221,19 @@ void WellLogTableDialogNew::InitWell() // m_gridData->initWellData(D_WellData,m_pWell); // } + if (TABLEE_OBJECT == m_ObjectType) + { + m_gridData->addActonMenu(2); + + m_DataTyle=valid_NULL; + //表格数据 + m_gridData->initTableWellLogData(D_TableWellLogData,m_pWellLogs); + m_pUI->tableWidget->verticalHeader()->hide();//隐藏左侧系统序号栏 + swtichViewSize(); + + return; + } + CLogIO *logio=new CLogIO(); logio->Open(FileName.toStdString().c_str(),CSlfIO::modeRead); index=logio->OpenCurve(CurveName.toStdString().c_str()); @@ -261,13 +284,18 @@ void WellLogTableDialogNew::InitWell() QTableWidgetItem* item2 = new QTableWidgetItem(QString::number(vtmp)); //item2->setFlags(item2->flags() & (~Qt::ItemIsEditable)); m_pUI->tableWidget->setItem(i, 1, item2); - - } } bool WellLogTableDialogNew::InitWellLog() { + if (TABLEE_OBJECT == m_ObjectType) + { + //表格数据 + m_gridData->bindData(); + return true; + } + //swtichViewSize(); int Type=0; //if(TypeName=="波列数据")Type=1; diff --git a/WellLogUI/src/WellLogUI.pro b/WellLogUI/src/WellLogUI.pro index 39ab812..501bf5c 100644 --- a/WellLogUI/src/WellLogUI.pro +++ b/WellLogUI/src/WellLogUI.pro @@ -59,6 +59,7 @@ FORMS += \ HEADERS += \ ../../common/geometryutils.h \ ../CallManage/CallManage.h \ + ../include/CStringType.h \ ../include/MyWelllogRound.h \ ../include/WellDialog.h \ ../include/WellLogDialog.h \ @@ -67,11 +68,14 @@ HEADERS += \ ../include/WellLogRoundDialog.h \ ../include/WellLogTableDialogNew.h \ ../include/WellLogUI.h \ + ../include/assetcopy.h \ + ../include/griddataadapter.h \ AngleAdjTool.h \ CurvePropertyEdit.h \ DrawCurveView.h \ ShowCurve.h \ SmoothTool.h \ + TipPop.h \ deptlineedit.h \ editEnd.h @@ -79,27 +83,40 @@ SOURCES += \ ../../common/geometryutils.cpp \ ../CallManage/CallManage.cpp \ AngleAdjTool.cpp \ + CStringType.cpp \ CurvePropertyEdit.cpp \ DrawCurveView.cpp \ MyWelllogRound.cpp \ ShowCurve.cpp \ SmoothTool.cpp \ + TipPop.cpp \ WellDialog.cpp \ WellLogDialog.cpp \ WellLogLabel.cpp \ WellLogProjectDialog.cpp \ WellLogRoundDialog.cpp \ WellLogTableDialogNew.cpp \ + assetcopy.cpp \ deptlineedit.cpp \ - editEnd.cpp + editEnd.cpp \ + griddataadapter.cpp INCLUDEPATH += ../include INCLUDEPATH += ../CallManage INCLUDEPATH += ../../Slfio/include INCLUDEPATH += ../../common +INCLUDEPATH += ../../BaseFun/include +INCLUDEPATH += ../../OSGDataModel/include +INCLUDEPATH += ../../DataMgr/include CONFIG(debug, debug|release){ LIBS += -L../../Bin -lslfiod + LIBS += -L../../Bin -lBaseFund + LIBS += -L../../Bin -lOSGDataModeld + LIBS += -L../../Bin -lDataMgrd } else { LIBS += -L../../Bin -lslfio + LIBS += -L../../Bin -lBaseFun + LIBS += -L../../Bin -lOSGDataModel + LIBS += -L../../Bin -lDataMgr } diff --git a/logPlus/mainwindow.cpp b/logPlus/mainwindow.cpp index 8d1404d..0f2bad7 100644 --- a/logPlus/mainwindow.cpp +++ b/logPlus/mainwindow.cpp @@ -78,6 +78,8 @@ MainWindow::MainWindow(QWidget *parent) : //关联信号槽，数据查看 connect(CallManage::getInstance(), SIGNAL(sig_ShowCurve(QString, QString)), this, SLOT(s_ShowCurve(QString, QString))); + //关联信号槽，数据查看 + connect(CallManage::getInstance(), SIGNAL(sig_ShowTable(QString, QString)), this, SLOT(s_ShowTable(QString, QString))); } MainWindow::~MainWindow() @@ -453,8 +455,25 @@ void MainWindow::s_ShowCurve(QString strSlfName, QString strName) if(m_centerWidgets) { WellLogTableDialogNew* pDialog = new WellLogTableDialogNew(); - pDialog->setName(strSlfName, strName); - m_centerWidgets->addTab(pDialog, strName); + pDialog->setName(strSlfName, strName, CURVE_OBJECT); + QString wellname;QString path; + GetWellNameAndPath(strSlfName, wellname, path); + m_centerWidgets->addTab(pDialog, wellname + ":" + strName); + int iCount = m_centerWidgets->count(); + m_centerWidgets->m_pTabBar->setCurrentIndex(iCount-1); + } +} + +//表格数据查看 +void MainWindow::s_ShowTable(QString strSlfName, QString strName) +{ + if(m_centerWidgets) + { + WellLogTableDialogNew* pDialog = new WellLogTableDialogNew(); + pDialog->setName(strSlfName, strName, TABLEE_OBJECT); + QString wellname;QString path; + GetWellNameAndPath(strSlfName, wellname, path); + m_centerWidgets->addTab(pDialog, wellname + ":" + strName); int iCount = m_centerWidgets->count(); m_centerWidgets->m_pTabBar->setCurrentIndex(iCount-1); } diff --git a/logPlus/mainwindow.h b/logPlus/mainwindow.h index 111c55c..f6cf632 100644 --- a/logPlus/mainwindow.h +++ b/logPlus/mainwindow.h @@ -10,6 +10,7 @@ #include "qtprojectwidgets.h" #include "qtcenterwidgets.h" +#include "mainwindownew.h" #include "mainwindowcurve.h" #include "customtabwidget.h" #include "ConsoleOutputWidget.h" @@ -87,6 +88,7 @@ public slots: void s_showView(); void s_ShowCurve(QString strSlfName, QString strName);//曲线数据查看 + void s_ShowTable(QString strSlfName, QString strName);//表格数据查看 }; diff --git a/logPlus/qtprojectwidgets.cpp b/logPlus/qtprojectwidgets.cpp index 44a109d..23ae811 100644 --- a/logPlus/qtprojectwidgets.cpp +++ b/logPlus/qtprojectwidgets.cpp @@ -591,6 +591,10 @@ void QtProjectWidgets::initMenu() _menuCurveObject = new QMenu(ui->treeWidget); initCurveObjectTreeMenu(_menuCurveObject, ui->treeWidget); + //表格对象-右键菜单 + _menuTableObject = new QMenu(ui->treeWidget); + initTableObjectTreeMenu(_menuTableObject, ui->treeWidget); + _menuWellName = new QMenu(ui->treeWidget); initWellNameTreeMenu(_menuWellName, ui->treeWidget); @@ -623,8 +627,15 @@ void QtProjectWidgets::initCurveObjectTreeMenu(QMenu *menu, QTreeWidget *treeWid m_action_ShowCurve->setIcon(QIcon(":/image/u174.png")); // 设置图标 connect(m_action_ShowCurve, SIGNAL(triggered(bool)), this, SLOT(onShowCurve(bool))); menu->addAction(m_action_ShowCurve); +} - +//初始化表格对象-右键菜单 +void QtProjectWidgets::initTableObjectTreeMenu(QMenu *menu, QTreeWidget *treeWidget) +{ + QAction* action_TableObject = new QAction("数据查看", treeWidget); + action_TableObject->setIcon(QIcon(":/image/u174.png")); // 设置图标 + connect(action_TableObject, SIGNAL(triggered(bool)), this, SLOT(onShowTable(bool))); + menu->addAction(action_TableObject); } //初始化根节点(井名称)-右键菜单 @@ -705,6 +716,12 @@ void QtProjectWidgets::onShowCurve(bool checked) emit CallManage::getInstance()->sig_ShowCurve(m_strSlfName, m_strCurveObjectName); } +//表格数据查看 +void QtProjectWidgets::onShowTable(bool checked) +{ + emit CallManage::getInstance()->sig_ShowTable(m_strSlfName, m_strCurveObjectName); +} + void QtProjectWidgets::onEditWelllogRound() { QTreeWidgetItem *wellItem = *ui->treeWidget->selectedItems().begin(); @@ -794,7 +811,6 @@ void QtProjectWidgets::onImportSlfTable() folderPath = folderPath + "/" + "#" + wellname + "/" + wellroundname + ".slf"; //QMessageBox::information(NULL,"标题",folderPath); QStringList namelist;//=GetSelWellRound(); - // namelist<<"D:/LogPlus/bin/../Logdata//例子2/#JPH-404/JPH-404.slf"; magr->dataInTable(CurItemType,wellname,folderPath); } @@ -809,7 +825,6 @@ void QtProjectWidgets::onOutWellLogRound() folderPath = folderPath + g_prjname; folderPath = folderPath + "/" + "#" + wellname + "/" + wellroundname + ".slf"; QStringList namelist;//=GetSelWellRound(); - // namelist<<"D:/LogPlus/bin/../Logdata//例子2/#JPH-404/JPH-404.slf"; namelist<text(0); m_strSlfName = item->data(0, Qt::UserRole+1).toString(); } + else if (strTreeTag == "tableObject") + { + //表格对象 + popMenu = _menuTableObject; + m_strCurveObjectName = item->text(0); + m_strSlfName = item->data(0, Qt::UserRole+1).toString(); + } else if (strTreeTag == "wellname") { //根节点(项目名称)-右键菜单 diff --git a/logPlus/qtprojectwidgets.h b/logPlus/qtprojectwidgets.h index 83c901c..01103f0 100644 --- a/logPlus/qtprojectwidgets.h +++ b/logPlus/qtprojectwidgets.h @@ -37,7 +37,9 @@ public slots: void s_OpenProject(QString fileFull); //打开项目 //曲线 - void onShowCurve(bool checked = false); //数据查看 + void onShowCurve(bool checked = false); //数据查看 + //表格 + void onShowTable(bool checked = false); //数据查看 void onEditWelllogRound(); void onImportSingleWellLogData(); void onImportSlfTable(); @@ -50,6 +52,7 @@ public: //右键菜单 QMenu *_menuRoot; QMenu *_menuCurveObject;//曲线对象(AC、BS...) + QMenu *_menuTableObject;//表格对象 QMenu *_menuWellName; //根节点(项目名称)-右键菜单 @@ -75,6 +78,8 @@ public: void initRootTreeMenu(QMenu *menu, QTreeWidget *treeWidget); //初始化曲线对象(AC、BS...)-右键菜单 void initCurveObjectTreeMenu(QMenu *menu, QTreeWidget *treeWidget); + //初始化表格对象-右键菜单 + void initTableObjectTreeMenu(QMenu *menu, QTreeWidget *treeWidget); //初始化根节点(井名称)-右键菜单 void initWellNameTreeMenu(QMenu *menu, QTreeWidget *treeWidget); private: