//////////////////////////////////////////////////////////////////
///
///   测录井信息综合平台
///
///   编制：王卫
///
///   版权：中国石化集团石油工程技术研究院
///
///   2010年10月-
///
// Depth.cpp : implementation file
//
#include "DepPairs.h"
#include "MemRdWt.h"
#include "math.h"
#include "BaseFun.h"
#include "geometryutils.h"
#include <qdir.h>
#include "qapplication.h"
#include <QMessageBox.h>

int GetDepPairs(float* curve1,float stdep1,float endep1,float rlev1,
    float* curve2,float stdep2,float endep2,float rlev2,float cmins,
    float winLength,float stepLength, float searchLength,
    float *FirstDep,
    float *SecondDep,
    float *corc)
{
    DepPairs depPairs(curve1,stdep1,endep1,rlev1,
    curve2,stdep2,endep2,rlev2,cmins,
    winLength,stepLength,searchLength);
    depPairs.FirstDep=FirstDep;
    depPairs.SecondDep=SecondDep;
    depPairs.corc=corc;

    float stdep=FirstDep[0];
    float endep=SecondDep[0];
    if(stdep==endep){
        stdep=stdep1;
        endep=endep1;

        stdep=stdep1;
        if(stdep>stdep2) stdep=stdep2;

        endep=endep1;
        if(endep<endep2) endep=endep2;
    }
    depPairs.StartDepth=stdep;
    depPairs.EndDepth=endep;

    return depPairs.AdmRun(curve1,curve2,NULL);
}
int getDepPairs(float* curve1,float stdep1,float endep1,float rlev1,
    float* curve2,float stdep2,float endep2,float rlev2,
    float *FirstDep,
    float *SecondDep)
{
    DepPairs depPairs(curve1,stdep1,endep1,rlev1,
        curve2,stdep2,endep2,rlev2,NULL,
        0,0,0);
    depPairs.FirstDep=FirstDep;
    depPairs.SecondDep=SecondDep;
    depPairs.corc=NULL;

    float stdep=FirstDep[0];
    float endep=SecondDep[0];
    if(stdep==endep){
        stdep=stdep1;
        endep=endep1;

        stdep=stdep1;
        if(stdep>stdep2) stdep=stdep2;

        endep=endep1;
        if(endep<endep2) endep=endep2;
    }
    depPairs.StartDepth=stdep;
    depPairs.EndDepth=endep;
    depPairs.ipar=1;
    return depPairs.AdmRun(curve1,curve2,NULL);
}
int AutoCompZone(char *Filename,char *Filename1,char *CurveName1,char *CurveName2,
    float *FirstDep,
    float *SecondDep)
{
    CMemRdWt well;
    if(!well.Open(Filename,CMemRdWt::modeRead)) {
        return 0;
    };

    CMemRdWt well1;
    if(!well1.Open(Filename1,CMemRdWt::modeRead)) {
        return 0;
    }

    int index=well.OpenCurve(CurveName1);
    int index1=well1.OpenCurve(CurveName2);
    if(index>-1&&index1>-1) {
        Slf_CURVE curve,curve1;
        well.GetCurveInfo(index,&curve);
        int count=(curve.EndDepth-curve.StartDepth)/curve.DepLevel+1.5;
        float *buffer=new float[count+1];
        well.ReadCurveToFloatBuf(index,curve.StartDepth,count,buffer);

        well1.GetCurveInfo(index1,&curve1);
        int count1=(curve1.EndDepth-curve1.StartDepth)/curve1.DepLevel+1.5;
        float *buffer1=new float[count1+1];
        well1.ReadCurveToFloatBuf(index1,curve1.StartDepth,count1,buffer1);
        int num=getDepPairs(buffer,curve.StartDepth,curve.EndDepth,curve.DepLevel,
            buffer1,curve1.StartDepth,curve1.EndDepth,curve1.DepLevel,
            FirstDep,
            SecondDep
            );
        delete buffer;
        delete buffer1;
        return num;
    }
    return 0;
}

int AutoComp(char *Filename,char *Filename1,char *CurveName1,char *CurveName2,
    float cmins,
    float winLength,float stepLength, float searchLength,
    float *FirstDep,
    float *SecondDep,
    float *corc)
{
    CMemRdWt well;
    if(!well.Open(Filename,CMemRdWt::modeRead)) {
        return 0;
    };

    CMemRdWt well1;
    if(!well1.Open(Filename1,CMemRdWt::modeRead)) {
        return 0;
    }

    int index=well.OpenCurve(CurveName1);
    int index1=well1.OpenCurve(CurveName2);
    if(index>-1&&index1>-1) {
        Slf_CURVE curve,curve1;
        well.GetCurveInfo(index,&curve);
        int count=(curve.EndDepth-curve.StartDepth)/curve.DepLevel+1.5;
        float *buffer=new float[count+1];
        well.ReadCurveToFloatBuf(index,curve.StartDepth,count,buffer);

        well1.GetCurveInfo(index1,&curve1);
        int count1=(curve1.EndDepth-curve1.StartDepth)/curve1.DepLevel+1.5;
        float *buffer1=new float[count1+1];
        well1.ReadCurveToFloatBuf(index1,curve1.StartDepth,count1,buffer1);
        int num=GetDepPairs(buffer,curve.StartDepth,curve.EndDepth,curve.DepLevel,
            buffer1,curve1.StartDepth,curve1.EndDepth,curve1.DepLevel,
            cmins,
            winLength,
            stepLength,
            searchLength,
            FirstDep,
            SecondDep,
            corc
        );
        delete buffer;
        delete buffer1;
        return num;
    }
    return 0;
}
bool AutoCompute(char *Filename,char *Filename1,char *CurveName1,char *CurveName2)
{
    CMemRdWt well;
    if(!well.Open(Filename,CMemRdWt::modeRead)) {
        return false;
    };

    CMemRdWt well1;
    if(!well1.Open(Filename1)) {
        return false;
    }

    int iIndex=well.OpenTable("OG_RESULT");
    if(iIndex<0) {
        return false;
    }

    int index=well.OpenCurve(CurveName1);
    int index1=well1.OpenCurve(CurveName2);
    if(index1>-1&&index1>-1) {
        Slf_CURVE curve,curve1;
        well.GetCurveInfo(index,&curve);
        well1.GetCurveInfo(index1,&curve1);

        int count=(curve.EndDepth-curve.StartDepth)/curve.DepLevel+1.5;
        float *buffer=new float[count+1];

        int count1=(curve1.EndDepth-curve1.StartDepth)/curve1.DepLevel+1.5;
        float *buffer1=new float[count1+1];

        well.ReadCurveToFloatBuf(index,curve.StartDepth,count,buffer);
        well1.ReadCurveToFloatBuf(index1,curve1.StartDepth,count1,buffer1);

        float cmins=0.9;
        float winLength=4;
        float stepLength=0.5;
        float searchLength=8;

        float* FirstDep=new float[5000];
        float* SecondDep=new float[5000];
        float* corc=new float[5000];

        int num=GetDepPairs(buffer,curve.StartDepth,curve.EndDepth,curve.DepLevel,
            buffer1,curve1.StartDepth,curve1.EndDepth,curve1.DepLevel,
            cmins,
            winLength,
            stepLength,
            searchLength,
            FirstDep,
            SecondDep,
            corc
        );

        delete buffer;
        delete buffer1;
        char buf[80];
        LAYER_DATA m_Result;
        int iIndex1=well1.OpenTable("RESULT");
        int len=well.GetTableRecordLength(iIndex);
        if (iIndex1 < 0)
        {
            iIndex1=well1.Open_Set_Table("RESULT",0,35,
                "NO,SDEP,EDEP,ZONE,RESULTNO,THICK,TT,MDEPTH1,MDEPTH2,MDEPTH3,MDEPTH4,MDEPTH5,MDEPTH6,MDEPTH7,MDEPTH8,MDEPTH9,MDEPTH10,OIL,POOROIL,OILWATER,WATEROIL,GAS,POORGAS,GASWATER,WATERGAS,DEST1,DEST2,DEST3,DEST4,DEST5,DEST6,DEST7,DEST8,DEST9,DEST10,SDEP1,EDEP1,SDEP2,EDEP2,SDEP3,EDEP3,SDEP4,EDEP4,SDEP5,EDEP5,SDEP6,EDEP6,SDEP7,EDEP7,SDEP8,EDEP8,SDEP9,EDEP9,SDEP10,EDEP10",
                "4,4,4,8,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,48,48,48,48,48,48,48,48,48,48,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4",//字段长度
                "1,4,4,6,1,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,6,6,6,6,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4",//字段类型
                "0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0");//字段备注
        }

        int iIndex2=well.OpenTable("RESULT");
        if (iIndex2 < 0)
        {
            iIndex2=well.Open_Set_Table("RESULT",0,35,
                "NO,SDEP,EDEP,ZONE,RESULTNO,THICK,TT,MDEPTH1,MDEPTH2,MDEPTH3,MDEPTH4,MDEPTH5,MDEPTH6,MDEPTH7,MDEPTH8,MDEPTH9,MDEPTH10,OIL,POOROIL,OILWATER,WATEROIL,GAS,POORGAS,GASWATER,WATERGAS,DEST1,DEST2,DEST3,DEST4,DEST5,DEST6,DEST7,DEST8,DEST9,DEST10,SDEP1,EDEP1,SDEP2,EDEP2,SDEP3,EDEP3,SDEP4,EDEP4,SDEP5,EDEP5,SDEP6,EDEP6,SDEP7,EDEP7,SDEP8,EDEP8,SDEP9,EDEP9,SDEP10,EDEP10",
                "4,4,4,8,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,48,48,48,48,48,48,48,48,48,48,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4",//字段长度
                "1,4,4,6,1,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,6,6,6,6,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4",//字段类型
                "0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0");//字段备注
        }
        count=well.GetTableRecordCount(iIndex);
        well.SetTableRecordCount(iIndex2,count);
        well1.SetTableRecordCount(iIndex1,count);
        int j=0;
        for(int k=0;k<count;k++) {
            well.ReadTable(iIndex,k+1,&buf);
            well.WriteTable(iIndex2,k+1,&buf);
            memmove(&m_Result,buf,sizeof(LAYER_DATA));
            if(m_Result.StartDepth<curve.StartDepth||m_Result.StartDepth>curve.EndDepth) {
                continue;
            }
            if(m_Result.EndDepth<curve.StartDepth||m_Result.EndDepth>curve.EndDepth) {
                continue;
            }
            well1.WriteTable(iIndex1,j+1,&buf);
            j++;
        }
        well1.SetTableRecordCount(iIndex1,j);
        well.CloseTable(iIndex);
        well1.CloseTable(iIndex1);
        well.CloseTable(iIndex2);

        char strName[256];
        memset(strName, 0, sizeof (strName));
        strcat(strName,"OG_RESULT1");
        well1.EShiftTableDepth(strName, num,FirstDep,SecondDep);
        delete FirstDep;
        delete SecondDep;
        delete corc;
        return true;
    }
    return false;
}

////////////////////////////////////////////////////////////////////////////
// DepPairs对象
// 显示边框
// 构造函数
DepPairs::DepPairs(float* curve1,float stdep1,float endep1,float rlev1,
    float* curve2,float stdep2,float endep2,float rlev2,float cmins,
    float winLength,float stepLength, float searchLength)
{
    Curve1.stdep=stdep1;
    Curve1.endep=endep1;
    Curve1.rlev=rlev1;
    Curve1.val=curve1;

    Curve2.stdep=stdep2;
    Curve2.endep=endep2;
    Curve2.rlev=rlev2;
    Curve2.val=curve2;

//		num=i;

    DepLevel=rlev1;
    if(DepLevel>rlev2) DepLevel=rlev2;

    StartDepth=stdep1;
    if(StartDepth>stdep2) StartDepth=stdep2;

    EndDepth=endep1;
    if(EndDepth<endep2) EndDepth=endep2;

//	int num=(EndDepth-StartDepth)/DepLevel+1.5;
    m_nDepPairsNum=0;
    wl=winLength;
    sl=searchLength;
    step=stepLength;
    dr1=3.;
    dr2=3.;
    cmin=cmins;
    elast=1.;
    emp=0;
    size=1;
    type=0;
    way=0;
    ipar=0;
    SetRef=0;
    mCurrent=-1;
    ShiftNum=0;
}
// 析构函数
DepPairs::~DepPairs()
{
}
// read depth pair from file
void DepPairs::qs(float *datx,float *daty,float *datc,int left,int right)
{
    int i,j;
    float x,y;

    i=left;j=right;
    x=datx[(left+right)/2];
    do {
        while(datx[i]<x&&i<right) i++;
        while(datx[j]>x&&j>left ) j--;
        if(i<=j) {
            y=datx[i];datx[i]=datx[j];datx[j]=y;
            y=daty[i];daty[i]=daty[j];daty[j]=y;
            y=datc[i];datc[i]=datc[j];datc[j]=y;
            i++;j--;
        }
    }while(i<=j);
    if(left<j)  qs(datx,daty,datc,left,j);
    if(i<right) qs(datx,daty,datc,i,right);
}

void DepPairs::detscl(float sdeps,float edeps)
{
    int k;
    float tempdep;
    tempdep = sdeps;
    float xmin1=99999.;
    float xmin2=99999.;
    float xmax1=-99999.;
    float xmax2=-99999.;
    k=(int)((sdeps-sdeps)/ DepLevel+0.5);
    float val=0;
    while(tempdep<edeps)
    {
        val=Curve1.GetValue(tempdep);
        if(val<xmin1) xmin1=val;
        if(val>xmax1) xmax1=val;
        val=Curve2.GetValue(tempdep);
        if(val<xmin2) xmin2=val;
        if(val>xmax2) xmax2=val;
        k++;
        tempdep=sdeps + k * DepLevel;
    }
    if(xmin1==xmax1)
    {
        xmin1=0.;
        xmax1=1.;
    }
    if(xmin2==xmax2)
    {
        xmin2=0.;
        xmax2=1.;
    }
    return;
}

float DepPairs::ampl(int n,float *x)
{
    int i;
    float xmin,xmax;
    xmin=9999.;
    xmax=-9999.;
    for(i=0;i<n;i++) {
        if(x[i]<xmin)xmin=x[i];
        if(x[i]>xmax)xmax=x[i];
    }
    return xmax-xmin;
}
float DepPairs::corr(int n,float *x,float *y,int size,int emp)
{
    float sx,sy,xave,yave,sqx,sqy,sxy,dp,dx,dy,c;
    float r1,r2,amp1,amp2,ratio;
    int i;
    sx=0.;
    sy=0.;
    for(i=0;i<n;i++) {
        sx=sx+x[i];
        sy=sy+y[i];
    }
    xave=sx/n;
    yave=sy/n;
    sqx=0.;
    sqy=0.;
    for(i=0;i<n;i++) {
        sqx=sqx+(x[i]-xave)*(x[i]-xave);
        sqy=sqy+(y[i]-yave)*(y[i]-yave);
    }
    dx=sqrt(sqx/n);
    dy=sqrt(sqy/n);
    sxy=0.;
    for(i=0;i<n;i++) {
        sxy=sxy+(x[i]-xave)*(y[i]-yave);
    }
    dp=sxy/n;
    c=0.;
    if(dx*dy!=0.)c=dp/(dx*dy);
    if(size==0.) {
        r1=1.;
        r2=1.;
        if(dx!=0.)r1=dy/dx;
        if(dy!=0.)r2=dx/dy;
        if(r1>=r2)ratio=r1;
        if(r1<r2)ratio=r2;
        c=c/ratio;
    }
    if(emp!=0) {
        amp1=ampl(n,x);
        amp2=ampl(n,y);
        ratio=amp1;
        if(ratio>amp2)ratio=amp2;
        c=c*ratio;
    }
    return c;
}
void DepPairs::cor(int iwl,int isl,float *x,float *y,float *c,int size,int emp)
{
    int i,ix=isl,iy;
    for(i=0;i<2*isl;i++) {
        ix=isl;
        iy=i;
        c[i]=corr(iwl,&x[ix],&y[iy],size,emp);
    }
}
double DepPairs::fun(DPoint &p1, DPoint &p2, DPoint &p3)
{
    double s;
    s= (p2.x-p1.x)*(p3.y-p1.y)+(p1.y-p2.y)*(p3.x-p1.x);
    return s;
}

float DepPairs::act(float *x,int n,int way)
{
    int i,i1,i2;
    float sum,sq,ave,z,sqd;
    sum=0.;
    for(i=0;i<n;i++)  sum=sum+x[i];
    ave=sum/n;
    sq=0.;
    for(i=0;i<n;i++)  sq=sq+(x[i]-ave)*(x[i]-ave);
    sqd=sqrt(sq/n);
    if(way==0) return sqd;
    i1=0;
    i2=0;
    for(i=0;i<n;i++) {
        if(i>=n/2&&x[i]>=ave)i1++;
        if(i>=n/2&&x[i]<ave)i2++;
        if(i<n/2&&x[i]>=ave)i2++;
        if(i<n/2&&x[i]<ave)i1++;
    }
    z=sqd;
    if(way==1&&i2>i1)z=-z;
    if(way==2&&i2<=i1)z=-z;
    return z;
}
void DepPairs::actvty(int iwl,int isl,float *dr,int way,float *x,float *c)
{
    int n,n2,i;
    n= (int)(*dr / DepLevel);
    n2=n/2;
    n=2*n2+1;
    for(i=0;i<iwl+2*isl;i++) c[i]=act(&x[i],n,way);
    for(i=0;i<iwl+2*isl;i++) x[i]=c[i];
}
void DepPairs::adjust(int n,int way,float *c)
{
    int i;
    for(i=0;i<n;i++) {
        if(way==0)c[i]=abs(c[i]);
        if(way==2)c[i]=-c[i];
    }
}
int  DepPairs::MMax(float depth,int isl,float *x,float *y,float *c,float cmins)
{
    int i,iup,idown,n,idir1=0,idir2=0;
    float xdep,ydep;
    n=2*isl+1;
    iup=1;
    idown=-1;
    if( c[0] <  c[1] ) idir1 = iup;
    if( c[0] >= c[1] ) idir1 = idown;
    for(i=1;i<n-1;i++)
    {
        if( c[i] <  c[i+1] )idir2=iup;
        if( c[i] >= c[i+1] )idir2=idown;
        if( idir1 == idown && idir2 == iup ) idir1=idir2;
        if( idir1 == iup && idir2 == idown )
        {
            xdep=depth;
            ydep=depth+(i-isl)*DepLevel;
            if ( c[i] >= 0.5) {
                fprintf(fp_temp,"%8.3f %8.3f %5.3f\n",ydep,xdep,c[i]);
//				break;
            }
            idir1=idir2;
        }
    }
    return 1;
}
int  DepPairs::MMax(float ydep,float dep0,int isl,float *c,float cmins)
{
    float xdep;
    int ss=-1;
    int n=1.5*isl+1;
    float maxcor=-99999;
    for(int i=0;i<n;i++)
    {
        if( c[i] >maxcor) {
            maxcor=c[i];
            ss=i;
        }
    }
    if(ss>-1&&c[ss]>cmins)
    {
        xdep=dep0+ss*DepLevel;
        fprintf(fp_temp,"%8.3f %8.3f %5.3f\n",xdep,ydep,c[ss]);
    }
    return 1;
}
int DepPairs::signum(float x)
{
    int y;
    y=0;
    if(x<0.)y=-1;
    if(x>0.)y=1;
    return y;
}
int  DepPairs::optim(int n,float *x1,float *y1,float *c1,float cmins,float elast)
{
    float xmax=999999.;
    int xnull=0;
    float tfine=0,check,diff=0,fcrif=0,fine=0,fmin=0;
    int i,iw,j,ip1,ip2,imin,nd,ids,nd1;

    n=1;
    float a,b,d;
    int aa=0;
    rewind(fp_temp);
    while(!feof(fp_temp))
    {
        fscanf(fp_temp,"%f%f%f\n",&a,&b,&d);
        if(ipar) aa++;
        else if(d>=cmins) aa++;
    }
    if(aa<=0) return -1;
    float *x=new float[aa+1000];
    float *y=new float[aa+1000];
    float *c=new float[aa+1000];

    float *f=new float[aa+1000];
    int *ncs=new int[aa+1000];
    rewind(fp_temp);
    while(!feof(fp_temp))
    {
        if(fscanf(fp_temp,"%f%f%f\n",&x[n],&y[n],&c[n])!=3)
        {
            break;
        };
        if(ipar) n++;
        else if(c[n]>=cmins) n++;
    }
    fclose(fp_temp);
    QString dir=GetLogdataPath();
    dir+="\\temp";
    CreateDir((char *)dir.toStdString().c_str());
    dir+="\\admtemp";
    fp_temp=fopen(dir.toStdString().c_str(),"w+");
    if(ipar)
    {
        for(ip1=0;ip1<n;ip1++)
        {
            ncs[ip1]=0;
        }
        for(int i=1;i<n;i++)
        {
            for(j=i-1;j>0;j--)
            {
                if(x[i]<=x[j]){
                    ncs[i]=1;
                    break;
                }
            }
            if(x[i]-x[i-1]>0&&x[i]-x[i-1]<0.5)ncs[i]=1;
            if(!ncs[i])
            {
                for(j=i+1;j<n-1;j++)
                {
                    if(x[i]>=x[j]){
                        ncs[i]=1;
                        break;
                    }
                }
            }
        }
        rewind(fp_temp);
        j=0;
        for(int i=1;i<n;i++){
            if(ncs[i]) continue;
            fprintf(fp_temp,"%f %f %f\n",x[i],y[i],c[i]);
            j++;
        }
    }
    else {
        x[0]=xmax; y[0]=xmax; c[0]=0.;
        x[n]=xmax; y[n]=xmax; c[n++]=0.;
        f[0]=0; ncs[0]=xnull;
        fine=elast;
        for(ip1=1;ip1<n;ip1++)
        {
            f[ip1]=0;
            ncs[ip1]=0;
        }
        for(ip1=1;ip1<n;ip1++)
        {
            if(x[ip1]>=xmax&&ip1!=n-1) goto l2100;
            fmin=xmax;
            tfine=0.;
            for(iw=0;iw<ip1;iw++)
            {
                ip2=ip1-iw-1;
                if(iw!=0&&x[ip2+1]<xmax) tfine=tfine+fine*c[ip2+1];
                if(x[ip2]>=xmax&&ip2!=0) goto l1900;
                if(tfine>fmin) goto l2000;
                if(x[ip1]<xmax&&x[ip2]<xmax) goto l1500;
                fcrif=f[ip2]+tfine;
                goto l1800;
l1500:;
                check=signum(x[ip1]-x[ip2])*signum(y[ip1]-y[ip2]);
                if(check<=0.0) goto l1900;
                diff=abs(( x[ip1]-x[ip2]) - (y[ip1]-y[ip2]));
                fcrif=f[ip2]+tfine+diff;
l1800:;
                if(fcrif>fmin) goto l1900;
                fmin=fcrif;
                imin=ip2;
l1900:;
            }
l2000:;
            f[ip1]=fmin;
            ncs[ip1]=imin;
l2100:;
        }
        nd=0;
        ids=n-1;
        while(1)
        {
            ids=ncs[ids];
            if(ids==0) break;
            f[nd++]=ids;
        }
        for(i=0;i<nd;i++)
        {
            j=nd-i-1;
            ncs[i]=f[j];
        }
        for(nd1=0,i=0;i<nd;i++)
        {
            if(x[ncs[i]]<xmax)
            {
                x[nd1]=x[ncs[i]];
                y[nd1]=y[ncs[i]];
                c[nd1++]=c[ncs[i]];
            }
        }
        rewind(fp_temp);
        fprintf(fp_temp,"%f %f %f\n",x[0],y[0],c[0]);
        j=0;
        float d1=0;
        j++;
        for(int i=1;i<nd1;i++) {
            d=x[i]-x[i-1];
            d1=y[j]-y[i-1];
            if(d!=d1||i==nd1-1)
            {
                fprintf(fp_temp,"%f %f %f\n",x[i],y[i],c[i]);
                j++;
            }
        }
    }
    delete x;
    delete y;
    delete c;
    delete f;
    delete ncs;
    return j;
}
int DepPairs::GetDots(int n1,float sdeps,float edeps,float DepLevel,float *datx1,int n)
{
    int count=(edeps-sdeps)/DepLevel+1.5;
    DPoint*p1=new DPoint[count+1];
    for(int i=0;i<count;i++)
    {
        if(datx1)
        {
            p1[i]=DPoint(sdeps+i*DepLevel,datx1[i]);
        }
        else p1[i]=DPoint(sdeps+i*DepLevel,Curve1.GetValue(sdeps+i*DepLevel));
    }
    int datn=GetGDots(count,p1,n);
    delete p1;
    return datn;
}
int DepPairs::GetGDots(int n1,DPoint *x,int n)
{
    int k=0;
    double s1, s2;
    int *spos=new int[n1];
    for(int i=1; i<n1-1; i++)
    {
        s1 = x[i].y-x[i-1].y;//fun(x[i-2], x[i-1], x[i]);
        s2 = x[i].y-x[i+1].y;//fun(x[i-1], x[i], x[i+1]);
        if(s1<0&&s2<0){
            spos[k]=i;
            k++;
        }
    }
    int kk=0;
    for(int j=0;j<n;j++)
    {
        if(kk)k=kk;
        kk=0;
        for(int i=1; i<k-1; i++)
        {
            s1 = x[spos[i]].y-x[spos[i-1]].y;//fun(x[i-2], x[i-1], x[i]);
            s2 = x[spos[i]].y-x[spos[i+1]].y;//fun(x[i-1], x[i], x[i+1]);
            if(s1>0&&s2<0||s1>0&&s2>0||s1<0&&s2>0){
                continue;
            }
            spos[kk]=spos[i];
            kk++;
        }
    }
    if(n<=0) kk=k;
    for(int i=0;i<kk-1;i++)
    {
        int ppos=-1;
        float d=99999;
        float dd;
        int len=spos[i+1]-1-spos[i];
        int isl=sl/DepLevel;
        if(len>isl) len=isl;
        for(int m=spos[i];m<spos[i]+len;m++)
        {
            dd=(x[m].y-x[m+1].y);
            if(dd<d)
            {
                ppos=m;
                d=dd;
            }
        }
        if(ppos>0){
            spos[i]=ppos-1;
        }
    }
    for(int i=0; i<kk; i++)
    {
        fprintf(fp_temp,"%f %f %f\n",x[spos[i]].x,x[spos[i]].x,1);
    }
    delete spos;
    return kk;
}

int DepPairs::paral(int n1,float *x1,float *y1,float *c1,int retype)
{
    float a,b,d;
    float *x=new float[n1+1];
    float *y=new float[n1+1];
    float *c=new float[n1+1];
    float *spos=new float[n1+1];
    memset(spos,0,n1*sizeof(float));
    rewind(fp_temp);
    int n=0;
    while(!feof(fp_temp))
    {
        fscanf(fp_temp,"%f%f%f",&x[n],&y[n],&c[n]);
        n++;
        if(n>=n1) break;
    }
    float xmax=999999.,disp1,disp2,disp;
    int i,k,j;
    if(n<3) {
        delete x;
        delete y;
        delete c;
        delete spos;
        return -1;
    }
    i=-1;
    float v1,v2,v3;
    fclose(fp_temp);
    QString dir=GetLogdataPath();
    dir+="\\temp";
    CreateDir((char *)dir.toStdString().c_str());
    dir+="\\admtemp";
    fp_temp=fopen(dir.toStdString().c_str(),"w+");
    while(1) {
        i=i+1;
        if(i>=n) break;
        disp1=y[i]-x[i];
        disp2=y[i+1]-x[i+1];
        if(disp1==disp2) {
            i+=2;
            for(j=i;j<n;j++) {
                disp=y[j]-x[j];
                if(disp==disp1)x[j-1]=xmax;
                if(disp!=disp1) break;
            }
            if(disp==disp1) break;
            i=j-1;
        }
    }

    for(k=0,i=0;i<n;i++) {
        if(x[i]<xmax) {
            fprintf(fp_temp,"%f %f %f\n",x[i],y[i],c[i]);
            k++;
        }
    }
    delete x;
    delete y;
    delete c;
    delete spos;
    return k;
}


void DepPairs::DepthSort(float *xxx,int number)
{
    int i5,j5;
    float tempf5;

    for (i5=0; i5<number; i5++)
        for (j5=i5; j5<number; j5++)
            if (xxx[i5] > xxx[j5])
            {
                tempf5 = xxx[i5];
                xxx[i5] = xxx[j5];
                xxx[j5] = tempf5;
            }
}
int DepPairs::GetCompare(int datn,float sdeps,float edeps,float* datx1,float* daty1,float* datc1,float cmins,float xelast)
{
    float *x=new float[datn+10];
    float *y=new float[datn+10];
    float *c=new float[datn+10];
    rewind(fp_temp);
    float wl2,xdr2;
    int num1,number,numt,i,iwl,isl,iwl2,istep,jsize,ixdr2,idr,idr2;
    int n1,kno;
    int cccc;
    if(wl==0)wl=10.;
    if(sl==0)sl=4.;
    if(step==0)step=1;
    if(dr1==0)dr1=3.;
    if(dr2==0)dr2=3.;
    if(type!=0 &&sl<dr2/2)sl=dr2/2;
    iwl=(int)(wl/DepLevel+0.5);
    iwl2=iwl/2;
    iwl=2*iwl2+1;
    isl=(int)(sl/DepLevel+0.5);
    istep=(int)(step/DepLevel+0.5);
    idr=(int)(dr2/DepLevel+0.5);
    idr2=idr/2;
    idr=2*idr2+1;
    xdr2=idr2*DepLevel;
    if( type == 0 ) xdr2=0;
    ixdr2=idr2;
    if( type == 0 ) ixdr2=0;
    jsize=iwl+2*isl;
    kno=1;
    if(emp!=0||size==0) detscl(sdeps,edeps);
    num1 = 0;
    number = iwl + 2 * isl+2*ixdr2;
    numt = number - istep;
    wl2=iwl2*DepLevel;

    int n=0;
    int maxnum=-99999;
    iwl=(int)(wl/DepLevel+0.5);
    iwl2=iwl/2;
    iwl=2*iwl2+1;

    while(!feof(fp_temp))
    {
        fscanf(fp_temp,"%f%f%f",&x[n],&y[n],&c[n]);
        if(n)iwl=(x[n]-x[n-1])/DepLevel;
        if(maxnum<iwl) maxnum=iwl;
        n++;
        if(n>=datn) break;
    }
    fclose(fp_temp);
    QString dir=GetLogdataPath();
    dir+="\\temp";
    CreateDir((char *)dir.toStdString().c_str());
    dir+="\\admtemp";
    fp_temp=fopen(dir.toStdString().c_str(),"w+");

    number = maxnum + 2 * isl+2*ixdr2;

    float *datx=new float[number+1];
    float *daty=new float[number+1];
    float *datc=new float[number+1];
    cccc = 0;
    for(int j=0;j<n-1;j++){
        int k=isl;
        for (i=0; i<number; i++) {
            datx[i]=0.;
            daty[i]=0.;
            datc[i]=0.;
        }
        for(float dep=x[j];dep<x[j+1];dep+=DepLevel)
        {
            if(datx1)
            {
                int pos=(dep-sdeps)/DepLevel;
                if(dep<sdeps||dep>edeps) datx[k++]=-9999.0;
                else datx[k++]=datx1[pos];
            }
            else datx[k++]=Curve1.GetValue(dep);
        }
        k=0;
        for(float dep=x[j]-isl*DepLevel/2;dep<x[j+1]+isl*DepLevel;dep+=DepLevel)
        {
            if(daty1)
            {
                int pos=(dep-sdeps)/DepLevel;
                if(dep<sdeps||dep>edeps) daty[k++]=-9999.0;
                else daty[k++]=daty1[pos];
            }
            else daty[k++]=Curve2.GetValue(dep);
        }
        iwl=(x[j+1]-x[j])/DepLevel;
        cor(iwl,isl,datx,daty,datc,size,emp);
        MMax(x[j],x[j]-isl*DepLevel/2,isl,datc,cmins);
    }
    datn=optim(0,datx1,daty1,datc1,cmins,xelast);
    delete x;
    delete y;
    delete c;
    return datn;
}
int DepPairs::joincurve(float sdeps,float edeps,float *datx1,float *daty1,float *datc1,
                                float wl,float sl,float step,float dr1,float dr2,
                                int type,int size,int way,int emp,int ipar,
                                float cmins,float xelast)
{
    float depth,depth1,dept,deps;
    float wl2,xdr2;
    int num1,number,numt,i,iwl,isl,iwl2,istep,jsize,ixdr2,idr,idr2;
    int n1,kno;
    int cccc;
    if(wl==0)wl=10.;
    if(sl==0)sl=4.;
    if(step==0)step=1;
    if(dr1==0)dr1=3.;
    if(dr2==0)dr2=3.;
    if(type!=0 &&sl<dr2/2)sl=dr2/2;
    iwl=(int)(wl/DepLevel+0.5);
    iwl2=iwl/2;
    iwl=2*iwl2+1;
    isl=(int)(sl/DepLevel+0.5);
    istep=(int)(step/DepLevel+0.5);
    idr=(int)(dr2/DepLevel+0.5);
    idr2=idr/2;
    idr=2*idr2+1;
    xdr2=idr2*DepLevel;
    if( type == 0 ) xdr2=0;
    ixdr2=idr2;
    if( type == 0 ) ixdr2=0;
    jsize=iwl+2*isl;
    kno=1;
    if(emp!=0||size==0) detscl(sdeps,edeps);
    num1 = 0;
    number = iwl + 2 * isl+2*ixdr2;
    numt = number - istep;
    wl2=iwl2*DepLevel;
    depth=sdeps-step+wl2+sl+xdr2;
    depth1 = depth + step + step/2;
    dept = iwl2 + isl;

    int ret=TRUE;

    QString dir=GetLogdataPath();
    dir+="\\temp";
    CreateDir((char *)dir.toStdString().c_str());
    dir+="\\admtemp";
    fp_temp=fopen(dir.toStdString().c_str(),"w+");
    if(fp_temp==NULL)
    {
        QMessageBox::warning(nullptr, "提示", "Not create file :admtemp !\n");
        return -1;
    }

//    ::GetProgressBar()->setVisible(true);
//    ::GetProgressBar()->setRange(sdeps,edeps);
//    ::GetProgressBarHint()->setVisible(true);

    char showname[200];
    sprintf(showname,"自动产生深度对比线...");
    int datn=0;

    if(ipar){

//        ::GetProgressBarHint()->setText("查找层界面....");
        QApplication::processEvents();
        datn=GetDots(n1,sdeps,edeps,DepLevel,datx1,1);
//        ::GetProgressBar()->setValue(sdeps+(edeps-sdeps)*0.1);
        QApplication::processEvents();

//        ::GetProgressBarHint()->setText("开始地层对比...");
//        ::GetProgressBar()->setValue(sdeps+(edeps-sdeps)*0.3);
        QApplication::processEvents();

        datn=GetCompare(datn,sdeps,edeps,datx1,daty1,datc1,cmins,xelast);

//        ::GetProgressBar()->setValue(edeps);
        QApplication::processEvents();
    }
    else{
        float *datx=new float[number+1];
        float *daty=new float[number+1];
        float *datc=new float[number+1];
        cccc = 0;
        for (i=0; i<number; i++) {
            datx[i]=0.;
            daty[i]=0.;
            datc[i]=0.;
        }
        while(1)
        {
            depth=depth+step;
//            ::GetProgressBar()->setValue(depth);
//            ::GetProgressBarHint()->setText(showname);

            QApplication::processEvents();

            if(depth>edeps-wl2-sl-xdr2) {
                break;
            }
            if ( depth > depth1 )
            {
                if ( numt > 0 )
                {
                    for(i=0;i<numt;i++)
                    {
                        datx[i] = datx[istep+i];
                        daty[i] = daty[istep+i];
                    }
                    num1 = numt;
                }
            }
            for(i=num1;i<number;i++)
            {
                deps=depth+(i-dept)*DepLevel;
                if(emp!=0||size==0)
                {
                    datx[i]=(Curve1.GetValue(deps)-xmin1)/(xmax1-xmin1);
                    daty[i]=(Curve2.GetValue(deps)-xmin2)/(xmax2-xmin2);
                }
                else
                {
                    datx[i]=Curve1.GetValue(deps);
                    daty[i]=Curve2.GetValue(deps);
                }
            }
            if(type!=0)
            {
                actvty(iwl,isl,&dr1,way,datx,datc);
                actvty(iwl,isl,&dr2,way,daty,datc);
            }
            cor(iwl,isl,datx,daty,datc,size,emp);
            n1=iwl+isl*2;
            if(type==0) adjust(n1,way,datc);
            cccc ++;
            MMax(depth,isl,datx,daty,datc,cmins);
        }
        fseek(fp_temp,0,0);
        delete datx;
        delete daty;
        delete datc;
        datn=optim(0,datx1,daty1,datc1,cmins,xelast);
        if(datn>0)datn=paral(datn,datx1,daty1,datc1,ipar);
    }
    fclose(fp_temp);
//    ::GetProgressBar()->setVisible(false);
//    ::GetProgressBarHint()->setVisible(false);
    QApplication::processEvents();
    return datn;
}

int DepPairs::adm(float stem,float etem ,float cmins,
                           float winLength,float stepLength, float searchLength,
                           float *datx1,float *daty1,float *datc1
                           )
{
    char str[120];
    int i;
    int datn;
    cmin = cmins;
    datn = joincurve(stem,etem,datx1,daty1,datc1,
        winLength,searchLength,stepLength,dr1,dr2,type,size,
        way,emp,ipar,cmins,elast);
    if ( datn < 0 )
    {
        sprintf(str,"%f--%f层段相关性太差，相关系数均小于截止值%f ",stem,etem,cmins);
        QMessageBox::warning(nullptr, "提示", str);
    }
    else {
        float *datx,*daty,*datc;
        m_nDepPairsNum=0;
        datx = new float[datn+100];
        if ( datx == NULL )
        {
            QMessageBox::warning(nullptr, "提示", "自动校深:没有足够的内存.");
            return m_nDepPairsNum;
        }
        daty = new float[datn+100];
        if ( daty == NULL )
        {
            QMessageBox::warning(nullptr, "提示", "自动校深:没有足够的内存.");
            delete datx;
            return m_nDepPairsNum;
        }
        datc = new float[datn+100];
        if ( datc == NULL )
        {
            QMessageBox::warning(nullptr, "提示", "自动校深:没有足够的内存.");
            delete datx;
            delete daty;
            return m_nDepPairsNum;
        }
        QString dir=GetLogdataPath();
        dir+="\\temp";
        CreateDir((char *)dir.toStdString().c_str());
        dir+="\\admtemp";
        fp_temp=fopen(dir.toStdString().c_str(),"rt");
        if(fp_temp==NULL)
        {
            QMessageBox::warning(nullptr, "提示", "Not create file :admtemp !\n");
            delete [] datx;
            delete [] daty;
            delete [] datc;
            QDir r;
            r.remove(dir.toStdString().c_str());
            return -1;
        }
        i=0;
        while(!feof(fp_temp))
        {
            fscanf(fp_temp,"%f%f%f",&datx[i],&daty[i],&datc[i]);
            i++;
            if(i>=datn) break;
        }
        if(!i) {
            QMessageBox::warning(nullptr, "提示", "自动对比文件读写错误！");
            fclose(fp_temp);
            delete [] datx;
            delete [] daty;
            delete [] datc;
            QDir r;
            r.remove(dir.toStdString().c_str());
            return -1;
        }
        datn=i;
        fclose(fp_temp);

        qs(datx,daty,datc,0,datn-1);
        if(last_edep!=stem)
        {
            float ddep=0;
            if(datn) {
                ddep=datx[0]-stem;
                FirstDep[m_nDepPairsNum]=daty[0]-ddep;
            }
            else FirstDep[m_nDepPairsNum]=stem;
            SecondDep[m_nDepPairsNum]=stem;
            corc[m_nDepPairsNum]=1.;
            m_nDepPairsNum++;
        }
        for(i=0;i<datn;i++)
        {
            FirstDep[m_nDepPairsNum]=daty[i];
            SecondDep[m_nDepPairsNum]=datx[i];
            if(corc) corc[m_nDepPairsNum]=datc[i];
            m_nDepPairsNum++;
        }
        float ddep=0;
        if(datn) {
            ddep=etem-datx[datn-1];
            FirstDep[m_nDepPairsNum]=daty[datn-1]+ddep;
        }
        else FirstDep[m_nDepPairsNum]=etem;
        SecondDep[m_nDepPairsNum]=etem;
        if(corc) corc[m_nDepPairsNum]=1;
        m_nDepPairsNum++;
        delete [] datx;
        delete [] daty;
        delete [] datc;
        QDir r;
        r.remove(dir.toStdString().c_str());
    }
    return m_nDepPairsNum;
}
int DepPairs::AdmRun(float *curve1,float *curve2,float *cc)
{
    return adm(StartDepth,EndDepth ,cmin,wl,step,sl,curve1,curve2,cc);
}