///////////////////////
///
///  wangwei change part:ImportWellTrajectorys() for add read wis、slf，table、dev

#pragma warning( push ,0)
#include <QDialog.h>
#include <string.h>
#include <vector>
#include <QInputDialog>
// #include "BaseFun.h"
#include <iostream>
#include "MemRdWt.h"
#include <QtCore>
// #include "ObjGeoLayerData.h"
#include "DepthProgress.h"
#include <QLibrary>
// #include "ObjectEvent.h"
// #include "VecSceneManager.h"
#include "ConvertorManager.h"
// #include "ObjDiscreteWellLog.h"
#include "DataImport.h"

#include "geometryutils.h"
// #include "CoreImageConfigDialog.h"
#include "ObjWell.h"
#include "ObjWelllog.h"
// #include "ObjWellTrajectory.h"
// #include "ObjBitmap.h"
// #include "ObjCrossplot.h"
// #include "VecDisplayObjectCommand.h"
// #include "ObjProject.h"
#include "ConvertorManager.h"
#include "IConvertor.h"
#include "ImportdataDialog.h"
// #include "ObjWellLogTrack.h"
#include "ObjWelllogRound.h"
// #include "ObjWellTrack.h"
#include "ConsoleOutputWidget.h"

// #include "ObjGeostratums.h"
#include "ObjWelllogWavefile.h"
// #include "ObjWelllogBIN.h"
#include "ObjWelllogINP.h"
// #include "ObjWelllogFMT.h"
// #include "ObjWelllogTDT.h"
#include "ObjWelllogTABLE.h"
#include "InterIConvertor.h"
#include <QTextStream>//2020.2.20 whp add
// #include "DataTree.h"
// #include "VecWindowCommand.h"
// #include "cdialog.h"//whp add 2020.3.17
#include "tishidialog.h"
// #include "Log.h"

#pragma warning( pop )
// void OSGFRAMEWORK_EXPORT AppendConsole(pai::log::Priority priority,const QString &output);

// BEGIN_OSGGRAPHICS_NAMESPACE;
extern QString g_prjname;
int CDataImport::flag1=-1;
int CDataImport::m_flag=-1;
int CDataImport::flag_check=0;
bool CDataImport::m_bImportByFolder = false;

void CreateWellFile(CLogIO *logio,Slf_FILE_MESSAGE &mssage,QString wellFile,CObjWell *pWell)
{
    if(logio) {
        CLogIO * logiowell=new CLogIO();
        Slf_FILE_MESSAGE ms=mssage;
        strcpy(ms.Item,"井基本信息");
        logiowell->Open(wellFile.toStdString().c_str(),CSlfIO::modeWrite);
        logiowell->SetFileMessage(ms);
        QStringList azims=GetSimilarCurves("AZIM");
        int iAZIM=-1;
        QString AZIM;
        foreach(QString cname,azims)
        {
            iAZIM=logio->FindObjectName((char *)cname.toStdString().c_str());
            if(iAZIM>-1) {
                AZIM=cname;
                break;
            }
        }
        int iDev=-1;
        QStringList devis=GetSimilarCurves("DEVI");
        QString DEV;
        foreach(QString cname,devis)
        {
            iDev=logio->FindObjectName((char *)cname.toStdString().c_str());
            if(iDev>-1) {
                DEV=cname;
                break;
            }
        }
//		if(logio->FindObjectIndex("井基本信息")>-1) {
//			logiowell->CopyFromFile((CSlfIO &)(*logio),"井基本信息");
//		}
        if(iAZIM>-1)logiowell->CopyFromFile((CSlfIO &)(*logio),(char *)AZIM.toStdString().c_str());
        if(iDev>-1)logiowell->CopyFromFile((CSlfIO &)(*logio),(char *)DEV.toStdString().c_str());
        delete logiowell;
        if(iDev>-1&&iAZIM>-1) {
            pWell->ComputeTrajectory(pWell,wellFile);
        }
    }
}
// CObjWell * CDataImport::GetWellByName( QString strWellName )
// {
// 	//得到或创建well
// 	CObjWell *pWell = NULL;
// 	if( GetProject() )
// 	{
// 		PaiObject *pP=GetProject()->GetObjectByName( strWellName,GetClassID_Well());
// 		pWell = dynamic_cast<CObjWell *>(pP);
// 	}

// 	if( !pWell  )
// 	{
// 		pWell = new CObjWell();
// 		pWell->SetName( strWellName );
// 		if( GetProject() )
// 		{
// 			GetProject()->GetWellsFolder(true)->AddChild( pWell );
// 		}
// 	}
// 	return pWell;
// }

// void CDataImport::AddWellNode(CVecSceneManager *pSceneManager,CObjWell *pWell,CObjWell *pWellInsertPos )
// {
// 	if( !pWell ) return;
// 	QUuid ID = pWellInsertPos ? pWellInsertPos->GetID(): QUuid();
// 	pSceneManager->AddObject( pWell,&ID  );

// 	QList<PaiObject*>listChild;
// 	pWell->GetChildren( listChild);
// 	for( long i = 0 ; i < listChild.size();++i )
// 	{
// 		AddWellLogNode( pSceneManager,dynamic_cast<CObjWellLog*>( listChild[i] ),NULL );
// 	}
// }

// void CDataImport::AddWellLogNode(CVecSceneManager * pSceneManager,CObjWellLog *pWellLog,CObjWellLog *pWellLogInsertPos )
// {
// 	QUuid ID = pWellLogInsertPos ? pWellLogInsertPos->GetID() : QUuid();
// 	pSceneManager->AddObject( pWellLog,&ID );
// }
int  CDataImport::chakan(QList<CObjWell *> &wells,QString path,QStringList &wellfs,int &num,bool GetNum,DiDepthProgress *DepthProgress,char *pSuffix)
{
    QDir dir(path);
    foreach(QFileInfo mfi ,dir.entryInfoList())
    {
        if(mfi.isFile())
        {
            if(pSuffix) {
                if(mfi.fileName().lastIndexOf(pSuffix,-1,Qt::CaseInsensitive)==-1) continue;
            }
            else {
                if(mfi.fileName().endsWith(".well",Qt::CaseInsensitive)) continue;
            }
            num++;
            if(IsInvalidString(mfi.fileName())) {
                wellfs.append(mfi.absoluteFilePath());
                continue;
            }
            if(GetNum) continue;
            QString aa= mfi.completeBaseName()+"导入中";
            DepthProgress->SetShowName(aa.toStdString().c_str(),0);
            DepthProgress->SetDepth(num,0);
            CObjWell *pWell=ChangetoSlf(mfi.absoluteFilePath(),DepthProgress);
            if(!pSuffix) {
                if(pWell) wells.push_back(pWell);
                else wellfs.append(mfi.absoluteFilePath());
            }
        }else
        {
            if(mfi.fileName()=="." || mfi.fileName() == "..")continue;
            chakan(wells,mfi.absoluteFilePath(),wellfs,num,GetNum,DepthProgress,pSuffix);
        }
    }
    return num;
}
QList<CObjWell *> CDataImport::ImportWellTrajectorys(bool IsDir)
{
    CDataImport::flag_check=0;
    CDataImport::flag1=-1;
    CDataImport::m_flag=-1;
    QList<CObjWell *> wells;
    QString path;
    if(IsDir)
    {
        static QString path1=::GetDataPath();
        path1=QFileDialog::getExistingDirectory(NULL,"选择目录",path1,QFileDialog::ShowDirsOnly);
        if(path1.isEmpty()) return wells;
        path=path1;
    }
    else  {
        ConvertorManager::GetInstance().LoadAllConvertorPlugin();
        ConvertorManager &pManager=ConvertorManager::GetInstance();
        pManager.all=0;
        QVector<QString>vSuffix=pManager.GetSupportFileExtensions();
        QString fileSuffix("数据文件(");
        for (int i=0;i<vSuffix.size();i++)
        {
            QString sSuffix="*.";
            sSuffix.append(vSuffix[i]);
            fileSuffix.append(sSuffix);
            fileSuffix.append(" ");
        }
        QString sSuffix="*.";
        sSuffix.append("slf");
        fileSuffix.append(sSuffix);
        fileSuffix.append(" ");
        sSuffix="*.";
        sSuffix.append("well");
        fileSuffix.append(sSuffix);
        fileSuffix.append(" ");

        fileSuffix.append(")");
        QStringList listFiles;
        listFiles=GetFileNames("数据目录",fileSuffix);
        if(listFiles.size()<1) return wells;
        path=listFiles[0];
    }
    int num=0;
    QStringList wellfs;
    wells=ImportWells(path,wellfs,&num);
    // CObjProject *pPrj=::GetProject();
    // if(pPrj) {
    //     PaiObject *pObj=pPrj->GetObjectByType(GetClassID_WellsFolder());
    //     if(pObj) {
    //         CBaseObject * pBaseObject = dynamic_cast<CBaseObject*>(pObj);
    //         if(pBaseObject) {
    //             CDataTree *pDatatree=(CDataTree *)::GetProject()->m_pDataTree;
    //             if(pDatatree) {
    //                 QTreeWidgetItem* pItem=pDatatree->GetTreeItem(pBaseObject);
    //                 pDatatree->ClickObjectCommand(pItem);
    //             }
    //             pBaseObject->SetCheckState(Qt::Checked);
    //             CVecWindow *pWindow=CVecWindowCommand::GetCurrentWindow();
    //             CVecDisplayObjectCommand::ClickObjectCommand( pBaseObject->GetPaiObject(),pWindow);
    //         }
    //     }
    // }
    QStringList lpsFile;
    if(wellfs.size())
    {
        for(int nIndex =0;nIndex<wellfs.size();++nIndex)//for(int n=0;n<wellfs.size();n++)
        {
                QString us=wellfs[nIndex];//rIter;
                QFileInfo currentfile(us.toUpper());
                //us=currentfile.suffix();
                if(currentfile.suffix()=="IRD"||currentfile.suffix()=="PLT"||
                    currentfile.suffix()=="I1D"||currentfile.suffix()=="D1D"||
                    currentfile.suffix()=="I2D"||currentfile.suffix()=="D2D")
                {
                        lpsFile.append(us);//wellfs[n]);
                        wellfs.removeAt(nIndex);
                        --nIndex;
                }
        }
    }
    if(wellfs.size())
    {
    // //whp change 2020.3.17
    //     CDialog* m_dialog=new CDialog();
    //     m_dialog->setMessage("成功导入"+QString::number(wells.size())+"个井次文件,"+QString::number(wellfs.size())+"个文件无法识别:\r\n"+wellfs.join("\r\n"));
    //     m_dialog->setTitle("提示");
    //     m_dialog->exec();
    //     delete m_dialog;
    }
    else {
        // AfxMessageBox(QString::number(num)+"个文件全部导入成功!");
        QMessageBox::information(NULL, "提示",QString::number(num)+"个文件全部导入成功!");
    }
    QList<CObjWell *> wells1;
    return wells1;
}
QList<CObjWell *> CDataImport::ImportWells(QString path,QStringList &wellfs,int *pNum,bool IsTran)
{
    char szTemp[64];
    strcpy(szTemp, ".well");
    ImportWells(path,wellfs,szTemp,NULL,IsTran);
    wellfs.clear();
    return ImportWells(path,wellfs,(char*)NULL,pNum,IsTran);
}
QString GetWellFileFromDir(QString path,QString &WellName,char *pSuffix)
{
    QDir dir(path);
    foreach(QFileInfo mfi ,dir.entryInfoList())
    {
        if(mfi.isFile())
        {
            QString tem=mfi.absoluteFilePath();
            if(tem.endsWith(pSuffix,Qt::CaseInsensitive)) {
                CLogIO tf;
                if(tf.Open(tem.toStdString().c_str(),CSlfIO::OpenFlags::modeRead)) {
                    Slf_FILE_MESSAGE mess;
                    tf.GetFileMessage(mess);
                    WellName=mess.WellName;
                    return tem;
                }
            }
        }
        else
        {
            if(mfi.fileName()=="." || mfi.fileName() == "..")continue;
            QString tt=GetWellFileFromDir(mfi.absoluteFilePath(),WellName,pSuffix);
            if(tt.isEmpty()) return tt;
        }
    }
    return "";
}
QString GetWellFileFromCurrentDir(QString path,QString WellName,char *pSuffix)
{
    QDir dir(path);
    foreach(QFileInfo mfi ,dir.entryInfoList())
    {
        if(mfi.isFile())
        {
            QString tem=mfi.absoluteFilePath();
            if(tem.endsWith(pSuffix,Qt::CaseInsensitive)) {
                return tem;
            }
        }
        else
        {
            if(mfi.fileName()=="." || mfi.fileName() == "..")continue;
            QString tt=GetWellFileFromCurrentDir(mfi.absoluteFilePath(),WellName,pSuffix);
            if(tt.isEmpty()) return tt;
        }
    }
    return "";
}
QList<CObjWell *> CDataImport::ImportWells(QString path,QStringList &wellfs,char *pSuffix,int *pNum,bool IsTran)
{
//////////////////////////
// FIRST is dir
    QList<CObjWell *> wells;
    if(path.isEmpty()) return wells;
    int num=0;
    QStringList listFiles;
    QFileInfo mfi(path);
    if(!mfi.isDir()) {
        if(!mfi.isFile()) return wells;
        listFiles.append(path);
        if(pSuffix) {
            CObjWell *pWell=NULL;
            foreach(QString filename,listFiles)
            {
                QString WellName;
                if(filename.endsWith(".slf",Qt::CaseInsensitive))
                {
                    QString wellname1,path1;
                    GetWellNameAndPath(filename,wellname1,path1);
                    QString path2=GetLogdataPath();
                    if(path1.indexOf(path2)<0) {
                        int a=1;
                    }
                    CLogIO tem;
                    if(tem.Open(filename.toStdString().c_str(),CSlfIO::OpenFlags::modeRead)){
                        Slf_FILE_MESSAGE mess;
                        tem.GetFileMessage(mess);
                        WellName=mess.WellName;
                    }
                }
                if(WellName.isEmpty()) continue;
                QString wellname,path1;
                GetWellNameAndPath(filename,wellname,path1);
                QString stem=path1+"\\";
                stem+=wellname;
                stem+=pSuffix;
                QDir ft(stem);
                if(ft.exists()) {
                    pWell=ChangetoSlf(stem,NULL,IsTran);
                    continue;
                }
                path1=GetWellFileFromDir(filename,WellName,pSuffix);
                if(path1.isEmpty()) continue;
                pWell=ChangetoSlf(path1,NULL,IsTran);
            }
            return wells;
        }
        num=listFiles.size();
    }
    else {
        QString fileSuffix("数据文件(");
        ConvertorManager &pManager=ConvertorManager::GetInstance();
        pManager.all=0;
        if(pSuffix) {
            QString sSuffix="*.";
            sSuffix+=pSuffix;
            fileSuffix.append(sSuffix);
        }
        else {
            ConvertorManager::GetInstance().LoadAllConvertorPlugin();
            QVector<QString>vSuffix=pManager.GetSupportFileExtensions();
            for (int i=0;i<vSuffix.size();i++)
            {
                QString sSuffix="*.";
                sSuffix.append(vSuffix[i]);
                fileSuffix.append(sSuffix);
                fileSuffix.append(" ");
            }
            QString sSuffix="*.";
            sSuffix.append("slf");
            fileSuffix.append(sSuffix);
            fileSuffix.append(" ");
        }
        fileSuffix.append(")");
        //取当前当前目录内容
        QDir dir(path);
        dir.setFilter(QDir::Dirs |QDir::NoDotAndDotDot |QDir::Files | QDir::NoSymLinks);
        QFileInfoList list = dir.entryInfoList();
        int file_count = list.count();
        if(file_count <= 0)//判断目录是否为空，空目录返回
        {
            return wells;
        }
        //取当前目录内容，符合后缀文件
        QStringList string_list;
        for(int i=0; i<list.size();i++)
        {
            QFileInfo file_info = list.at(i);
            if(file_info.isDir()) {
                QString absolute_file_path = file_info.absoluteFilePath();
                if(absolute_file_path.at(absolute_file_path.length()-1)==' ') {
                    dir.rmdir(absolute_file_path);
                    continue;
                }
                listFiles.append(absolute_file_path);
            }
            else {
                QString suffix = file_info.suffix();
                suffix=suffix.toLower();
                QString absolute_file_path = file_info.absoluteFilePath();
                if(fileSuffix.indexOf(suffix,0,Qt::CaseInsensitive)>=0)
                {
                    listFiles.append(absolute_file_path);
                }
                else {
                    if(!pSuffix)wellfs.append(absolute_file_path);
                }
            }
        }
        if(listFiles.size()<1) return wells;
        num=chakan(wells,path,wellfs,num,true,NULL,pSuffix);
        if(num<1) return wells;
    }
    DiDepthProgress DepthProgress;
    int progress=0;
    QString sname="批量加载数据...";//
    if(pSuffix) sname="遍历工区井..";
    DepthProgress.CreatProgress(0,num,sname.toStdString().c_str());
    foreach( QString wellFile,listFiles )
    {
        QFileInfo w(wellFile);
        if(w.isDir()) {
            chakan(wells,wellFile,wellfs,progress,0,&DepthProgress,pSuffix);
        }
        else {
            sname=w.completeBaseName()+"数据导入中";
            DepthProgress.SetShowName(sname.toStdString().c_str(),0);
            DepthProgress.SetDepth(progress++,0);
            CObjWell *pWell=ChangetoSlf(wellFile,&DepthProgress,IsTran);
            if(!pSuffix) {
                if(pWell) {
                    wells.push_back(pWell);
                }
                else wellfs.append(wellFile);
            }
        }
    }
    DepthProgress.DelProgress();
    if(pNum) *pNum=num;
    return wells;
}
void CDataImport::LoadLayers(QStringList &listFiles)
{
    // CObjProject *pProj=::GetProject();
    // if(!pProj) return;
    // if(!listFiles.size())
    // {
    //     QString path=GetLogdataPath();//GetProjectFolder()
    //     if(pProj) path=path+pProj->GetName();
    //     QDir dir(path);
    //     if(!dir.exists())
    //     {
    //         return;
    //     }
    //     dir.setFilter(QDir::NoDotAndDotDot |QDir::Files | QDir::NoSymLinks);
    //     QFileInfoList list = dir.entryInfoList();

    //     int file_count = list.count();
    //     if(file_count <= 0)
    //     {
    //         return;
    //     }
    //     QStringList fileSuffix;
    //     fileSuffix.append("Layer");
    //     QStringList string_list;
    //     listFiles.clear();
    //     for(int i=0; i<list.size();i++)
    //     {
    //         QFileInfo file_info = list.at(i);
    //         QString suffix = file_info.suffix();
    //         if(fileSuffix.indexOf(suffix)>=0)
    //         {
    //             QString absolute_file_path = file_info.absoluteFilePath();
    //             listFiles.append(absolute_file_path);
    //         }
    //     }
    // }
    // CBaseObject *pOSGObject =pProj->GetFolderObjectByClassID(GetClassID_GeoModelFolder(),true);
    // PaiObject * pParentObject= pOSGObject->GetPaiObject();
    // QList<PaiObject*>lists;
    // pParentObject->GetChildren(lists);
    // for(int i=0;i<lists.size();i++)
    // {
    //     CObjGeoLayerData * pGeoLayerObj=dynamic_cast<CObjGeoLayerData *>(lists[i]);
    //     pParentObject->RemoveChild(pGeoLayerObj,true);
    // }
    // foreach( QString wellFile,listFiles ) {
    //     CObjGeoLayerData * pGeoLayerObj=new CObjGeoLayerData;
    //     QString sectionName,path0;
    //     GetWellNameAndPath(wellFile,sectionName,path0);
    //     if(!sectionName.isEmpty())pGeoLayerObj->SetName(sectionName);
    //     else pGeoLayerObj->SetName(wellFile);
    //     pParentObject->AddChild(pGeoLayerObj);
    // }
}
void CDataImport::ImporttoTree(QString slfFileName,CLogIO *logio1,CObjWell *pWell,CObjWelllogRound* pWelllogRound,char *curvename)
{
// //	if(!pWelllogRound) return;
//     CLogIO *logio=logio1;
//     if(!logio) {
//         logio=new CLogIO();
//         if(!logio->Open(slfFileName.toStdString().c_str(),CSlfIO::modeRead))
//         {
//             delete logio;
//             AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！");
//             return;
//         }
//     }
//     int i=logio->FindObjectName(curvename);
//     if(i<0) {
//         if(!logio1){
//             delete logio;
//         }
//         return;
//     }
	
//     char aliasname[65];
//     aliasname[64]='\0';
//     logio->GetObjectName(i,curvename,NULL,aliasname);
//     CObjWellLog * acurve;
//     if(pWelllogRound) acurve=dynamic_cast<CObjWellLog *>(pWelllogRound->GetObjectByName(curvename));
//     else acurve=dynamic_cast<CObjWellLog *>(pWell->GetObjectByName(curvename));
//     if(dynamic_cast<CObjDiscreteWellLog*>(acurve)) acurve=NULL;
//     short curvetype=logio->GetObjectType(i);
//     short Attribute=0,SubAttribute=0;
//     logio->GetObjectAttribute(i,&Attribute,&SubAttribute);

//     if(acurve) {
//         PaiObject *pP=acurve->GetParent();
//         if(dynamic_cast<CObjWellTrack*>(pP)||
//             dynamic_cast<CObjWellLogTrack*>(pP)
//             ) acurve=NULL;
//         else{
//             CDataTree *pTree=dynamic_cast<CDataTree *>(::GetProject()->m_pDataTree);
//             if(pTree&&pTree->GetTreeItem(acurve))
//             {
//                 if(!logio1){
//                     delete logio;
//                 }
//                 return;
//             }
//         }
//     }


//     PaiObject*pPai=NULL;
//     if(curvetype==CURVE_OBJECT)
//     {
//         Slf_CURVE acurveinfo;
//         logio->GetCurveInfo(i,&acurveinfo);
//         int curveindex=logio->OpenCurve(curvename);
//         if(curveindex<0)
//         {
//             if(!logio1){
//                 delete logio;
//             }
//             return;
//         }
//         CObjWellLog * acurve=NULL;
//         QStringList cnames=GetSimilarCurves("Trajectory");
//         if(!pWelllogRound&&cnames.contains(curvename)) {
//             acurve=(CObjWellLog *) new CObjWellTrajectory();
//         }
//         else {
//             acurve=new CObjWellLog();
//             acurve->acurveinfo=acurveinfo;
//         }
//         acurve->m_ObjectType=CURVE_OBJECT;
//         acurve->SetSlfFileName(slfFileName);
//         acurve->SetName(QString::fromStdString(curvename));
//         acurve->SetAliasName(QString::fromStdString(aliasname));
//         acurve->SetUnit(QString::fromStdString(acurveinfo.Unit));
//         acurve->SetAliasUnit(QString::fromStdString(acurveinfo.AliasUnit));
//         acurve->SetDepthUnit(QString::fromStdString(acurveinfo.DepthUnit));
//         acurve->SetDepthAliasUnit(QString::fromStdString(acurveinfo.DepthHZUnit));
//         acurve->SetpropertyMin(acurveinfo.MinValue);
//         acurve->SetpropertyMax(acurveinfo.MaxValue);
//         acurve->SetRlev(acurveinfo.DepLevel);
//         acurve->SetTopDepth(acurveinfo.StartDepth);
//         acurve->SetBottomDepth(acurveinfo.EndDepth);
//         acurve->GetLogCurve().SetCurveAlias(acurveinfo.AliasName);
//         acurve->GetLogCurve().SetUnit(acurveinfo.Unit);
//         acurve->GetLogCurve().SetSampleInterval(acurveinfo.DepLevel);
//         acurve->AutoMatchFamily();
//         if(pWelllogRound)pWelllogRound->AddChild(acurve);
//         else pWell->AddChild(acurve);
//         pPai=acurve;
//     }
//     else if(curvetype==WAVE_OBJECT)
//     {
//         Slf_WAVE acurveinfo;
//         logio->GetWaveInfo(i,&acurveinfo);
//         CObjWellLog * acurve=new CObjWellLogWavefile();
//         acurve->m_ObjectType=WAVE_OBJECT;
//         acurve->SetName(QString::fromStdString(curvename));
//         acurve->SetAliasName(QString::fromStdString(aliasname));
//         acurve->SetUnit(QString::fromStdString(acurveinfo.Unit));
//         acurve->SetAliasUnit(QString::fromStdString(acurveinfo.AliasUnit));
//         acurve->SetDepthUnit(QString::fromStdString(acurveinfo.DepthUnit));
//         acurve->SetDepthAliasUnit(QString::fromStdString(acurveinfo.DepthHZUnit));
//         acurve->SetSlfFileName(slfFileName);
//         acurve->SetTopDepth(acurveinfo.StartDepth);
//         acurve->SetBottomDepth(acurveinfo.EndDepth);
//         acurve->SetRlev(acurveinfo.DepLevel);
//         acurve->GetLogCurve().SetSampleInterval(acurveinfo.DepLevel);
//         if(pWelllogRound)pWelllogRound->AddChild(acurve);
//         else pWell->AddChild(acurve);
//         pPai=acurve;
//     }
//     else if(curvetype==CARD_OBJECT)
//     {
//         if(SubAttribute==PARA_OBJECT) {
//             CObjWellLog * acurve=new CObjWellLogINP();
//             acurve->m_ObjectType=CARD_OBJECT;
//             acurve->SetName(QString::fromStdString(curvename));
//             acurve->SetAliasName(QString::fromStdString(aliasname));
//             acurve->SetSlfFileName(slfFileName);
//             if(pWelllogRound)pWelllogRound->AddChild(acurve);
//             else pWell->AddChild(acurve);
//         }
//         else {
//             CObjWellLog * acurve=new CObjWellLogBIN();
//             acurve->m_ObjectType=CARD_OBJECT;
//             acurve->SetName(QString::fromStdString(curvename));
//             acurve->SetAliasName(QString::fromStdString(aliasname));
//             acurve->SetSlfFileName(slfFileName);
//             if(pWelllogRound)pWelllogRound->AddChild(acurve);
//             else pWell->AddChild(acurve);
//         }
//         pPai=acurve;
//     }
//     else if(curvetype==FMT_OBJECT)
//     {
//         CObjWellLog * acurve=new CObjWellLogFMT();
//         acurve->m_ObjectType=FMT_OBJECT;
//         acurve->SetName(QString::fromStdString(curvename));
//         acurve->SetAliasName(QString::fromStdString(aliasname));
//         acurve->SetSlfFileName(slfFileName);
//         if(pWelllogRound)pWelllogRound->AddChild(acurve);
//         else pWell->AddChild(acurve);
//         pPai=acurve;
//     }
//     else if(curvetype==TDT_OBJECT)
//     {
//         CObjWellLog * acurve=new CObjWellLogTDT();
//         acurve->m_ObjectType=TDT_OBJECT;
//         acurve->SetName(QString::fromStdString(curvename));
//         acurve->SetAliasName(QString::fromStdString(aliasname));
//         acurve->SetSlfFileName(slfFileName);
//         if(pWelllogRound)pWelllogRound->AddChild(acurve);
//         else pWell->AddChild(acurve);
//         pPai=acurve;
//     }
//     else if(curvetype>CARD_OBJECT||curvetype==0)
//     {
//         if(pWelllogRound&&strcmp(curvename,"井基本信息")==0) return;
//         CObjWellLog * acurve=new CObjWellLogTABLE();
//         acurve->m_ObjectType=TABLEE_OBJECT;
//         acurve->SetName(QString::fromStdString(curvename));
//         acurve->SetAliasName(QString::fromStdString(aliasname));
//         acurve->SetSlfFileName(slfFileName);
//         if(pWelllogRound)pWelllogRound->AddChild(acurve);
//         else pWell->AddChild(acurve);
//         pPai=acurve;
//     }
//     CObjWellLog *pLog=dynamic_cast<CObjWellLog *>(pPai);
//     if(pLog) pLog->SetWell(pWell);
//     if(!logio1){
//         delete logio;
//     }
//     return;
}
CObjWell *CDataImport::ChangetoSlf(QString wellFile1,DiDepthProgress *pDepthProgress)
{
    return ChangetoSlf(wellFile1,pDepthProgress,true);
}
CObjWell *CDataImport::ChangetoSlf(QString wellFile1,DiDepthProgress *pDepthProgress,bool IsTran)
{
    static QString temp = ::GetConfPath()+"data.ini";
    QSettings settings(temp,QSettings::IniFormat,0);
    settings.setIniCodec(QTextCodec::codecForName("UTF-8"));
    QStringList serials=settings.value("wellType",0).toStringList();
    CObjWell *pWell(NULL);
    if(pDepthProgress)	pDepthProgress->DelProgress(1);

    QString filename=wellFile1;
    QString slffilename=filename;

///////////////////
//识别是否为系统格式，否则启动转换模块转换为系统格式
    if(!filename.endsWith(".slf",Qt::CaseInsensitive)&&
        !filename.endsWith(".well",Qt::CaseInsensitive)&&IsTran)
    {
        QString logdata=GetLogdataPath()+g_prjname/*::GetProject()->GetName()*/;
        logdata.replace('\\','/');
        logdata.replace("//","/");
        filename.replace("//","/");
        filename.replace("\\","/");
        if(filename.indexOf(logdata,0,Qt::CaseInsensitive)>-1) return pWell;
        ConvertorManager &pManager=ConvertorManager::GetInstance();
        //按目录加载原始数据时解编入口
        QString slfName=ConvertorWellLogFiles(pManager,filename,pDepthProgress);
        if(slfName!=""&&slfName!="abandoned"){//2020.3.19 放弃加载的文件名如何加入到提示中
            pWell=ChangetoSlf(slfName,pDepthProgress);//whp add 2019.12.12
        }
        return pWell;
    }
    else {
        QString wellname1,path1;
        GetWellNameAndPath(filename,wellname1,path1);
        QString prjname = g_prjname;
        // if(GetProject()) prjname=GetProject()->GetName();
        QString path2="LogData\\"+prjname;
        QString path3="LogData/"+prjname;
        path1=path1.replace("\\\\","\\");
        path1=path1.replace("//","/");
        int a=path1.indexOf(path2,0,Qt::CaseInsensitive);
        int b=path1.indexOf(path3,0,Qt::CaseInsensitive);
        if(a<0&&b<0) {
            QFile dd;
            path2=GetLogdataPath();
            path2+=prjname+"\\#"+wellname1;
            CreateDir((char *)path2.toStdString().c_str());
            path2+="\\"+wellname1+".slf";
            dd.copy(filename,path2);
            slffilename=path2;
            filename=path2;
        }

        int iX=-1,iY=-1,iZ=-1;
        CObjWelllogRound* pWelllogRound=NULL;
        ///从文件内部读取井名
        CLogIO * logio=new CLogIO();
        if(!logio->Open(slffilename.toStdString().c_str(),CSlfIO::modeRead))
        {
            delete logio;
            QString aa=slffilename+"文件打开失败，请检查！";
            // AppendConsole(pai::log::PAI_ERROR,aa);
            return pWell;
        }
        //说明从项目或者井节点发起attachSLF,需要读取slf获得井名和井次信息
        QString wellname="";
        QString wellRoundname="";
        Slf_FILE_MESSAGE mssage;
        logio->GetFileMessage(mssage);
        wellname=mssage.WellName;
        wellname=wellname.toUpper();
        //辨别井名是否有效，无效则采用文件名
        QFileInfo fileInfo(filename);
        QString strWellName = fileInfo.completeBaseName();
        strWellName=strWellName.toUpper();
        if (wellname.isEmpty()||wellname.length()>64||wellname.indexOf('&')>-1)
        {
            wellname=strWellName.toStdString().c_str();
            int len=strlen(strWellName.toStdString().c_str());
            if(len>sizeof(mssage.WellName)) len=sizeof(mssage.WellName);
            strncpy(mssage.WellName,strWellName.toStdString().c_str(),len);
            mssage.WellName[len]=0;
            logio->SetFileMessage(mssage);
        }
        wellname=wellname.toUpper();
        // if(!GetProject() ) {
        //     delete logio;
        //     return NULL;
        // }
        // //挂接到树
        // PaiObject *pObject=GetProject()->GetObjectByName( wellname,2);//GetClassID_Well());
        // pWell = dynamic_cast<CObjWell *>( pObject );
        // if(!pWell) {
        //     CObjWellTrack *pWellTrack = dynamic_cast<CObjWellTrack *>( pObject);
        //     if(pWellTrack&&pWellTrack->GetWelllogRound()) {
        //         pWell=pWellTrack->GetWelllogRound()->GetWell();
        //     }
        // }
        if(!pWell) {
            // pWell = CDataImport::GetWellByName(wellname);
            // CDataTree *pTree=(CDataTree *)GetDataTree();
            // if(pTree) {
            //     PaiObject *pJ=GetProject()->GetObjectByType(GetClassID_WellsFolder());
            //     QTreeWidgetItem*  pItemF=pTree->GetTreeItem(dynamic_cast<CBaseObject *>(pJ));
            //     QTreeWidgetItem*  pItem=pTree->GetTreeItem(pWell );
            //     QTreeWidgetItem*  pItemF1=NULL;
            //     if(pItem)pItemF1=pItem->parent();
            //     if(pItemF1!=pItemF) {
            //         if(pItemF1)pItemF1->removeChild(pItem);
            //         if(pItemF)pItemF->addChild(pItem);
            //     }
            // }
            // if(!pWell) {
            //     delete logio;
            //     return NULL;
            // }

            if( !pWell  )
            {
                pWell = new CObjWell();
                pWell->SetName( strWellName );
            }

            QString welln;
            if(filename.endsWith(".slf",Qt::CaseInsensitive))
            {
                QString dirpath=GetLogdataPath()+g_prjname/*GetProject()->GetName()*/;

                char szTemp[64];
                strcpy(szTemp, ".well");
                welln=GetWellFileFromDir(dirpath,wellname, szTemp);
                if(welln.isEmpty()||(!pWell->GetName().isEmpty()&&wellname!=pWell->GetName())) {
                    wellname=pWell->GetName();
                    int index=filename.lastIndexOf("\\");
                    int index1=filename.lastIndexOf("/");
                    if(index1>index) index=index1;
                    welln=GetWellFileFromCurrentDir(filename.left(index+1),wellname,szTemp);
                    if(welln.isEmpty()) {
                        welln=filename.left(index+1)+wellname+".well";
                        CreateWellFile(logio,mssage,welln,pWell);
                        // CDataTree::SetTree(welln,pWell,NULL,(DepthProgress *)pDepthProgress,1);
                    }
                }
            }
            else if(filename.endsWith(".well",Qt::CaseInsensitive))welln=filename;
            pWell->SetWellFileName(welln);
        }
        wellRoundname=strWellName;
        //查找是否已经存在该井和井次
        int isrefress=0;
        if(!filename.endsWith(".well",Qt::CaseInsensitive)) {
            pWelllogRound=dynamic_cast<CObjWelllogRound*>( pWell->GetObjectByName(wellRoundname,GetClassID_WellLogRound()));
            if(pWelllogRound)
            {
                QString cs=pWelllogRound->GetSlfFileName();
                cs.replace('\\','/');
                cs.replace("//","/");
                QString cs1=filename;
                cs1.replace('\\','/');
                cs1.replace("//","/");
                if(cs1.compare(cs,Qt::CaseInsensitive)!=0) {
                    QString cs2=cs+"\n";
                    cs2+=cs1+"为同一井次文件!\n";
                    cs2+="按重名文件加载！";
                    // AppendConsole(pai::log::PAI_ERROR,cs2);
                    wellRoundname+="_重名文件";
                    strcpy(mssage.Item,wellRoundname.toStdString().c_str());
                    pWelllogRound=NULL;//return 0;
                }
            }
            if(!pWelllogRound)
            {
                // pWelllogRound=new CObjWelllogRound();
                // pWelllogRound->SetWell(pWell);
                // pWell->AddChild(pWelllogRound);

                // pWell->SetCurrentObjWellRound(pWelllogRound);
                if(strstr(mssage.Item,"常规")) {
                    strncpy(mssage.Item,wellRoundname.toStdString().c_str(),sizeof(mssage.Item));
                    mssage.Item[strlen(wellRoundname.toStdString().c_str())]=0;
                }
                if(strlen(mssage.Item)) {
                    wellRoundname=mssage.Item;
                }
                else {
                    int len=strlen(wellRoundname.toStdString().c_str());
                    if(len>sizeof(mssage.Item)) len=sizeof(mssage.Item);
                    strncpy(mssage.Item,wellRoundname.toStdString().c_str(),len);
                    mssage.Item[len]=0;
                    logio->SetFileMessage(mssage);
                }
                // wellRoundname=wellRoundname.toUpper();
                // pWelllogRound->SetName(wellRoundname);
                // pWelllogRound->SetSlfFileName(filename);
            }
            else {
                isrefress=true;
            }
        }
        QString temp = ::GetConfPath()+"data.ini";
        QSettings settings(temp,QSettings::IniFormat,0);
        settings.setIniCodec(QTextCodec::codecForName("UTF-8"));
        QStringList serials=settings.value("wellType",0).toStringList();
        int type=serials.indexOf(mssage.WellType);

        if(type>-1) pWell->SetWellSymbol("well" + QString::number(type) + ".png");

        //else isrefress=true;
        float Altitude=mssage.Altitude;
        float X_COORDINATE=mssage.Xcoor;
        float Y_COORDINATE=mssage.Ycoor;//井斜x,y坐标
        WellHead &mWellHead=pWell->GetWellHead();
        if(mssage.Kelly==9999999) mssage.Kelly=0;
        if(mssage.Kelly==-9999) mssage.Kelly=0;
        if(mssage.Kelly==-99999) mssage.Kelly=0;
        if(mssage.azca) mWellHead.azca=mssage.azca;
        if(mssage.Kelly)mWellHead.dEle=ConvertDataByFloat(mssage.Kelly).toFloat();
        if(mssage.WellName[0])mWellHead.wellName=mssage.WellName;
        if(X_COORDINATE)mWellHead.x=X_COORDINATE;
        if(Y_COORDINATE)mWellHead.y=Y_COORDINATE;
        if(Altitude)mWellHead.earthEle=Altitude;
        if(mssage.X0)mWellHead.dxe=mssage.X0;
        if(mssage.Y0)mWellHead.dyn=mssage.Y0;
        if(mssage.TVD)mWellHead.tvd=mssage.TVD;
        Slf_CURVE acurveinfo;
        memset(&acurveinfo,0,sizeof(Slf_CURVE));
        int curveCount=logio->GetObjectCount();
        if(isrefress) {
            logio->DiscardObject("X");
            logio->DiscardObject("Y");
            logio->DiscardObject("Z");
            logio->DiscardObject("TVD");
        }
        iX=logio->OpenCurve("X");
        iY=logio->OpenCurve("Y");
        iZ=logio->OpenCurve("Z");
        if(iX>-1) logio->GetCurveInfo(iX,&acurveinfo);

        mWellHead.depth=acurveinfo.StartDepth;
        if(mWellHead.tvd==0&&acurveinfo.StartDepth!=0)mWellHead.tvd=acurveinfo.StartDepth;
        mWellHead.z=mWellHead.earthEle-mWellHead.tvd+mWellHead.dEle;
        mWellHead.startDepth=acurveinfo.StartDepth;
        mWellHead.endDepth=acurveinfo.EndDepth;
        mWellHead.rlev=acurveinfo.DepLevel;
        int iDepth=-1;
        iDepth=logio->OpenCurve("TVD");
        if(iX>=0&&iY>=0&&iZ>=0&&iDepth>=0) {
            logio->GetCurveInfo(iX,&acurveinfo);
            if(acurveinfo.DepLevel==0) {
                logio->DiscardObject(iX);
                logio->DiscardObject(iY);
                logio->DiscardObject(iZ);
                logio->DiscardObject(iDepth);
                delete logio;
                pWell->ComputeTrajectory(pWell,filename);
            } else {
                delete logio;
                pWell->SetDepth(pWell);
            }
        }
        else {
            delete logio;
            pWell->ComputeTrajectory(pWell,slffilename);
        }
        logio=new CLogIO();
        if(!logio->Open(slffilename.toStdString().c_str(),CSlfIO::modeRead))
        {
            delete logio;
            QString aa=slffilename+"文件打开失败，请检查！";
            // AppendConsole(pai::log::PAI_ERROR,aa);
            return pWell;
        }
        curveCount=logio->GetObjectCount();
        char* curvename=new char[65];
        curvename[64]='\0';
        char* aliasname=new char[65];
        aliasname[64]='\0';
        for(int i=0;i<curveCount;i++) {
            logio->GetObjectName(i,curvename,NULL,aliasname);
            if(!logio->IsObject(i)) {
                logio->DiscardObject(i);
                continue;
            };
            if(logio->GetObjectStatus(i)!=OBJECT_NORMAL) continue;
            short curvetype=logio->GetObjectType(i);
            short Attribute=0,SubAttribute=0;
            logio->GetObjectAttribute(i,&Attribute,&SubAttribute);
            if(curvetype==CURVE_OBJECT)
            {
                Slf_CURVE acurveinfo;
                logio->GetCurveInfo(i,&acurveinfo);
                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){
                        int curveindex=logio->OpenSlfTable(i,-1);
                        if(curveindex>-1)
                        {
                            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(curveindex, acurveinfo.StartDepth,count,(void *)vVdl.vchar);
                            if(!len) {
                                QString cs;
                                char buf[1000];
                                sprintf(buf,"%s %f-%f",acurveinfo.Name,acurveinfo.StartDepth,acurveinfo.EndDepth);
                                cs=buf;
                                int flag = QMessageBox::warning(NULL,"提示",QString(cs+"\n曲线信息异常！删除该曲线可能需要较长时间，建议复制正常曲线等信息到新文件，然后删除此文件。是否此时直接将该曲线删除？"),QMessageBox::Yes,QMessageBox::No);
                                if(flag==QMessageBox::Yes) logio->DiscardObject(i);
                                delete vVdl.vchar;
                                continue;
                            }
                            for(int kk=0;kk<count;kk=kk+10)
                            {
                                float buf[200];
                                buf[0]=0;
                                float temp=logio->GetData(acurveinfo.RepCode,&vVdl.vchar[kk*acurveinfo.CodeLen],buf);
                                if(_isnan(temp)||!_finite(temp)) continue;

                                if(acurveinfo.MaxValue<temp) if(temp!=-9999.0&&temp!=-999.25&&temp!=-99999.0)acurveinfo.MaxValue=temp;
                                if(acurveinfo.MinValue>temp) if(temp!=-9999.0&&temp!=-999.25&&temp!=-99999.0)acurveinfo.MinValue=temp;
                            }
                            logio->SetCurveInfo(curveindex,&acurveinfo);
                            delete vVdl.vchar;
                        }
                    }
                }
                else if(acurveinfo.DepLevel==0||acurveinfo.StartDepth<-100000||acurveinfo.StartDepth>100000)
                {
                    QString cs;
                    char buf[1000];
                    sprintf(buf,"%s %f-%f",acurveinfo.Name,acurveinfo.StartDepth,acurveinfo.EndDepth);
                    cs=buf;
                    int flag = QMessageBox::warning(NULL,"提示",QString(cs+"\n曲线信息异常！删除该曲线可能需要较长时间，建议复制正常曲线等信息到新文件，然后删除此文件。是否此时直接将该曲线删除？"),QMessageBox::Yes,QMessageBox::No);
                    if(flag==QMessageBox::Yes) logio->DiscardObject(i);
                    continue;
                }
            }
        }
        delete []curvename;
        delete []aliasname;
        DepthProgress *pd=new DepthProgress;
        pd->CreatProgress(0,2,"正在整理数据...");
        pd->SetDepth(1);
        delete logio;
        delete pd;
/////////////////////
        pai::ios::welllog::Well& topwell=pWell->GetDBWell();
        topwell.SetTopDepth(pWell->GetTopWellLogDepth());
        topwell.SetBottomDepth(pWell->GetBottomWellLogDepth());
        if(X_COORDINATE)topwell.SetXCode(X_COORDINATE);
        if(Y_COORDINATE)topwell.SetYCode(Y_COORDINATE);
        if(mssage.Altitude)topwell.SetAsl(mssage.Altitude);
        if(mssage.Kelly)topwell.SetBsl(ConvertDataByFloat(mssage.Kelly).toFloat());
    //		topwell.SetItem(mssage.Item);

    /////////////
        topwell.LoadMeesge(filename);
        // if(pWelllogRound&&pWelllogRound->GetChildrenCount()>2) {
        //     isrefress=1;
        // }
        // if(isrefress) {
        //     QString slfFileName=filename;
        //     CDataTree::SetTree(slfFileName,pWell,pWelllogRound,(DepthProgress *)pDepthProgress,1);
        // }
    }
	
    return pWell;
return NULL;
}
void CDataImport::ImportCoreImage()
{
 //    QStringList listFiles=GetFileNames("选择文件","图片文件(*.jpg)");
 //    CObjCoreImage* pCoreImage = new  CObjCoreImage();
	
 //    std::vector<CoreImage>vCoreImage;
 //    foreach( QString imageFile,listFiles )
 //    {
 //        //得到或创建well
 //        QFileInfo fileInfo(imageFile);
 //        QString strWellName = fileInfo.completeBaseName();


 //        CoreImage coreImage;

 //        LinePro linePro;
 //        linePro.lineColor = QColor(Qt::black);
 //        linePro.lineWidth = 1;
 //        linePro.lineStyle = Qt::SolidLine;

 //        coreImage.m_imageFile = imageFile;
 //        coreImage.m_startDepth = 0;
 //        coreImage.m_endDDepth = 0;
 //        coreImage.m_leftDepth = 0;
 //        coreImage.m_rightDepth = 0;
 //        coreImage.m_border = linePro ;
 //        //pCoreImage->m_childrenItems.push_back(coreImage);
 //        vCoreImage.push_back(coreImage);
		
 //    }
 //    pCoreImage->SetImageObjects( vCoreImage );
	
 //    if(listFiles.size() > 0)
 //    {
 //        pai::gui::CoreImageConfigDialog* pDialog = new pai::gui::CoreImageConfigDialog();
 //        pDialog->SetCoreImages( pCoreImage );
 //        if(pDialog->exec() == QDialog::Accepted)
 //        {
 //            //TODO这里要找到当前曲线，不可写死
 //            CObjWell *pWell = CDataImport::GetWellByName( "A10" );
 //            pWell->AddChild( pCoreImage );
 //        }
 //    }
}

void CDataImport::ImportBitmaps()
{
    // QStringList listFiles=GetFileNames("选择文件","图片文件(*.jpg)");
    // qsrand(qrand());
    // foreach( QString imageFile,listFiles )
    // {

    //     // create Image object
    //     int nWidth = qBound( 0,qrand(),1000 );
    //     int nHeight =  nWidth ;
    //     CObjBitmap *pImageObject = new CObjBitmap( QRectF( qBound( 0,qrand(),1000 ),qBound( 0,qrand(),1000 ),
    //         nWidth,nHeight ),imageFile );

    //     // set name
    //     QFileInfo fileInfo( imageFile );
    //     pImageObject->SetName(  fileInfo.completeBaseName() );

    //     // add to project
    //     if( ::GetProject() )
    //     {
    //         ::GetProject()->AddChild( pImageObject );
    //     }
    // }
}

void CDataImport::ImportConvertorWellLogFiles(QString wellname,QString wellroundname)
{
//     AppendConsole(pai::log::PAI_INFO,QObject::tr("解编模块启动中..."));
//     ConvertorManager &pManager=ConvertorManager::GetInstance();
//     QVector<QString>vSuffix=pManager.GetSupportFileExtensions();
//     //	if (vSuffix.empty())
//     //		return;
//     QString fileSuffix("数据文件(");
//     for (int i=0;i<vSuffix.size();i++)
//     {
//         QString sSuffix="*.";
//         sSuffix.append(vSuffix[i]);
//         fileSuffix.append(sSuffix);
//         fileSuffix.append(" ");
//     }
//     QString sSuffix="*.";
//     sSuffix.append("slf");
//     fileSuffix.append(sSuffix);
//     fileSuffix.append(" ");

//     //whp del 2020.5.17 for test wis转换
// /*	sSuffix="*.";
//     sSuffix.append("wis");
//     fileSuffix.append(sSuffix);
//     fileSuffix.append(" ");*/

//     //whp add 2019.12.09 for .well
//     sSuffix="*.";
//     sSuffix.append("well");
//     fileSuffix.append(sSuffix);
//     fileSuffix.append(" ");

//     fileSuffix.append(")");
//     //选择一文件
//     QStringList listFiles=GetFileNames("选择数据文件",fileSuffix,QFileDialog::ExistingFiles);
//     int FileNum=listFiles.size();//whp 2019.12.08 test
//     if (listFiles.empty())	return ;
//     AppendConsole(pai::log::PAI_INFO,QObject::tr("解编模块自动检测开始..."));
//     DiDepthProgress DepthProgress;
//     if(listFiles.size()>1) {
//         DepthProgress.CreatProgress(0,listFiles.size(),"数据加载",0);
//         int progress=0;
//         char aa[1000];
//         //whp change 2019.12.08 for 输出成功加载的文件个数
//         int errNum=0,okNum=0,abandonedNum=0;//2020.3.19 放弃加载;
//         QStringList errFile,abandonedFile;//2020.3.19
//         //whp add 2020.3.19
//         CDataImport::flag1=-1;
//         CDataImport::m_flag=-1;
//         CDataImport::flag_check=0;//
//         foreach(QString iFile,listFiles ) {
//             progress++;
//             sprintf(aa,"待加载数据文件%d个,当前正在加载：%s",listFiles.size(),iFile.toStdString().c_str());
//             DepthProgress.SetShowName(aa,0);
//             DepthProgress.SetDepth(progress,0);
//             //多个测井数据加载时解编入口
//             QString slfName=ConvertorWellLogFiles(pManager,iFile,&DepthProgress);
//             if(slfName=="")
//             {
//                 errNum++;
//                 errFile.append(iFile);
//             }
//             else if(slfName=="abandoned")//2020.3.19 放弃加载
//             {
//                 abandonedNum++;
//                 abandonedFile.append(iFile);
//             }
//             else
//             {
//                 CObjWell* pWell=ChangetoSlf(slfName,&DepthProgress);//whp add 2019.12.12
//                 if(!pWell) {
//                     errNum++;
//                     errFile+=iFile;
//                     errFile+="\r\n";
//                 }
//             }
//         }
//         DepthProgress.DelProgress();
//         CObjProject *pPrj=::GetProject();
//         if(pPrj) {
//             PaiObject *pObj=pPrj->GetObjectByType(GetClassID_WellsFolder());
//             if(pObj) {
//                 CBaseObject * pBaseObject = dynamic_cast<CBaseObject*>(pObj);
//                 if(pBaseObject) {
//                     CDataTree *pDatatree=(CDataTree *)::GetProject()->m_pDataTree;
//                     if(pDatatree) {
//                         QTreeWidgetItem* pItem=pDatatree->GetTreeItem(pBaseObject);
//                         pDatatree->ClickObjectCommand(pItem);
//                     }
//                     pBaseObject->SetCheckState(Qt::Checked);
//                     CVecWindow *pWindow=CVecWindowCommand::GetCurrentWindow();
//                     CVecDisplayObjectCommand::ClickObjectCommand( pBaseObject->GetPaiObject(),pWindow);
//                 }
//             }
//         }

//         //2020.3.17需要修改
//         QString mes="";
//         if(errNum||abandonedNum)
//         {
//             mes="成功导入"+QString::number(listFiles.size()-errNum-abandonedNum)+"个文件;";
//             if(abandonedNum) mes+="放弃导入"+QString::number(abandonedNum)+"个数据文件;";
//             if(errNum)mes+="\r\n"+QString::number(errNum)+"个数据文件无法识别:\r\n"+errFile.join("\r\n");
//             CDialog* m_dialog=new CDialog();
//             m_dialog->setMessage(mes);
//             m_dialog->setTitle("提示");
//             m_dialog->exec();
//             delete m_dialog;
//         }
//         else {
//             mes=QString::number(listFiles.size())+"个文件全部导入成功!";
//             QMessageBox::about(NULL,"提示",mes);
//         }
//     }
//     else {
//         DepthProgress.CreatProgress(0,1,"数据加载",0);
//         DepthProgress.SetDepth(1,0);
//         QString us=listFiles[0].toLower();
//         QFileInfo currentfile(us);
//         us=currentfile.suffix();
//         //	if(us.indexOf("slf")>-1||us.indexOf("wis")>-1) {
//         //whp add 2019.12.09 for .well
//         if(us.indexOf("slf")>-1||us.indexOf("well")>-1) {
//             ChangetoSlf(listFiles[0]);
//             QString message=listFiles[0]+"解编结束";
//             AppendConsole(pai::log::PAI_INFO,QObject::tr(message.toStdString().c_str()));
//             return;
//         }
//         DepthProgress.SetShowName("类型识别",0);
//         QVector<IConvertor*> vConvertor=pManager.GetSupportConvertors(listFiles[0],&DepthProgress);
// //		if (vConvertor.empty())	return ;
//         if (vConvertor.empty())
//         {
//             QMessageBox::information(NULL,"无法识别的文件",listFiles[0]);
//             return ;
//         }
//         ImportDataDialog *pDialog = new ImportDataDialog(NULL,wellname,wellroundname);
//         pDialog->DisplayFileInformationAreaData(vConvertor,listFiles[0]);
//         ::GetObjectEvent().OnActiveConvertorWindow( pDialog );
//     }
//     AppendConsole(pai::log::PAI_INFO,QObject::tr("解编模块解编结束"));
}
//whp change 2019.12.08 for 输出成功加载的文件个数
//void
//bool
//whp add 2020.2.28 for 检查井名文件名是否存在,若存在，获取井次全路径文件名
QString CDataImport::GetOutName(QString wellname,QString filename)
{
  // CObjProject *pPrj=::GetProject();
  // PaiObject *pObj=pPrj->GetObjectByType(GetClassID_WellsFolder());
  // QList<PaiObject *> childs;
  // pObj->GetChildren(childs);
  // int wellnum=childs.count();
  // foreach(PaiObject *pChild,childs)
  // {
  //   CObjWell *pWell=dynamic_cast<CObjWell*>(pChild);
  //   if(pWell)
  //   {
  //       QString well=pWell->GetName().toUpper();
  //       if(well==wellname.toUpper())
  //       {
  //           QList<PaiObject *> childsRound;
  //           pChild->GetChildren(childsRound);
  //           foreach(PaiObject *pChildRound,childsRound)
  //           {
  //                CObjWelllogRound *pWellRound=dynamic_cast<CObjWelllogRound*>(pChildRound);
  //               if(pWellRound)
  //               {
  //                   QString file=pWellRound->GetName().toUpper();
  //                   if(file==filename.toUpper())
  //                   {
  //                       QString outname=pWellRound->GetSlfFileName();
  //                       return outname;
  //                   }
  //               }
  //           }
  //       }
  //    }
  //   }
  return "";
  }
////whp change 2020.2.28 for 检查井名、文件名是否存在,若存在，使用已存在的输出路径（主要针对更名后的井文件）
QString CDataImport::ConvertorWellLogFiles(ConvertorManager &pManager,QString wellname,DiDepthProgress *DepthProgress)
{
    QString iFile=wellname;
    QString us1=iFile.toLower();
    QFileInfo currentfile(us1);
    QString us=currentfile.suffix();
    //whp add 2019.12.09 for .well
    if(us.indexOf("slf")>-1||us.indexOf("well")>-1) {
        //ChangetoSlf(iFile,DepthProgress);
        //return 1;
        return iFile;//whp change 2019.12.12
    }
    QVector<IConvertor*> vConvertor=pManager.GetSupportConvertors(iFile,DepthProgress);
    if(vConvertor.size()>1) {
        QString s=iFile+"解编模块不唯一，无法批量解编！";
        // AppendConsole(pai::log::PAI_INFO,s);
        return "";//0;//whp change 2019.12.12
    }
    if(vConvertor.size()==0) {
        QString s=iFile+"无法识别数据类型，无法解编！";
        // AppendConsole(pai::log::PAI_INFO,s);
        return "";//0;//whp change 2019.12.12
    }
    InterIConvertor *v=(InterIConvertor *)vConvertor[0];
    QList<CObjWellLog*> ObjWellLogs= v->GetWellLogList(iFile);
    int c=ObjWellLogs.size();
    for(int i=0;i<c;i++) {
        CObjWellLog *pWellLog=ObjWellLogs[i];
        delete pWellLog;
        pWellLog=NULL;
    }
    Well* well=v->GetWellInfo();
    MyWelllogRound* r=v->GetWellLogRoundInfo();
    QString WellName=well->GetName().c_str();//取的谁的名字？跟踪遇见的都是空
	
    // if(WellName==""){//应用当前选中井名
    //     QAction* ImportConvertorWellLogDataAct= ::GetGlobalCommand().GetAction(GetCmdID_ImportConvertorWellLogData(),true) ;
    //     WellName = ImportConvertorWellLogDataAct->property("CurrentWellName").value<QString>();
    // }

    //whp change 2020.2.18 for 汉字井名转换有乱码
    if(WellName=="") WellName=QString(QString::fromLocal8Bit(v->FILE_MESSAGE.WellName)); //QLatin1String(v->FILE_MESSAGE.WellName);//for 带有井名信息的原始数据，如ASCII
    //该语句不可用，发现clis文件中的井名
    //add end
    if(WellName=="") WellName=r->GetName().c_str();
    QString strWellName;
    // CObjProject *pProject = ::GetProject();
    // if(pProject != NULL)
    // {
    //     strWellName = pProject->GetName();
    // }
    strWellName = g_prjname;
    QString dir0,dir=::GetLogdataPath();//whp add 2020.2.19 for 非法井名，无法产生井目录
    QDir w;
    if(!strWellName.isEmpty()) {
        dir=dir+strWellName;
        bool ok=w.mkdir(dir);
        dir+=QDir::separator();
    }
    QString	tempWellName;
    QString filename=r->GetName().c_str();
    if(filename=="") filename=WellName;
    //whp add 2020.3.3 删除井名中的空格
    WellName.replace(" ","");
    WellName=WellName.toUpper();
    //whp add 2020.3.3 删除".zh"之类的后缀之类的后缀
    QFileInfo temDir(WellName);
    WellName=temDir.baseName();

//////
    char *pmessage=v->GetfileMessage();
    if(pmessage) {
        char *p=pmessage;
        p+=strlen(p)+1;
        if(strlen(p)>0&&strlen(p)<20) {
            p+=strlen(p)+1;
            p+=strlen(p)+1;
            tempWellName=p;
        }
        else tempWellName="";
    }
    //whp change 2020.2.18 for 文件名中有一个以上的“."时，如3Oq.ZH.716
    //QFileInfo temDir(filename);
    //if(tempWellName=="") tempWellName=temDir.completeBaseName();
    if(tempWellName=="") tempWellName=filename;
    QString outputfilename=GetOutName(WellName,tempWellName);
    if(outputfilename=="")
    {
        dir0=dir;//whp add 2020.2.19 for 非法井名，无法产生井目录
        dir+="#"+WellName;
        bool ok=w.mkdir(dir);
        //whp add 2020.2.19 for 非法井名，无法产生井目录
        QDir mdir(dir);
        if(mdir.exists())ok=1;
        if(!ok)
        {
            dir=dir0;
            QFileInfo temDir(iFile);
            WellName=temDir.completeBaseName();
            outputfilename=GetOutName(WellName,tempWellName);
            if(outputfilename=="")
            {
                dir+="#"+WellName;
                ok=w.mkdir(dir);
                if(!ok)
                {
                    QString mes="解编"+iFile+"文件时，产生井文件目录失败：\r\n井文件目录:"+dir;
                    QMessageBox::about(NULL, QObject::tr("警告"), mes);
                    return "";
                }
                outputfilename=dir;
                outputfilename+=QDir::separator();
                outputfilename+=tempWellName;
                outputfilename+=".slf";
            }
        }
        else outputfilename=dir+QDir::separator()+tempWellName+".slf";
    }
    char *outfile = new char[outputfilename.toStdString().size()+200];
    strcpy(outfile, outputfilename.toStdString().c_str());

/*	//whp add 2019.12.10 for 如果文件存在，提示是否覆盖
    QFileInfo mfi(outfile);
    //2020.3.19
    if(mfi.isFile())
    {
		
        if(CDataImport::flag_check)//&&CDataImport::flag1!=-1)
        {
            if(CDataImport::flag1==QMessageBox::Cancel)return "abandoned";//放弃加载
            else if(CDataImport::flag1==QMessageBox::No){
                QDir ss;ss.remove(outfile);
            }
        }
        else //if(mfi.isFile())
        {//whp change 2020.2.28
            QMessageBox box(QMessageBox::Warning,"提示","输出文件"+QString::fromLocal8Bit(outfile)+"已存在!");
            //box.setStandardButtons (QMessageBox::Yes|QMessageBox::No|QMessageBox::Cancel|QMessageBox::YesAll|QMessageBox::NoAll|QMessageBox::Apply);
            box.setStandardButtons (QMessageBox::Yes|QMessageBox::Cancel|QMessageBox::YesAll|QMessageBox::Apply);
            box.setButtonText (QMessageBox::Yes,QString("覆盖当前"));//\r\n已存在文件"));
            //	box.setButtonText (QMessageBox::No,QString("重建\r\n当前文件"));
            box.setButtonText (QMessageBox::YesAll,QString("覆盖所有"));//\r\n已存在文件"));
            //	box.setButtonText (QMessageBox::NoAll,QString("全部\r\n执行重建"));
            box.setButtonText (QMessageBox::Cancel,QString("放弃当前"));//\r\n文件解编"));
            box.setButtonText (QMessageBox::Apply,QString("放弃所有"));//\r\n已存在文件解编"));
            int ret=box.exec();
            if(ret==QMessageBox::YesAll||ret==QMessageBox::Yes) CDataImport::flag1 =QMessageBox::Yes;
            //if(ret==QMessageBox::NoAll||ret==QMessageBox::No) CDataImport::flag1 =QMessageBox::No;
            if(ret==QMessageBox::Cancel||ret==QMessageBox::Apply) CDataImport::flag1 =QMessageBox::Cancel;
            //if(ret==QMessageBox::NoAll||ret==QMessageBox::YesAll||ret==QMessageBox::Apply) CDataImport::flag_check=1;
            if(ret==QMessageBox::YesAll||ret==QMessageBox::Apply) CDataImport::flag_check=1;
            if(CDataImport::flag1==QMessageBox::Cancel)return "abandoned";//放弃加载
            //else if(CDataImport::flag1==QMessageBox::No)QDir ss;ss.remove(outfile);
        }
    }
    //add end*/
    char *logfilename = new char[iFile.toStdString().size()+1];

    strcpy(logfilename, iFile.toStdString().c_str());

    int l=strlen(outfile)+1;
    double x=well->GetXCode();
    strcpy(&outfile[l],QString::number(x).toStdString().c_str());//x坐标
    double y=well->GetYCode();
    l+=strlen(&outfile[l])+1;
    strcpy(&outfile[l],QString::number(y).toStdString().c_str());//y坐标

    QString top="-99999.";//QString::number(r->GetTopDepth());
    l+=strlen(&outfile[l])+1;
    strcpy(&outfile[l],top.toStdString().c_str());//y坐标

    QString bottom="-99999.";//QString::number(r->GetBottomDepth());
    l+=strlen(&outfile[l])+1;
    strcpy(&outfile[l],bottom.toStdString().c_str());//y坐标
    l+=strlen(&outfile[l])+1;
    int iRow=v->GetWellCurves().Curve_Num;
    *(int *)&outfile[l]=iRow;
    //TODO
    vector<int> OutCurveNo;
    vector<char*> OutCurve=v->GetCurveNames();
    vector<char*> strChineseName=v->GetCurveNames();
    vector<char*> strUnit=v->GetCurveUnits();
    for(int i=0;i<OutCurve.size();i++) {
        OutCurveNo.push_back(i);
    }

    CMemRdWt *logio=new CMemRdWt();
    QString qss=outfile;
    //whp add 2020.7.16 for 按导入对象提示
    //如果文件存在,检查输出对象是否存在
    QFileInfo mfi(outfile);
    if(mfi.isFile())//
    {
        vector<int> ExistCurveNo;
        vector<char*> ExistCurve;
        int ExistCurveNum=0;
        logio->Open(qss.toStdString().c_str(),CSlfIO::modeRead);
        for(int i=0;i<iRow;i++)
        {
            int nn=logio->FindObjectName(OutCurve[i]);
            if(logio->FindObjectName(OutCurve[i],-1,-1,OBJECT_NORMAL)<0)continue;
            ExistCurve.push_back(OutCurve[i]);
            ExistCurveNo.push_back(i);
        }
        if(ExistCurve.size()>0)//输出对象是否存在
        {
            if(!CDataImport::flag_check)
            {
                QString name=qss;
                int index=name.lastIndexOf("/");
                int index1=name.lastIndexOf("\\");
                if(index1>index)index=index1;
                name=name.mid(index+1);
                name=name.left(name.lastIndexOf("."));
                Slf_FILE_MESSAGE mes;
                logio->GetFileMessage(mes);
                QString m_WellAndRound=QString::fromLocal8Bit(mes.WellName)+"井"+name;
                TiShiDialog *dlg=new TiShiDialog(NULL);
                dlg->init(ExistCurve,m_WellAndRound);//qss);
				
                if(dlg->exec()==QDialog::Accepted)
                {
                    CDataImport::flag1=dlg->flag;
                    CDataImport::m_flag=dlg->flag;
                    CDataImport::flag_check=dlg->check;
                }
            }
            int mflag=CDataImport::m_flag;
            if(mflag==0)//跳过
            {
                for(int i=0;i<ExistCurve.size();i++)
                {
                    int nn=ExistCurveNo[i];
                    OutCurveNo[ExistCurveNo[i]]=-1;
                }
            }
            else if(mflag==1)//替换
            {
                for(int i=0;i<ExistCurve.size();i++)
                {
                    logio->DiscardObject(ExistCurve[i]);
                }
            }
            else if(mflag==3)//另存
            {
                QStringList OutCurveList;
                for(int i=0;i<logio->GetObjectCount();i++)
                {
                    char name[64];
                    if(logio->GetObjectStatus(i)!=OBJECT_NORMAL)continue;
                    logio->GetObjectName(i,name);
                    OutCurveList.append(QString(name));
                }
                for(int i=0;i<ExistCurve.size();i++)
                {
                    QString name1,name=QString(ExistCurve[i])+"_";
                    for(int j=0;j<100;j++)
                    {
                        name1=name+QString::number(j+1);
                        if(OutCurveList.indexOf(name1)<0)break;
                    }
                    char *temp = new char[name1.toStdString().size()+1];
                    strcpy(temp, name1.toStdString().c_str());
                    strcpy(OutCurve[ExistCurveNo[i]],temp);
                    delete temp;
                }
            }
            if(mflag=0&&ExistCurve.size()==iRow)
            {
                delete logio;
                return "abandoned";//放弃加载
            }
        }
        logio->Close();
    }
//	bool CheckExistCurve(QString outputfilename,int NumLog,vector<int>& OutCurveNo,vector<char*>& OutCurve);
	

    if(logio->Open(qss.toStdString().c_str(),CSlfIO::modeRead))
    {
        Slf_FILE_MESSAGE FILE_MESSAGE=v->FILE_MESSAGE;
        logio->GetFileMessage(v->FILE_MESSAGE);

        if(v->FILE_MESSAGE.Xcoor!=FILE_MESSAGE.Xcoor) {
            if(FILE_MESSAGE.Xcoor!=0) v->FILE_MESSAGE.Xcoor=FILE_MESSAGE.Xcoor;
        }
        if(v->FILE_MESSAGE.Ycoor!=FILE_MESSAGE.Ycoor) {
            if(FILE_MESSAGE.Ycoor!=0) v->FILE_MESSAGE.Ycoor=FILE_MESSAGE.Ycoor;
        }
        if(v->FILE_MESSAGE.Altitude!=FILE_MESSAGE.Altitude) {
            if(FILE_MESSAGE.Altitude!=0) v->FILE_MESSAGE.Altitude=FILE_MESSAGE.Altitude;
        }
        if(v->FILE_MESSAGE.Kelly!=FILE_MESSAGE.Kelly) {
            if(FILE_MESSAGE.Kelly!=0) v->FILE_MESSAGE.Kelly=FILE_MESSAGE.Kelly;
        }
        if(v->FILE_MESSAGE.TVD!=FILE_MESSAGE.TVD) {
            if(FILE_MESSAGE.TVD!=0) v->FILE_MESSAGE.TVD=FILE_MESSAGE.TVD;
        }
        if(v->FILE_MESSAGE.X0!=FILE_MESSAGE.X0) {
            if(FILE_MESSAGE.X0!=0) v->FILE_MESSAGE.X0=FILE_MESSAGE.X0;
        }
        if(v->FILE_MESSAGE.Y0!=FILE_MESSAGE.Y0) {
            if(FILE_MESSAGE.Y0!=0) v->FILE_MESSAGE.Y0=FILE_MESSAGE.Y0;
        }
        if(v->FILE_MESSAGE.Z0!=FILE_MESSAGE.Z0) {
            if(FILE_MESSAGE.Z0!=0) v->FILE_MESSAGE.Z0=FILE_MESSAGE.Z0;
        }
        int indexSTable=-1;
        int indexDTable=-1;
        if(logio->FindObjectIndex("井基本信息")>-1) {
            WELL_STATIC_INFO WellStaticInfo=v->WellStaticInfo;

            indexSTable=logio->OpenSTATIC("井基本信息");
            logio->ReadTable(indexSTable,1,&v->WellStaticInfo);//inf);
            if(v->WellStaticInfo.XCoor!=WellStaticInfo.XCoor) {
                if(WellStaticInfo.XCoor!=0) v->WellStaticInfo.XCoor=WellStaticInfo.XCoor;
            }
            if(v->WellStaticInfo.YCoor!=WellStaticInfo.YCoor) {
                if(WellStaticInfo.YCoor!=0) v->WellStaticInfo.YCoor=WellStaticInfo.YCoor;
            }
            if(v->WellStaticInfo.As1!=WellStaticInfo.As1) {
                if(WellStaticInfo.As1!=0) v->WellStaticInfo.As1=WellStaticInfo.As1;
            }
            if(v->WellStaticInfo.Bs1!=WellStaticInfo.Bs1) {
                if(WellStaticInfo.Bs1!=0) v->WellStaticInfo.Bs1=WellStaticInfo.Bs1;
            }
            logio->CloseTable(indexSTable);
        }
        if(logio->FindObjectIndex("测井信息")>-1) {
            WELL_DYNAMIC_INFO WellDynamicInfo;
            indexDTable=logio->OpenDYNAMIC("测井信息");
            logio->ReadTable(indexDTable,1,&v->WellDynamicInfo);//inf);
            logio->CloseTable(indexDTable);
        }
    }
    delete logio;
    //v->Transfer(logfilename,outfile,&OutCurveNo[0],&OutCurve[0],&strChineseName[0],&strUnit[0],iRow);
    //whp change 2019.12.10 for写入井名
    if(v->Transfer(logfilename,outfile,&OutCurveNo[0],&OutCurve[0],&strChineseName[0],&strUnit[0],iRow))
    {
        CLogIO * logio=new CLogIO();
        logio->Open(outfile,CSlfIO::modeReadWrite);
        Slf_FILE_MESSAGE mssage;
        logio->GetFileMessage(mssage);
        strcpy(mssage.WellName,WellName.toStdString().c_str());
        logio->SetFileMessage(mssage);
        delete logio;
    }
    else return "";//whp add 2019.12.12
    //whp change 2020.2.18 for 汉字井名转换有乱码
    QString slfname=QString(QString::fromLocal8Bit(outfile));//QString(QLatin1String(outfile));
    delete []logfilename;
    delete []outfile;
    //return 1;////whp add 2019.12.08 for 输出成功加载的文件个数
    return  slfname;//whp change 2019.12.12
}
QStringList CDataImport::GetFileNames(const QString &caption ,	const QString &filter,QFileDialog::FileMode filemode )
{
    static QString path=::GetDataPath();
    QStringList sts=QFileDialog::getOpenFileNames(NULL,caption,path,filter);
    if(sts.size()) path=sts[0];
    return sts;
// 	QFileDialog * fileDlg=new QFileDialog();
// 	fileDlg->setFileMode(filemode);
// 	QStringList listFiles;
// 	if(fileDlg->exec()==QFileDialog::Accepted)
// 	{
// 		listFiles=fileDlg->selectedFiles();
// 	}
// 	delete fileDlg;
// 	return listFiles;
}
void CDataImport::OutPutWellXYCoordinate()
{
    // //井名	磁偏角	南北（小）	东西（大）	测量深度	地面海拔	补心高	TVD	东西位移	南北位移
    // //a	0	4394427.9	19308473.9	0	1446.9	0	0	0	0
    // //b	0	4394427.9	19308473.9	0	1446.9	0	0	0	0
    // //c	0	4398164.3	19306076.3	0	1436.5	0	0	0	0
    // //d	0	4398270.1	19311098.4	0	1437.5	0	0	0	0
    // //e	0	4392057.3	19305209.1	0	1461.3	0	0	0	0
    // QString strFileName =QFileDialog::getSaveFileName( NULL,"导出工区井坐标为TXT",::GetOutDataPath(),"文件(*.txt)");
    // FILE *fp=fopen(strFileName.toStdString().c_str(),"wt");
    // if(!fp) return;
    // fprintf(fp,"磁偏角	南北（小）	东西（大）	测量深度	地面海拔	补心高	TVD	东西位移	南北位移\m");
    // int flag=0;
    // CObjProject *pPrj=::GetProject();
    // if(!pPrj) return;
    // PaiObject *pObj=pPrj->GetObjectByType(GetClassID_WellsFolder());
    // if(!pObj) return;
    // QList<PaiObject *> childs;
    // pObj->GetChildren(childs);
    // std::vector<QString> wellnames;
    // foreach(PaiObject *pChild,childs) {
    //     CObjWell *pWell=dynamic_cast<CObjWell*>(pChild);
    //     if(pWell)
    //     {
    //         QString ss=pWell->GetWellFileName();
    //         QString wellname,path;
    //         GetWellNameAndPath(ss,wellname,path);
    //         WellHead &hd=pWell->GetWellHead();
    //         fprintf(fp,"%s\t%10.3f\t%10.3f\t%10.3f\t%10.3f\t%10.3f\t%10.3f\t%10.3f\t%10.3f\t%10.3f\t\n",
    //             hd.wellName.toStdString().c_str(),
    //             //井名	磁偏角	南北（小）	东西（大）	测量深度	地面海拔	补心高	TVD	东西位移	南北位移
    //             hd.azca,
    //             hd.x,
    //             hd.y,
    //             hd.depth,
    //             hd.earthEle,
    //             hd.dEle,
    //             hd.tvd,
    //             hd._HorizBoreXE,
    //             hd._HorizBoreYN);
    //     }
    // }
    // fclose(fp);
    // QMessageBox::warning(NULL,"提示",QString("井位信息保存完成！"));
}

void CDataImport::ImportWellXYCoordinate()
{
// //井名	磁偏角	南北（小）	东西（大）	测量深度	地面海拔	补心高	TVD	东西位移	南北位移
// //a	0	4394427.9	19308473.9	0	1446.9	0	0	0	0
// //b	0	4394427.9	19308473.9	0	1446.9	0	0	0	0
// //c	0	4398164.3	19306076.3	0	1436.5	0	0	0	0
// //d	0	4398270.1	19311098.4	0	1437.5	0	0	0	0
// //e	0	4392057.3	19305209.1	0	1461.3	0	0	0	0


//     QStringList listFiles=GetFileNames("选择工区井井位信息","数据文件(*.prn;*.txt)");
//     if(!listFiles.size())
//     {
//         return;
//     }
//     int flag=0;
//     foreach(QString strFileName, listFiles)
//     {
//         QFile file(strFileName);
//         if (!file.open(QIODevice::ReadOnly ))
//         {
//             continue;
//         }
//         flag=0;
//         QTextStream in(&file);
//         QString lineString  = in.readLine();
//         QStringList LineStringList = lineString.split(",");
//         if(LineStringList.size()==1) LineStringList = lineString.split("	");
//         if(LineStringList.size()==1) LineStringList = lineString.split(" ");
//         LineStringList.removeAll("");
//         LineStringList.removeAll(" ");
//         for (int i=0;i<LineStringList.size();i++)
//         {
//             while(LineStringList[i].indexOf("\t")>-1) LineStringList[i]=LineStringList[i].replace("\t","");
//             LineStringList[i]=LineStringList[i].trimmed();
//         }
//         QString strWellName=LineStringList[0];
//         if(strWellName.indexOf("wellname",0,Qt::CaseInsensitive)>=0||
//             strWellName.indexOf("井名",0,Qt::CaseInsensitive)>=0
//             ) {
//             flag=1;
//         }
//         while ( !in.atEnd() )
//         {
//             lineString  = in.readLine();
//             if(lineString.isEmpty()) continue;
//             LineStringList = lineString.split(",");
//             if(LineStringList.size()==1) LineStringList = lineString.split("	");
//             if(LineStringList.size()==1) LineStringList = lineString.split(" ");
//             LineStringList.removeAll("");
//             LineStringList.removeAll(" ");
//             for (int i=0;i<LineStringList.size();i++)
//             {
//                 while(LineStringList[i].indexOf("\t")>-1) LineStringList[i]=LineStringList[i].replace("\t","");
//                 LineStringList[i]=LineStringList[i].trimmed();
//             }
//             if(LineStringList.size()<1) continue;
//             LineStringList.replaceInStrings("-9999.0","0");
//             LineStringList.replaceInStrings("-9999","0");
//             if(flag) {
//                 CObjWell * pWell = CDataImport::GetWellByName(LineStringList[0]);
//                 if(!pWell) continue;
//                 //井名	磁偏角	南北（小）	东西（大）	测量深度	地面海拔	补心高	TVD	东西位移	南北位移
//                 //  0      1        2          3            4           5          6     7     8            9
//                 WellHead &wh=pWell->GetWellHead();
//                 if(LineStringList.size()>1)wh.azca=LineStringList[1].toDouble();
//                 if(LineStringList.size()>2)wh.y=LineStringList[2].toDouble();
//                 if(LineStringList.size()>3)wh.x=LineStringList[3].toDouble();
//                 if(LineStringList.size()>4)wh.depth=LineStringList[4].toDouble();
//                 if(LineStringList.size()>5)wh.earthEle=LineStringList[5].toDouble();
//                 if(LineStringList.size()>6){
//                     wh.dEle=LineStringList[6].toDouble();
//                     if(wh.dEle==-9999) wh.dEle=0;
//                 }
//                 if(LineStringList.size()>7)wh.tvd=LineStringList[7].toDouble();
//                 if(LineStringList.size()>8)wh.dyn=LineStringList[8].toDouble();
//                 if(LineStringList.size()>9)wh.dxe=LineStringList[9].toDouble();
//                 wh.z=wh.earthEle-wh.tvd+wh.dEle;
//                 if(pWell->GetWellFileName().isEmpty()) {
//                     QString fi=GetLogdataPath()+GetProject()->GetName()+"\\#"+LineStringList[0];
//                     CreateDir((char *)fi.toStdString().c_str());
//                     fi+="\\"+LineStringList[0]+".slf";
//                     pWell->SetWellFileName(fi);
//                 }
//                 pWell->SaveWellHead(pWell->GetWellFileName());
//                 QList<PaiObject*>  wellroundchildren;
//                 int count=pWell->GetAllWellRound(wellroundchildren);
//                 for(int i=0;i<count;i++) {
//                     CObjWelllogRound *pWR=dynamic_cast<CObjWelllogRound *>(wellroundchildren[i]);
//                     pWell->SaveWellHead(pWR->GetSlfFileName());
//                 }
//             }
//             else {
//             }
//         }
//     }
//     AfxMessageBox("导入完成！");
}
void CDataImport::ImportGeoStraData()
{
    // QStringList listFiles=GetFileNames("选择工区层位数据","数据文件(*.prn;*.txt)");
    // if(listFiles.size()<1) return;
    // int flag=0;
    // std::vector<QString> wellNameVec;
    // QList<QString> layerNameVec;
    // std::vector<float> topDetphVec;
    // std::vector<float> bottomDepthVec;
    // foreach(QString strFileName, listFiles)
    // {
    //     QFile file(strFileName);
    //     if (!file.open(QIODevice::ReadOnly ))
    //     {
    //         continue;
    //     }
    //     flag=0;
    //     QTextStream in(&file);
    //     QString lineString  = in.readLine();
    //     QStringList LineStringList = lineString.split(",");
    //     if(LineStringList.size()==1) LineStringList = lineString.split("	");
    //     if(LineStringList.size()==1) LineStringList = lineString.split(" ");
    //     LineStringList.removeAll("");
    //     LineStringList.removeAll(" ");
    //     for (int i=0;i<LineStringList.size();i++)
    //     {
    //         while(LineStringList[i].indexOf("\t")>-1) LineStringList[i]=LineStringList[i].replace("\t","");
    //         LineStringList[i]=LineStringList[i].trimmed();
    //     }
    //     if(LineStringList.size()<1) continue;
    //     QString strWellName = LineStringList[0] ;
    //     if(strWellName.indexOf("wellname",0,Qt::CaseInsensitive)>=0||
    //         strWellName.indexOf("井名",0,Qt::CaseInsensitive)>=0
    //         ) {
    //         flag=1;
    //         for(int i=1;i<LineStringList.size();i++) {
    //             if(i<2&&layerNameVec.indexOf(LineStringList[i])>-1) {
    //                 flag=2;
    //                 continue;
    //             }
    //             layerNameVec.push_back(LineStringList[i]);
    //         }
    //     }
    //     while ( !in.atEnd() )
    //     {
    //         lineString  = in.readLine();
    //         LineStringList = lineString.split(",");
    //         if(LineStringList.size()==1) LineStringList = lineString.split("	");
    //         if(LineStringList.size()==1) LineStringList = lineString.split(" ");
    //         LineStringList.removeAll(" ");
    //         LineStringList.removeAll("");
    //         for (int i=0;i<LineStringList.size();i++)
    //         {
    //             while(LineStringList[i].indexOf("\t")>-1) LineStringList[i]=LineStringList[i].replace("\t","");
    //             LineStringList[i]=LineStringList[i].trimmed();
    //         }
    //         if(LineStringList.size()<1) continue;
    //         if(flag) {
    //             wellNameVec.push_back(LineStringList[0]);
    //             if(flag==1) {
    //                 for(int i=2;i<LineStringList.size();i++) {
    //                     topDetphVec.push_back(LineStringList[i-1].toFloat());
    //                     bottomDepthVec.push_back(LineStringList[i].toFloat());
    //                 }
    //             }
    //             else	{
    //                 for(int i=1;i<layerNameVec.size()*2;i+=2) {
    //                     if(LineStringList.size()<=i) continue;
    //                     topDetphVec.push_back(LineStringList[i].toFloat());
    //                     bottomDepthVec.push_back(LineStringList[i+1].toFloat());
    //                 }
    //             }
    //         }
    //         else {
    //             wellNameVec.push_back(LineStringList[0]);
    //             layerNameVec.push_back(LineStringList[1]);
    //             topDetphVec.push_back(LineStringList[2].toFloat());
    //             bottomDepthVec.push_back(LineStringList[3].toFloat());
    //         }
    //     }
    // }
    // for(int i=0;i<wellNameVec.size();i++)
    // {
    //     CObjWell * pWell = CDataImport::GetWellByName(wellNameVec[i]);
    //     if(!pWell) continue;
    //     if(pWell->GetWellFileName().isEmpty()) {
    //         QString fi=GetLogdataPath()+GetProject()->GetName()+"\\#"+wellNameVec[i];
    //         CreateDir((char *)fi.toStdString().c_str());
    //         fi+="\\"+wellNameVec[i]+".slf";
    //         pWell->SetWellFileName(fi);
    //     }
    //     CObjGeostratums* pGeostratum = dynamic_cast<CObjGeostratums*>(pWell->GetObjectByType(GetClassID_OGGeostratums(), 2));
    //     if(!pGeostratum) {
    //         pGeostratum = new CObjGeostratums();
    //         pGeostratum->SetName("LAYER_DATA");
    //         pWell->AddChild( pGeostratum );
    //     }
    //     if (flag1==QMessageBox::Yes) {
    //         pGeostratum->ClearItems();
    //     }
    //     pGeostratum->SetSlfFileName(pWell->GetWellFileName());
    //     int index = 0;
    //     if(flag) {
    //         int size=layerNameVec.size()-1;
    //         if(flag==2) size=layerNameVec.size();
    //         for(int j=0;j<size;j++) {
    //             float top=topDetphVec[i*(size)+j];
    //             float bottom=bottomDepthVec[i*(size)+j];
    //             if(top==-9999||bottom==-9999) continue;
    //             pai::datamodel::WelllogItem* pItem =pGeostratum->GetItemByName(layerNameVec[j]);
    //             if(!pItem) {
    //                 pItem = pGeostratum->AddItem(top,bottom);
    //                 OGGeostratumItem * pGeoItem = dynamic_cast<OGGeostratumItem*>(pItem);
    //                 if(pGeoItem) {
    //                     pGeoItem->SetName(layerNameVec[j]);
    //                     pGeoItem->SetDEST(layerNameVec[j]);
    //                     pGeoItem->SetSDEP(top);
    //                     pGeoItem->SetEDEP(bottom);
    //                 }
    //             }
    //             else {
    //                 OGGeostratumItem * pGeoItem = dynamic_cast<OGGeostratumItem*>(pItem);
    //                 {
    //                     pGeoItem->SetTopDepth(top);
    //                     pGeoItem->SetBottomDepth(bottom);
    //                     pGeoItem->SetSDEP(top);
    //                     pGeoItem->SetEDEP(bottom);
    //                     pGeoItem->SetDEST(layerNameVec[j]);
    //                 }
    //             }
    //         }
    //     }
    //     else {
    //         if(topDetphVec[i]==-9999||bottomDepthVec[i]==-9999) continue;
    //         pai::datamodel::WelllogItem* pItem =pGeostratum->GetItemByName(layerNameVec[i]);
    //         if(!pItem) {
    //             pItem = pGeostratum->AddItem(topDetphVec[i],bottomDepthVec[i]);
    //             OGGeostratumItem * pGeoItem = dynamic_cast<OGGeostratumItem*>(pItem);
    //             pGeoItem->SetName(layerNameVec[i]);
    //             pGeoItem->SetDEST(layerNameVec[i]);
    //             pGeoItem->SetSDEP(topDetphVec[i]);
    //             pGeoItem->SetEDEP(bottomDepthVec[i]);
    //         }
    //         else {
    //             OGGeostratumItem * pGeoItem = dynamic_cast<OGGeostratumItem*>(pItem);
    //             pGeoItem->SetTopDepth(topDetphVec[i]);
    //             pGeoItem->SetBottomDepth(bottomDepthVec[i]);
    //             pGeoItem->SetSDEP(topDetphVec[i]);
    //             pGeoItem->SetEDEP(bottomDepthVec[i]);
    //             pGeoItem->SetDEST(layerNameVec[i]);
    //         }
    //     }
    //     pGeostratum->SaveToSLF();
    // }

    // AfxMessageBox("导入分层完成！");
}

void CDataImport::OutPutGeoStraData()
{
//     QString strFileName =QFileDialog::getSaveFileName( NULL,"输出层位数据为TXT",::GetOutDataPath(),
//                 "文件(*.txt)");
//     int flag=0;
//     std::vector<QString> wellNameVec;
//     std::vector<QString> layerNameVec;
//     std::vector<float> topDetphVec;
//     std::vector<float> bottomDepthVec;

//     CObjProject *pPrj=::GetProject();
//     if(!pPrj) return;
//     PaiObject *pObj=pPrj->GetObjectByType(GetClassID_WellsFolder());
//     if(!pObj) return;
//     QList<PaiObject *> childs;
//     pObj->GetChildren(childs);
//     QStringList LayerNameVec;
//     std::vector<QStringList>LayerNameVecS;
//     std::vector<std::vector<float>> TopDepthVecS;
//     std::vector<std::vector<float>> BottomDepthVecS;
//     std::vector<QString> wellnames;
//     foreach(PaiObject *pChild,childs) {
//         CObjWell *pWell=dynamic_cast<CObjWell*>(pChild);
//         if(pWell) {
//             QString ss=pWell->GetWellFileName();
//             if(!ss.isEmpty()) {
//                 QString name="LAYER_DATA";
//                 LAYER_DATA m_Result;
//                 CLogIO *logio=new CLogIO();
//                 if(!logio->Open(ss.toStdString().c_str(),CSlfIO::modeRead))
//                 {
//                     delete logio;
//                     return;
//                 }
//                 int iIndex=logio->OpenTable(name.toStdString().c_str());
//                 if (iIndex >=0)
//                 {
//                     wellnames.push_back(pWell->GetName());
//                     QStringList layerNameVec;
//                     std::vector<float> TopDepthVec;
//                     std::vector<float> BottomDepthVec;
//                     int count=logio->GetTableRecordCount(iIndex);
//                     for(int j=0;j<count;j++) {
//                         memset(&m_Result,0,sizeof(LAYER_DATA));
//                         logio->ReadTable(iIndex,j+1,&m_Result);
//                         char buf[490];
//                         GetDescription(m_Result,buf);
//                         if(!strlen(buf)) continue;
//                         if(!LayerNameVec.contains(buf)) LayerNameVec.append(buf);
//                         layerNameVec.append(buf);
//                         TopDepthVec.push_back(m_Result.StartDepth);
//                         BottomDepthVec.push_back(m_Result.EndDepth);
//                     }
//                     LayerNameVecS.push_back(layerNameVec);
//                     TopDepthVecS.push_back(TopDepthVec);
//                     BottomDepthVecS.push_back(BottomDepthVec);
//                 }
//                 delete logio;
//             }
//         }
//     }
//     FILE *fp=fopen(strFileName.toStdString().c_str(),"wt");
//     if(!fp) return;
//     fprintf(fp,"%s","wellname\t");
//     for(int j=0;j<LayerNameVec.size();j++) {
//         fprintf(fp,"%s\t%s",LayerNameVec[j].toStdString().c_str(),LayerNameVec[j].toStdString().c_str());
//         if(j!=LayerNameVec.size()-1) fprintf(fp,"%s","\t");
//         else fprintf(fp,"%s","\n");
//     }
//     for(int i=0;i<wellnames.size();i++) {
//         fprintf(fp,"%s\t",wellnames[i].toStdString().c_str());
//         for(int j=0;j<LayerNameVec.size();j++) {
//             int pos=LayerNameVecS[i].indexOf(LayerNameVec[j]);
//             if(pos>-1)	{
// //				if(j!=LayerNameVec.size())
//                     fprintf(fp,"%10.3f\t%10.3f",TopDepthVecS[i][pos],BottomDepthVecS[i][pos]);
// //				else fprintf(fp,"%10.3f",BottomDepthVecS[i][pos]);
//             }
//             else fprintf(fp,"%10.3f\t%10.3f",-9999.0,-9999.0);
//             if(j!=LayerNameVec.size()-1) fprintf(fp,"%s","\t");
//             else fprintf(fp,"%s","\n");
//         }
//     }
//     fclose(fp);
//     QMessageBox::warning(NULL,"提示",QString("分层数据保存完成！"));
}

// END_OSGGRAPHICS_NAMESPACE