#include "MemRdWt.h"
#include "math.h"
#include "BaseFun.h"
#include <stdio.h>
#include "DepthProgress.h"
#include <iostream>
#include <fstream>
#include<time.h>
//#include <Windows.h>
#include <QFileDialog>
#include <QTextStream>
#include <math.h>
#include"fftw3.h"
#include"Att_c_find.h"
#include"hilbert.h"
#include"Inputtuban.h"
//#include"maxInArray.h"
#include"SLG_plate.h"
#include"Zc_Zm_comb.h"
#include"S_per.h"
#include"Ecc_Co.h"
#include"FindPeak.h"
#include"InArray_self.h"
#include"Rate_Co.h"
#include"Thcav_Co.h"
#include"findcc.h"

#ifdef BOOL
#undef BOOL
#endif
#include <Windows.h>

using namespace std;
#define PI (float)3.1415926
#define NN 300
#define NFFT 80
//FILE* fpF,*fpF1,*fpN1,*fpN,*fpR,*fpR1,*fp11,*fp12,*fp13,*fpSPR;
//FILE* fpJc;
//FILE* fpR1,*fpR2,*fpR3,*fpR4,*fpR5,*fpR6,*fpR7;
//------------------------无需修改----------------------------------------------
Slf_WAVE  mWave[1];
using namespace std;
#define OUTNAME "OUT1"

extern "C"{

	//------------------------------------------------------------------无需修改----------------------------------------------------------------------------------
	_declspec (dllexport) struct INC_STRU  INC={12,
		"FWGN:远波增益,raw;; \
		FWST:远波延迟,μs;;\
		NWGN:近波增益,raw;;\
		NWST:近波延迟,μs;; \
		RWGN:共振增益,raw;;\
		RWST:共振延迟,μs;; \
		MWAVE:泥浆波曲线,μs;; \
		MWGN:泥浆增益,raw;; \
		MWST:泥浆延迟,μs;; \
		W80F:温度曲线,℃;; \
		RB:方位曲线,(°);; \
		RPS:钻速曲线,r/s;;"};
	_declspec (dllexport) struct INP_STRU  INP;
	//_declspec (dllexport) struct OUTC_STRU  OUTC={18, "ATT:衰减;;\
													  RATE:共振效率;;\
													  ATTC:套后衰减;;\
													  ZCC:套后阻抗;;\
													  SLG:气液固状态;;\
													  THC:套管厚度;;\
													  AMP:套管内壁粗糙度;;\
													  SPR_ALL:固体占比;;\
													  LPR_ALL:液体占比;;\
													  GPR_ALL:气体占比;;\
													  THCAV:套管平均厚度;;\
													  THCMN:套管最小厚度;;\
													  THCMX:套管最大厚度;;\
													  ECM:仪器居中度;;\
													  CEM:套管居中度;;\
													  THerr:套管厚度计算误差;;\
													  THLR:套管损失率;;\
													  THCSD:标准厚度;;"};
	//
	////8, "ATT:36道波形衰减值;dB/m; RATE:72道波形的共振效率值;%; ATTC:套后衰减率;none; ZCC:套后阻抗;MRayI; SLG:套后气液固状态;none; THC:测量的套管厚度;mm;AMP:套管内部状态幅度;none;SLGall:层间封隔评价;none;"
	//_declspec (dllexport) struct OUTP_STRU OUTP;
	_declspec (dllexport) struct HD_STRU   HD={0.0,9999.0,0.0,0.0,0.0,0.0,0.0,"CBUIprogram.INP","CBUIprogram.TLP"};
	__declspec (dllexport) struct CONC_STRU  CONC={32,
     "CTH:套管厚度,mm;;;;10.54;\
      CT:水泥类型;;;;1;\
	  IT:套管尺寸,mm;;;;139.7;\
	  MT:泥浆类型;;;;1;\
	  STEV:套管声速,m/s;;;;5200;\
	  ZM1:泥浆阻抗,MRayls;;;;1.5;\
	  LSM:平滑选择;;;;2;\
	  BW:共振效率;;;;0.08;\
	  CON1:衰减校正,dB/m;;;;-35;\
	  CON2:共振校正;;;;0.01;\
	  CON3:仪器常数;;;;0.55;\
	  RWD:共振波开窗延时,μs;;;;20;\
	  RWL:共振波延时窗长,μs;;;;30;\
	  FPS:兰姆波寻峰起始点;;;;20;\
	  FPE:兰姆波寻峰终止点;;;;300;\
	  RM1:共振波频域前窗,kHz;;;;20;\
	  RM2:共振波频域后窗,kHz;;;;40;\
	  RL:共振波时域窗长,μs;;;;48;\
	  S1:固相填充差截止值,%;;;;10;\
	  S2:固相填充中截止值,%;;;;70;\
	  S3:固相填充好截止值,%;;;;90;\
	  L1:液相填充好截止值,%;;;;10;\
	  L2:液相填充中截止值,%;;;;20;\
	  L3:液相填充差截止值,%;;;;90;\
	  G1:气相填充截止值,%;;;;90;\
	  CCMX:窜槽上限截止值,m;;;;2;\
	  CCMN:窜槽下限截止值,m;;;;1;\
	  NSR:近波采样间隔,μs;;;;400;\
	  FSR:远波采样间隔,μs;;;;400;\
	  RSR:共振波采样间隔,μs;;;;400;\
	  CID:共振波仪器参数,mm;;;;29.5;\
	  CD:兰姆波仪器参数,mm;;;;27.2;"
    };
	_declspec (dllexport) struct CON_STRU  CON={10.54,1,139.7,1,5200,1.5,2,0.08,-35,0.01,0.55,20,30,20,300,20,40,48,10,70,90,10,20,90,90,2,1,400,400,400,29.5,27.2};
	_declspec (dllexport) struct ErrorInf  errorinf;
	__declspec (dllexport) struct LogType  LogType={};//WAVE_OBJECT,WAVE_OBJECT,WAVE_OBJECT,WAVE_OBJECT,WAVE_OBJECT,WAVE_OBJECT
	__declspec( dllexport ) CMemRdWt  MemRdWt;
	_declspec (dllexport) int CBUIprogram();
}


typedef struct ss_struct
{
	int GNO;
	float GSDEP,GEDEP;
	int GRESULT;
} GUJING;

struct Fdpr {
	float fdep;
	float fspr;
//	float flpr;
	float fgpr;
};


int getRange(float y,float S1,float S2,float S3) 
{
	if (y >= 0 && y < S1) return 0;
	if (y >= S1 && y < S2) return 1;
	if (y >= S2 && y < S3) return 2;
	if (y >= S3 && y <= 100) return 3;
	return -1; 
}


struct Process_Struct
{
	//------------------------------------无需修改-------------------------------------
	//float ATT, RATE,ATTC,ZCC,SLG,THC,AMP,SPR_ALL,LPR_ALL, GPR_ALL,THCAV,THCMN,THCMX,ECM, CEM, THerr, THLR,THCSD;
	float CTH,CT,IT,MT,STEV,ZM1,LSM,BW,CON1,CON2,CON3,RWD,RWL,FPS,FPE,RM1,RM2,RL,S1,S2,S3,L1,L2,L3,G1,CCMX,CCMN,NSR,FSR,RSR,CID,CD;
	int Process();
};

int CBUIprogram()
{
	//-------------------------------------无需修改----------------------------------------
	Process_Struct Process;
	return Process.Process();
}


int Process_Struct::Process()
{
	if(HD.Sdep >= HD.EndDep)
	{
		AfxMessageBox("当前处理井段深度有误！\n已停止计算");
		return 0;
	}

	//-------------------------------------无需修改----------------------------------------
	MemRdWt.Const();
	MemRdWt.In();
	MemRdWt.Out();
	//char name[100];
	//MemRdWt.GetInCurveName(0,name);
	Slf_WAVE waveinf;

	//-----------------------------------------2 获取参数变量（无需修改）-----------------------------------------------
	#pragma region 获取参数
	//float NSR[36], FSR[36], RSR[72];
	
	
	GetPosValue(CTH,CON,1,1);
	GetPosValue(CT,CON,2,1);
	GetPosValue(IT,CON,3,1);
	GetPosValue(MT,CON,4,1);
	GetPosValue(STEV,CON,5,1);
	GetPosValue(ZM1,CON,6,1);
	GetPosValue(LSM,CON,7,1);
	GetPosValue(BW,CON,8,1);
	GetPosValue(CON1,CON,9,1);
	GetPosValue(CON2,CON,10,1);
	GetPosValue(CON3,CON,11,1);
	GetPosValue(RWD,CON,12,1);
	GetPosValue(RWL,CON,13,1);
	GetPosValue(FPS,CON,14,1);
	GetPosValue(FPE,CON,15,1);
	GetPosValue(RM1,CON,16,1);
	GetPosValue(RM2,CON,17,1);
	GetPosValue(RL,CON,18,1);
	GetPosValue(S1,CON,19,1);
	GetPosValue(S2,CON,20,1);
	GetPosValue(S3,CON,21,1);
	GetPosValue(L1,CON,22,1);
	GetPosValue(L2,CON,23,1);
	GetPosValue(L3,CON,24,1);
	GetPosValue(G1,CON,25,1);
	GetPosValue(CCMX,CON,26,1);
	GetPosValue(CCMN,CON,27,1);
	GetPosValue(NSR,CON,28,1);
	GetPosValue(FSR,CON,29,1);
	GetPosValue(RSR,CON,30,1);
	GetPosValue(CID,CON,31,1);
	GetPosValue(CD,CON,32,1);
	#pragma endregion
	IT=IT/25.4;
	float gd_Zc[100], gd_Att[100], ld_Zc[100], ld_Att[100], sd_Zc[100], sd_Att[100], gu_Zc[100], gu_Att[100], lu_Zc[100], lu_Att[100], su_Zc[100], su_Att[100];
	Tubanpara(MT, CTH, gd_Zc, gd_Att, ld_Zc, ld_Att, sd_Zc, sd_Att, gu_Zc, gu_Att, lu_Zc, lu_Att, su_Zc, su_Att);
	
	#pragma region F2D数组声名
	float **F2D = new float*[36];
	for(int _ii = 0; _ii < 36; _ii++)
		F2D[_ii] = new float[NN];
	float **N2D = new float*[36];
	for(int _ii = 0; _ii < 36; _ii++)
		N2D[_ii] = new float[NN];
	float **R2D = new float*[72];
	for(int _ii = 0; _ii < 72; _ii++)
		R2D[_ii] = new float[NN];
	#pragma endregion
	#pragma region F_hx_abs数组声名
	float **F_hx_abs = new float*[36];
	for(int _ii = 0; _ii < 36; _ii++)
		F_hx_abs[_ii] = new float[NN];
	float **N_hx_abs = new float*[36];
	for(int _ii = 0; _ii < 36; _ii++)
		N_hx_abs[_ii] = new float[NN];
	float **R_hx_abs = new float*[72];
	for(int _ii = 0; _ii < 72; _ii++)
		R_hx_abs[_ii] = new float[NN*2];
    float **R_hx_group = new float*[72];
	for (int _ii = 0; _ii < 72; _ii++)
		R_hx_group[_ii] = new float[NN * 2];
    //#pragma region RR2D/XX_abs/pha/p
	float **RR2D = new float*[72];
	for(int _ii = 0; _ii < 72; _ii++)
		RR2D[_ii] = new float[NN*2];
	float **R_XX_abs = new float*[72];
	for(int _ii = 0; _ii < 72; _ii++)
		R_XX_abs[_ii] = new float[NN*2];
	float **F_lb = new float*[36];
	for (int _ii = 0; _ii < 36; _ii++)
		F_lb[_ii] = new float[NN];	
	#pragma endregion

	#pragma region 波列数据初始化检查
	QStringList _nList;
	_nList << "ATT" << "RATE" << "ATTC" << "ZCC" << "SLG" << "THC"<<"AMP";
	for(int _i = 0; _i < _nList.size(); _i++)
	{
		int index1 = MemRdWt.OpenWave(_nList[_i].toStdString().c_str());
		if(index1 > 0) 
			continue;
		Slf_WAVE  myWave;
		strcpy(myWave.Name, _nList[_i].toStdString().c_str());
		strcpy(myWave.AliasName, _nList[_i].toStdString().c_str());
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");
		myWave.StartTime=0;
		myWave.TimeLevel=5;
		myWave.ArrayNum = 1;//阵列数
		if(_nList[_i] == "ATT")
			{myWave.TimeSamples = 36;
			myWave.TimeLevel=10;}
		else if(_nList[_i] == "SLGall")
			myWave.TimeSamples = 1;
		else
			myWave.TimeSamples = 72;
		strcpy(myWave.TimeUnit,"ns");	
		index1 = MemRdWt.OpenWave((Slf_WAVE *)&myWave);
	}
	#pragma endregion
	#pragma region 曲线数据初始化检查
	//MemRdWt.OpenCurve("SPR_all");
	int index1 = MemRdWt.OpenCurve("SPR_all");
	if(index1 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "SPR_all");
		strcpy(myWave.AliasName, "SPR_all");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index1 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	//
	int index2 = MemRdWt.OpenCurve("LPR_all");
	if(index2 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "LPR_all");
		strcpy(myWave.AliasName, "LPR_all");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index2 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	//
	int index3 = MemRdWt.OpenCurve("GPR_all");
	if(index3 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "GPR_all");
		strcpy(myWave.AliasName, "GPR_all");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index3 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	int index4 = MemRdWt.OpenCurve("THCAV");
	if(index4 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "THCAV");
		strcpy(myWave.AliasName, "THCAV");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index4 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	int index5 = MemRdWt.OpenCurve("THerr");
	if(index5 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "THerr");
		strcpy(myWave.AliasName, "THerr");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index5 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	int index6 = MemRdWt.OpenCurve("THCMN");
	if(index6 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "THCMN");
		strcpy(myWave.AliasName, "THCMN");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index6 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	int index7 = MemRdWt.OpenCurve("THCMX");
	if(index7 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "THCMX");
		strcpy(myWave.AliasName, "THCMX");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index7 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	int index8 = MemRdWt.OpenCurve("THLR");
	if(index8 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "THLR");
		strcpy(myWave.AliasName, "THLR");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index8 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	int index9 = MemRdWt.OpenCurve("ECM");
	if(index9 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "ECM");
		strcpy(myWave.AliasName, "ECM");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index9 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	int index10 = MemRdWt.OpenCurve("CEM");
	if(index10 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "CEM");
		strcpy(myWave.AliasName, "CEM");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index10 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	int index11 = MemRdWt.OpenCurve("THCSD");
	if(index11 < 0) 
	{	
		Slf_CURVE  myWave;
		strcpy(myWave.Name, "THCSD");
		strcpy(myWave.AliasName, "THCSD");
		strcpy(myWave.DepthUnit, "m");
		myWave.CodeLen = 4;//float
		myWave.RepCode = 4;
		myWave.DefVal = 0;
		myWave.StartDepth = HD.Sdep;
		myWave.EndDepth = HD.Edep;
		myWave.DepLevel = HD.Rlev;
		strcpy(myWave.DepthUnit,"m");	
		index11 = MemRdWt.OpenCurve((Slf_CURVE *)&myWave);
	}
	#pragma endregion
	int SL=(HD.EndDep-HD.Sdep)/HD.Rlev+5;	
	float SPR_all;
	float LPR_all;
	float GPR_all;
	float THCAV[1];
	float THerr,THCMX,THCMN,THLR,ECM,CEM,THCSD;
	#pragma region 波列数据index获取
	int ATT_index = MemRdWt.OpenWave("ATT");
	int RATE_index = MemRdWt.OpenWave("RATE");
	int ATTC_index = MemRdWt.OpenWave("ATTC");
	int ZCC_index = MemRdWt.OpenWave("ZCC");
	int SLG_index = MemRdWt.OpenWave("SLG");
	int THC_index = MemRdWt.OpenWave("THC");
	//加入套管内部幅度输出
	int AMP_index = MemRdWt.OpenWave("AMP");
	//曲线
	int SPR_all_index = MemRdWt.OpenCurve("SPR_all");
	int LPR_all_index = MemRdWt.OpenCurve("LPR_all");
	int GPR_all_index = MemRdWt.OpenCurve("GPR_all");
	int THCAV_index = MemRdWt.OpenCurve("THCAV");
	int THerr_index = MemRdWt.OpenCurve("THerr");
	int THCMN_index = MemRdWt.OpenCurve("THCMN");
	int THCMX_index = MemRdWt.OpenCurve("THCMX");
	int THLR_index = MemRdWt.OpenCurve("THLR");
	int ECM_index = MemRdWt.OpenCurve("ECM");
	int CEM_index = MemRdWt.OpenCurve("CEM");
	int THCSD_index = MemRdWt.OpenCurve("THCSD");
	#pragma endregion

	#pragma region 获取input数据的index
	int FGN_index = MemRdWt.OpenWave("FWGN");
	int NGN_index = MemRdWt.OpenWave("NWGN");
	int RGN_index = MemRdWt.OpenWave("RWGN");
	int FDL_index = MemRdWt.OpenWave("FWST");
	int NDL_index = MemRdWt.OpenWave("NWST");
	int RDL_index = MemRdWt.OpenWave("RWST");

	

	int FWAVEindex[36], NWAVEindex[36], RWAVEindex[72];
	for(int _i = 0; _i < 36; _i++)
	{
		QString num = QString::number(_i + 1);
		num = (num.length() == 1)? "0" + num : num;
		QString fwaveName = "FWAVE" + num;
		QString nwaveName = "NWAVE" + num;

		FWAVEindex[_i] = MemRdWt.OpenWave(fwaveName.toStdString().c_str());
		NWAVEindex[_i] = MemRdWt.OpenWave(nwaveName.toStdString().c_str());

		if(FWAVEindex[_i] < 0 || NWAVEindex[_i] < 0)
			return 0;
	}
	for(int _i = 0; _i < 72; _i++)
	{
		QString num = QString::number(_i + 1);
		num = (num.length() == 1)? "0" + num : num;
		QString rwaveName = "RWAVE" + num;

		RWAVEindex[_i] = MemRdWt.OpenWave(rwaveName.toStdString().c_str());

		if(RWAVEindex[_i] < 0)
			return 0;
	}
	#pragma endregion

	
	int itable1=MemRdWt.OpenOG_RESULT("固井质量");//打开固井表格，获取表格index（钥匙）
	MemRdWt.SetTableRecordCount(itable1,0);       //情况原有的表格数据
	
	int itable2=MemRdWt.OpenOG_RESULT("封隔评价");
	MemRdWt.SetTableRecordCount(itable2,0);
	

	int fiii=0;
	int FLE=(HD.EndDep-HD.Stdep)/HD.Rlev+300;
	float *FSPR=new float[FLE];
	float *FGPR=new float[FLE];
	float *FDEP=new float[FLE];
	/*float **FSLG = new float*[72];
	for (int _ii = 0; _ii < 72; _ii++)
		FSLG[_ii] = new float[FLE];*/
	/*int **ADDR=new int*[72];
	for(int mm=0;mm<72;mm++)
		ADDR[mm]=new int[FLE];*/


	


	DepthProgress mmProgress;
	mmProgress.CreatProgress(HD.Stdep, HD.EndDep, "程序处理中...");
	//---------------------------------深度循环--------------------------------------------
	while(HD.Dep <= HD.EndDep)
	{
		//每次都重复读取参数，应对多段参数控制
		GetPosValue(CTH,CON,1,1);
		GetPosValue(CT,CON,2,1);
		GetPosValue(IT,CON,3,1);
		GetPosValue(MT,CON,4,1);
		GetPosValue(STEV,CON,5,1);
		GetPosValue(ZM1,CON,6,1);
		GetPosValue(LSM,CON,7,1);
		GetPosValue(BW,CON,8,1);
		GetPosValue(CON1,CON,9,1);
		GetPosValue(CON2,CON,10,1);
		GetPosValue(CON3,CON,11,1);
		GetPosValue(RWD,CON,12,1);
		GetPosValue(RWL,CON,13,1);
		GetPosValue(FPS,CON,14,1);
		GetPosValue(FPE,CON,15,1);
		GetPosValue(RM1,CON,16,1);
		GetPosValue(RM2,CON,17,1);
		GetPosValue(RL,CON,18,1);
		GetPosValue(S1,CON,19,1);
		GetPosValue(S2,CON,20,1);
		GetPosValue(S3,CON,21,1);
		GetPosValue(L1,CON,22,1);
		GetPosValue(L2,CON,23,1);
		GetPosValue(L3,CON,24,1);
		GetPosValue(G1,CON,25,1);
		GetPosValue(CCMX,CON,26,1);
		GetPosValue(CCMN,CON,27,1);
		GetPosValue(NSR,CON,28,1);
		GetPosValue(FSR,CON,29,1);
		GetPosValue(RSR,CON,30,1);
		GetPosValue(CID,CON,31,1);
		GetPosValue(CD,CON,32,1);
		IT=IT/25.4;

		QString _proOut = "";
		if(CTH < 5 || CTH > 15)
			_proOut += "参数套管厚度CTH超界（5~15mm）\n";
		if(CT != 1 && CT != 2)
			_proOut += "参数水泥类型CT超界（1-低密度水泥，2-常规水泥）\n";
		if(IT*25.4 < 100 || IT*25.4 > 200)
			_proOut += "参数套管尺寸IT超界（100~200mm）\n";
		if(MT != 1 && MT != 2)
			_proOut += "参数泥浆类型MT超界（1-水基，2-油基）\n";
		if(STEV < 4000 || STEV > 7000)
			_proOut += "参数套管声速STEV超界（4000~7000m/s）\n";
		if(ZM1 < 0.5 || ZM1 > 10)
			_proOut += "参数泥浆阻抗ZM1超界（0.5~10MRayls）\n";
		if(LSM != 1 && LSM != 2)
			_proOut += "参数平滑选择LSM超界（1-平滑，2-不平滑）\n";
		if(RWD <= 0)
			_proOut += "参数共振波开窗延时RWD超界（大于0μs）\n";
		if(RWL <= 0)
			_proOut += "参数共振波延时窗长RWL超界（大于0μs）\n";
		if(FPS <= 0)
			_proOut += "参数兰姆波寻峰起始点FPS超界（大于0）\n";
		if(FPE <= 0)
			_proOut += "参数兰姆波寻峰终止点FPE超界（大于0）\n";
		if(FPS >= FPE)
			_proOut += "参数兰姆波寻峰起始点FPS/兰姆波寻峰终止点FPE关系错误（FPS < FPE）\n";
		if(RM1 <= 0)
			_proOut += "参数共振波频域前窗RM1超界（大于0kHz）\n";
		if(RM2 <= 0)
			_proOut += "参数共振波频域后窗RM2超界（大于0kHz）\n";
		if(RM1 >= RM2)
			_proOut += "参数共振波频域前窗RM1/共振波频域后窗RM2关系错误（RM1 < RM2）\n";
		if(RL <= 0)
			_proOut += "参数共振波时域窗长RL超界（大于0μs）\n";

		if(S1 <= 0 || S1 >= 100)
			_proOut += "参数固相填充差截止值S1超界（0~100%）\n";
		if(S2 <= 0 || S2 >= 100)
			_proOut += "参数固相填充中截止值S2超界（0~100%）\n";
		if(S3 <= 0 || S3 >= 100)
			_proOut += "参数固相填充好截止值S3超界（0~100%）\n";
		if(S1 >= S2 || S1 >= S3 || S2 >= S3)
			_proOut += "参数固相填充S1/S2/S3关系错误（S1 < S2 < S3）\n";

		if(L1 <= 0 || L1 >= 100)
			_proOut += "参数液相填充好截止值S1超界（0~100%）\n";
		if(L2 <= 0 || L2 >= 100)
			_proOut += "参数液相填充中截止值S2超界（0~100%）\n";
		if(L3 <= 0 || L2 >= 100)
			_proOut += "参数液相填充差截止值S3超界（0~100%）\n";
		if(L1 >= L2 || L1 >= L3 || L2 >= L3)
			_proOut += "参数液相填充L1/L2/L3关系错误（L1 < L2 < L3）\n";

		if(G1 <= 0 || G1 >= 100)
			_proOut += "参数气相填充截止值G1超界（0~100%）\n";

		if(CCMX <= 0)
			_proOut += "参数窜槽上限截止值CCMX超界（大于0m）\n";
		if(CCMN <= 0)
			_proOut += "参数窜槽下限截止值CCMN超界（大于0m）\n";
		if(CCMN >= CCMX)
			_proOut += "参数窜槽CCMN/CCMX关系错误（CCMN < CCMX）\n";

		if(CID <= 0)
			_proOut += "参数共振波仪器参数CID超界（大于0mm）\n";
		if(CD <= 0)
			_proOut += "参数兰姆波仪器参数CD超界（大于0mm）\n";

		if(_proOut != ""){
			_proOut += "已停止计算";
			AfxMessageBox(_proOut);
			#pragma region 空间释放
			for(int _ii = 0; _ii< 36; _ii++)
			{
				delete []N2D[_ii];
			}delete []N2D;
			for(int _ii = 0; _ii < 36; _ii++)
			{
				delete []F2D[_ii];
			}delete []F2D;
			for(int _ii = 0; _ii < 72; _ii++)
			{
				delete []R2D[_ii];
			}delete []R2D;
			for(int _ii = 0; _ii < 72; _ii++)
			{
				delete []RR2D[_ii];
			}delete []RR2D;
			//近
			for(int _ii = 0; _ii < 36; _ii++)
			{
				delete []N_hx_abs[_ii];
			}delete []N_hx_abs;
			for(int _ii = 0; _ii < 36; _ii++)
			{
				delete []F_hx_abs[_ii];
			}delete []F_hx_abs;
			//共振
			for (int _ii = 0; _ii < 36; _ii++)
			{
				delete[]R_hx_group[_ii];
			}delete[]R_hx_group;
			for(int _ii = 0; _ii < 72; _ii++)
			{
				delete []R_hx_abs[_ii];
			}delete []R_hx_abs;
			for(int _ii = 0; _ii < 72; _ii++)
			{
				delete []R_XX_abs[_ii];
			}delete []R_XX_abs;
			for (int _ii = 0; _ii < 36; _ii++)
			{
				delete[]F_lb[_ii];
			}delete[]F_lb;
			#pragma endregion
			return 0;
		}
		//------------------------------------------1 获取数据（无需修改）--------------------------------------------------
		mmProgress.SetDepth(HD.Dep);
		HD.Dep;
		int a = 0;
		float SPR[3]={1};
	    float CmQ[2]={0};
		float FGN[36], NGN[36], RGN[72],  FDL[36], NDL[36], RDL[72];
		float F2D0[36][300], N2D0[36][300], R2D0[72][300];
		float ATT[72],RATE[72],ATTC[72],ZCC[72],SLG[72],THC[72],AMP[72];

		#pragma region 数据获取
		//GetINValue(FGN,1,36);
		//GetINValue(NGN,3,36);
		//GetINValue(RGN,5,72);
		//GetINValue(FDL,2,36);
		//GetINValue(NDL,4,36);
		//GetINValue(RDL,6,72);


		MemRdWt.ReadWaveToFloatBuf(FGN_index, HD.Dep, 1,FGN);
		MemRdWt.ReadWaveToFloatBuf(NGN_index, HD.Dep, 1,NGN);
		MemRdWt.ReadWaveToFloatBuf(RGN_index, HD.Dep, 1,RGN);
		MemRdWt.ReadWaveToFloatBuf(FDL_index, HD.Dep, 1,FDL);
		MemRdWt.ReadWaveToFloatBuf(NDL_index, HD.Dep, 1,NDL);
		MemRdWt.ReadWaveToFloatBuf(RDL_index, HD.Dep, 1,RDL);

		if(FGN[0] <= -9999 || NGN[0] <= -9999 || RGN[0] <= -9999 || FDL[0] <= -9999 || NDL[0] <= -9999 || RDL[0] <= -9999)
		{
			#pragma region 空间释放
			for(int _ii = 0; _ii< 36; _ii++)
			{
				delete []N2D[_ii];
			}delete []N2D;
			for(int _ii = 0; _ii < 36; _ii++)
			{
				delete []F2D[_ii];
			}delete []F2D;
			for(int _ii = 0; _ii < 72; _ii++)
			{
				delete []R2D[_ii];
			}delete []R2D;
			for(int _ii = 0; _ii < 72; _ii++)
			{
				delete []RR2D[_ii];
			}delete []RR2D;
			//近
			for(int _ii = 0; _ii < 36; _ii++)
			{
				delete []N_hx_abs[_ii];
			}delete []N_hx_abs;
			for(int _ii = 0; _ii < 36; _ii++)
			{
				delete []F_hx_abs[_ii];
			}delete []F_hx_abs;
			//共振
			for (int _ii = 0; _ii < 36; _ii++)
			{
				delete[]R_hx_group[_ii];
			}delete[]R_hx_group;
			for(int _ii = 0; _ii < 72; _ii++)
			{
				delete []R_hx_abs[_ii];
			}delete []R_hx_abs;
			for(int _ii = 0; _ii < 72; _ii++)
			{
				delete []R_XX_abs[_ii];
			}delete []R_XX_abs;
			for (int _ii = 0; _ii < 36; _ii++)
			{
				delete[]F_lb[_ii];
			}delete[]F_lb;
			#pragma endregion
			AfxMessageBox("当前处理井段数据有误！请检查井段深度设置或数据\n已停止计算");
			return 0;
		}

		for(int _i = 0; _i < 36; _i++)
		{
			MemRdWt.ReadWaveToFloatBuf(FWAVEindex[_i], HD.Dep, 1, F2D0[_i]);
			MemRdWt.ReadWaveToFloatBuf(NWAVEindex[_i], HD.Dep, 1, N2D0[_i]);
		}
		for(int _i = 0; _i < 72; _i++)
		{
			MemRdWt.ReadWaveToFloatBuf(RWAVEindex[_i], HD.Dep, 1, R2D0[_i]);
		}
		#pragma endregion
		//去掉增益
		for (int i = 0; i < 36; i++)
		{
			for (int j = 0; j < 300; j++)
			{
				F2D[i][j] = F2D0[i][j]/FGN[i];
				N2D[i][j] = N2D0[i][j]/NGN[i];
			}
		}
		
		float V=1500,RNS,RNE,D;
		D=(IT*25.4/2-CTH-CID)*1e-3*2;
		int rll=RL/RSR*1e3;
		for (int i = 0; i < 72; i++)
		{
			for (int j = 0; j < 300; j++)
			{
				R2D[i][j] = R2D0[i][j]/RGN[i];
				RNS=floor((D/V)/(RSR*0.000000001))-RDL[i]/(RSR);
				RNE=RNS+rll;
			}
		}		

		//------------------------------------------3 处理程序（放运算程序的地方）--------------------------------------------------
		//处理过程
		float Att0all[36],Att0all1[36],Rateall[72],Thick[72],Att_c[72],Zc_end[72], Zm_end[72];
		float Rf[72],N_hx_abs_max[36], F_hx_abs_max[36], R_hx_abs_max[72],R_hx_phah_min[72] ,S_welldata2D_max[72], S_welldata2D_min[72], N_maxindex[72], F_maxindex[72], S_maxindex[72], maxindex[72], minindex[72];
		//远波形到时计算
		hilbert(F2D, F_hx_abs, 36);//远：前12个 
		/*for (int i = 0; i < 36; i++)
		{
			for (int j = 0; j < NN; j++)
			{
				F_hx_abs[i][j] = F2D[i][j];
			}
		}*/
		for (int i = 0; i < 36; i++)
		{
			maxindex[i]=1;
			F_hx_abs_max[i] = F_hx_abs[i][0];
		}
		maxInArray_self(F_hx_abs, F_hx_abs_max, maxindex,1, NN, 36, 1);

		int FPE1=FPE;
		int FPS1=FPS;
		float pf[36] = { 0 }, lf[36] = { 0 };
		float **pksf = new float*[36];
		for (int _ii = 0; _ii < 36; _ii++)
			pksf[_ii] = new float[FPE1];
		float **locsf = new float*[36];
		for (int _ii = 0; _ii < 36; _ii++)
			locsf[_ii] = new float[FPE1];

		for (int i = 0; i<36; i++)
		{
			for (int m = 0; m < FPE1; m++)
			{
				pksf[i][m] = 0;
				locsf[i][m] = 0;
			}
		}
		findPeaks(F_hx_abs, pksf, locsf, FPS1, FPE1);
		
	 for (int k = 0; k<36; k++)
		{
			for (int m = 0; m<FPE1; m++)
			{
				if (pksf[k][m] != 0)
				{
					pf[k] = pksf[k][m];
					lf[k] = locsf[k][m];

					if (pksf[k][m]>F_hx_abs_max[k]/3)
						break;
				}
				else if (pksf[k][m] == 0)
					break;
			}

		}
	    float fcy[36] = { 0 }, fmy[36] = { 0 };
		for (int k = 0; k<36; k++)
		{
			for (int m = 0; m<FPE1; m++)
			{
				if (pksf[k][m] != 0)
				{
					fmy[k] = pksf[k][m];
					fcy[k] = locsf[k][m];

					if (pksf[k][m]>F_hx_abs_max[k] * 0.4)
						break;
				}
				else if (pksf[k][m] == 0)
					break;
			}
		}
		for (int _ii = 0; _ii < 36; _ii++)
		{
			delete[]pksf[_ii];
		}delete[]pksf;
		for (int _ii = 0; _ii < 36; _ii++)
		{
			delete[]locsf[_ii];
		}delete[]locsf;

		//套管居中度
		
		float fbc = 15;
		float fcc[36] = { 0 };
		float ffm[36] = { 0 };
		float F_lb_max[36] = { 0 };
		float CEC[18] = { 0 };
		for (int i = 0; i < 36; i++)
		{
			fcc[i] = fcy[i] + fbc;
			for (int j = 0; j < NN; j++)
			{
				if (j<fcc[i])
					F_lb[i][j] = 0;
				else
					F_lb[i][j] = F_hx_abs[i][j];
			}
		}
		for (int i = 0; i < 36; i++)
		{
			ffm[i] = 1;
			F_lb_max[i] = F_lb[i][0];
		}
		int CEN = 150;
		maxInArray_self(F_lb, F_lb_max, ffm,1, NN, 36, 1);
		float pce[36] = { 0 }, lce[36] = { 0 };
		float **pkce = new float*[36];
		for (int _ii = 0; _ii < 36; _ii++)
			pkce[_ii] = new float[CEN];
		float **loce = new float*[36];
		for (int _ii = 0; _ii < 36; _ii++)
			loce[_ii] = new float[CEN];
		for (int i = 0; i<36; i++)
		{
			for (int m = 0; m < CEN; m++)
			{
				pkce[i][m] = 0;
				loce[i][m] = 0;
			}
		}
			
		findPeaks(F_lb, pkce, loce, 1, CEN);
		for (int k = 0; k<36; k++)
		{
			for (int m = 0; m<CEN; m++)
			{
				if (pkce[k][m] != 0)
				{
					pce[k] = pkce[k][m];
					lce[k] = loce[k][m];

					if (pkce[k][m]>F_lb_max[k] * 0.8)
						break;
				}
				else if (pkce[k][m] == 0)
					break;
			}
		}

		Ecc_co(lce, CEC, FDL, RSR,36);
		CEM =CEC[0];
		for (int i = 1; i < 18; i++)
		{
			if (CEC[i] > CEM)
			{
				CEM = CEC[i];
			}
		}
		CEM= 100 - CEM;
		for (int _ii = 0; _ii < 36; _ii++)
		{
			delete[]pkce[_ii];
		}delete[]pkce;
		for (int _ii = 0; _ii < 36; _ii++)
		{
			delete[]loce[_ii];
		}delete[]loce;
		//近波到时
		hilbert(N2D,N_hx_abs,36);//近：前512个
		/*for (int i = 0; i < 36; i++)
		{
			for (int j = 0; j < NN; j++)
			{
				N_hx_abs[i][j] = N2D[i][j];
			}
		}*/
		for (int i = 0; i < 36; i++)
		{
			maxindex[i]=1;
			N_hx_abs_max[i] = N_hx_abs[i][0];
		}
		maxInArray_self(N_hx_abs, N_hx_abs_max, maxindex,1, NN, 36, 1);

		float pn[36] = { 0 }, ln[36] = { 0 };
		float **pksn = new float*[36];
		for (int _ii = 0; _ii < 36; _ii++)
			pksn[_ii] = new float[FPE1];
		float **locsn = new float*[36];
		for (int _ii = 0; _ii < 36; _ii++)
			locsn[_ii] = new float[FPE1];
		for (int i = 0; i<36; i++)
		{
			for (int m = 0; m < FPE1; m++)
			{
				pksn[i][m] = 0;
				locsn[i][m] = 0;
			}
		}
		findPeaks(N_hx_abs, pksn, locsn, FPS1, FPE1);
		for (int k = 0; k<36; k++)
		{
			for (int m = 0; m<FPS1; m++)
			{
				if (pksn[k][m] != 0)
				{
					pn[k] = pksn[k][m];
					ln[k] = locsn[k][m];
					if (pksn[k][m]>N_hx_abs_max[k]/3)
						break;
				}
				else if (pksn[k][m] == 0)
					break;
			}
		}
		for (int _ii = 0; _ii < 36; _ii++)
		{
			delete[]pksn[_ii];
		}delete[]pksn;
		for (int _ii = 0; _ii < 36; _ii++)
		{
			delete[]locsn[_ii];
		}delete[]locsn;

		//衰减计算
		for (int j = 0; j < 36; j++)
		{
			Att0all[j] = 20 / 0.1*log10(pn[j] / pf[j]);
			if(Att0all[j]<0)
			{Att0all[j]=(Att0all[j-1]+Att0all[j-2])/2;}
		}
		/*for (int j = 0; j < 36; j++)
		{
			Att0all[j] = 20 / 0.1*log10(N_hx_abs_max[j] / F_hx_abs_max[j]);
		}*/
		//套管厚度及误差计算
		fft(R2D, RR2D,R_hx_group, R_XX_abs,72,RNS,RNE); //选择计算波形段 
		/*for (int i = 0; i < 72; i++)
		{
			for (int j = 0; j < NN*2; j++)
			{
				R_XX_abs[i][j] = RR2D[i][j];
				R_hx_group[i][j]=RR2D[i][j];
			}
		}*/
		float ref = 0.5*STEV / CTH;//共振频率
		float RN1 = round((ref - RM1)*6/25);
		float RN2 = round((ref + RM2)*6/25);
		int RN11=RN1;
		for (int i = 0; i < 72; i++)
		{
			minindex[i]=RN1;
			R_hx_phah_min[i] = R_hx_group[i][RN11];
		}
		minInArray_self(R_hx_group, R_hx_phah_min, minindex, RN1,RN2, 72, 1);
		
		THerr=0;
		Thc_co(THCAV, Rf, THC, minindex, RSR, STEV, NN*2);
		THerr=sqrt((THCAV[0]-CTH)*(THCAV[0]-CTH))/CTH*100;
		float THLR;
		THLR=sqrt(((THCAV[0]-CTH)/CTH)*((THCAV[0]-CTH)/CTH))*100;
		float THCMN= THC[0];
		for (int i = 1; i < 72; i++)
		{
			if (THC[i] <THCMN)
			{
				THCMN = THC[i];
			}
		}
		float THCMX= THC[0];
		for (int i = 1; i < 72; i++)
		{
			if (THC[i] >THCMX)
			{
				THCMX = THC[i];
			}
		}
		THCSD=CTH;
		//共振波效率计算
		hilbert2(RR2D,R_hx_abs,72);
		/*for (int i = 0; i < 72; i++)
		{
			for (int j = 0; j < NN; j++)
			{
				R_hx_abs[i][j] = R2D[i][j];
			}
		}*/
		for (int i = 0; i < 72; i++)
		{
			maxindex[i]=1;
			R_hx_abs_max[i] = R_hx_abs[i][0];
		}
		maxInArray_self(R_hx_abs, R_hx_abs_max, maxindex,1, NN, 72, 1);
		Rate_co(R_hx_abs, RATE, maxindex, R_hx_abs_max, RSR, RWD, RWL,NN);
		float amp[72];
		for (int i = 0; i < 72; i++)
		{
			maxindex[i]=1;
			amp[i] = R_hx_abs[i][0];
		}
		maxInArray_self(R_hx_abs, amp, maxindex,50, NN, 72, 1);
		float ampg[72];
		for (int i = 1; i < 72; i++)
		{
			 ampg[i]=amp[i]/RGN[i];
		}
		//仪器居中度
		float ECC[36];
		Ecc_co(maxindex, ECC, RDL, RSR,72);
		ECM= ECC[0];
		for (int i = 1; i < 36; i++)
		{
			if (ECC[i] > ECM)
			{
				ECM = ECC[i];
			}
		}

		//计算气液固状态
	    float BW1 = BW * 100;
		float ZM2=1.5;
		Zc_Zm_comb(Att0all, ATT, RATE, CON2, CON1, CTH, IT, CD, BW1, CT, LSM, CON3,Zc_end, Zm_end, ZM1, ZM2);
		Att_c_find2(Att_c, ATT, CTH, Zm_end, CON1);
		SLG_plate(SLG, Zc_end, Att_c, CTH, CT, gd_Zc, gd_Att, ld_Zc, ld_Att, sd_Zc, sd_Att, gu_Zc, gu_Att, lu_Zc, lu_Att, su_Zc, su_Att);		
		
		S_cal(SLG,SPR,CmQ,S1,S2,S3,L1,L2,L3,G1,CCMX,CCMN);
		SPR_all=SPR[0];
	    LPR_all=SPR[1];
	    GPR_all=SPR[2];
		

		/*for(int j=0;j<72;j++)
		{
			FSLG[j][fiii]=SLG[j];
		}*/
		FDEP[fiii]=HD.Dep;
		FSPR[fiii]=SPR_all;
		FGPR[fiii]=GPR_all;
		fiii++;


		//-------------------------------------------4 输出结果(无需修改)-------------------------------------------------
		//二维输出
		if(ATT_index > 0) MemRdWt.WriteWave(ATT_index, HD.Dep, 1, &Att0all);//直接计算得到
		if(RATE_index > 0) MemRdWt.WriteWave(RATE_index, HD.Dep, 1, &RATE);
		if(ATTC_index > 0) MemRdWt.WriteWave(ATTC_index, HD.Dep, 1, &Att_c);//套后衰减
		if(ZCC_index > 0) MemRdWt.WriteWave(ZCC_index, HD.Dep, 1, &Zc_end);//套后阻抗
		if(SLG_index > 0) MemRdWt.WriteWave(SLG_index, HD.Dep, 1, &SLG);
		if(THC_index > 0) MemRdWt.WriteWave(THC_index, HD.Dep, 1, &THC);
		if(AMP_index > 0) MemRdWt.WriteWave(AMP_index, HD.Dep, 1, &amp);
		//一维输出
		if(THCAV_index > 0) MemRdWt.WriteCurve(THCAV_index,HD.Dep,1,&THCAV);
		if(THerr_index > 0) MemRdWt.WriteCurve(THerr_index,HD.Dep,1,&THerr);
		if(THCAV_index > 0) MemRdWt.WriteCurve(THCAV_index,HD.Dep,1,&THCAV);
		if(THCMN_index > 0) MemRdWt.WriteCurve(THCMN_index,HD.Dep,1,&THCMN);
		if(THCMX_index > 0) MemRdWt.WriteCurve(THCMX_index,HD.Dep,1,&THCMX);
		if(THLR_index > 0) MemRdWt.WriteCurve(THLR_index,HD.Dep,1,&THLR);
		if(CEM_index > 0) MemRdWt.WriteCurve(CEM_index,HD.Dep,1,&CEM);
		if(ECM_index > 0) MemRdWt.WriteCurve(ECM_index,HD.Dep,1,&ECM);
		if(THCSD_index > 0) MemRdWt.WriteCurve(THCSD_index,HD.Dep,1,&THCSD);
		if(SPR_all_index > 0) MemRdWt.WriteCurve(SPR_all_index,HD.Dep,1,&SPR_all);
		if(LPR_all_index > 0) MemRdWt.WriteCurve(LPR_all_index,HD.Dep,1,&LPR_all);
		if(GPR_all_index > 0) MemRdWt.WriteCurve(GPR_all_index,HD.Dep,1,&GPR_all);
		MemRdWt.In();

	}
	
	Fdpr *fdpr=new Fdpr[fiii];
	for(int i=0;i<fiii;i++)
	{
		fdpr[i].fdep=FDEP[i];
		fdpr[i].fgpr=FGPR[i];
		fdpr[i].fspr=FSPR[i];
	}
	int dataSize =fiii;
	const int maxSegments = fiii;
    int segmentCount = 0;

    Fdpr*** segments = new Fdpr**[maxSegments];
    int* segmentLengths = new int[maxSegments]();  // 每段的长度
    float* segmentAverages = new float[maxSegments]();  // 存储每段的平均值
	float* segmentGAverages = new float[maxSegments](); 
    // 初始化第一段
    segments[segmentCount] = new Fdpr*[dataSize];
    segments[segmentCount][segmentLengths[segmentCount]++] = &fdpr[0];

    // 当前段的y值范围
    int currentRange = getRange(fdpr[0].fspr,S1,S2,S3);

	  // 分段逻辑
    for (int i = 1; i < dataSize; ++i) {
        int newRange = getRange(fdpr[i].fspr,S1,S2,S3);
        if (newRange != currentRange) {
            // 计算当前段的平均值
            float sum = 0;
			float sumg = 0;
            for (int j = 0; j < segmentLengths[segmentCount]; ++j) {
                sum += segments[segmentCount][j]->fspr;
				sumg += segments[segmentCount][j]->fgpr;
            }
            segmentAverages[segmentCount] = sum / segmentLengths[segmentCount];
			segmentGAverages[segmentCount] = sumg / segmentLengths[segmentCount];
            // 完成当前段，开始新段
            segmentCount++;
            segments[segmentCount] = new Fdpr*[dataSize];
            currentRange = newRange;
        }
        segments[segmentCount][segmentLengths[segmentCount]++] = &fdpr[i];
    }
	// 计算最后一段的平均值
    float sum = 0;
	float sumg = 0;
    for (int j = 0; j < segmentLengths[segmentCount]; ++j) {
        sum += segments[segmentCount][j]->fspr;
		sumg += segments[segmentCount][j]->fgpr;
    }
    segmentAverages[segmentCount] = sum / segmentLengths[segmentCount];
	segmentGAverages[segmentCount] = sumg / segmentLengths[segmentCount];
    segmentCount++; // 实际的段数

	// 输出分段结果和平均值
	/*FILE *tb1;
	tb1=fopen("E:\\seg.txt","w");
	for (int i = 0; i < segmentCount; i++) 
	{
		fprintf(tb1,"%d\t",i+1);
		fprintf(tb1,"%f\t",segmentAverages[i]);
		fprintf(tb1,"%f\t",segments[i][0]->fdep);
		fprintf(tb1,"%f\t",segments[i][segmentLengths[i]-1]->fdep);
		fprintf(tb1,"\n");
	}
	fclose(tb1);*/
	GUJING *CCNN1=new GUJING[segmentCount];
	for (int i = 0; i < segmentCount; i++) 
	{
		CCNN1[i].GNO=i+1;
		CCNN1[i].GSDEP=segments[i][0]->fdep;
		if(i+1==segmentCount)
			CCNN1[i].GEDEP=segments[i][segmentLengths[i]-1]->fdep;
		else
			CCNN1[i].GEDEP=segments[i+1][0]->fdep;
		CCNN1[i].GRESULT=Grs(segmentAverages[i],segmentGAverages[i],S1,S2,S3,L1,L2,L3,G1);
	}
	/*FILE *tb11;
	tb11=fopen("E:\\CN1.txt","w");
	for (int i = 0; i < segmentCount; i++) 
	{
		fprintf(tb11,"%d\t",CCNN1[i].GNO);
		fprintf(tb11,"%f\t",CCNN1[i].GSDEP);
		fprintf(tb11,"%f\t",CCNN1[i].GEDEP);
		fprintf(tb11,"%d\t",CCNN1[i].GRESULT);
		fprintf(tb11,"\n");
	}
	fclose(tb11);*/
	for (int i = 1; i < segmentCount-1; i++) 
	{
		if(CCNN1[i].GEDEP-CCNN1[i].GSDEP<0.5&&CCNN1[i].GRESULT==1)
		{
			if(CCNN1[i-1].GRESULT==CCNN1[i+1].GRESULT)
				CCNN1[i].GRESULT=CCNN1[i-1].GRESULT;
		}
	}
	for (int i = 1; i < segmentCount-1; i++) 
	{
		if(CCNN1[i].GEDEP-CCNN1[i].GSDEP<0.5)
		{
			if(CCNN1[i-1].GRESULT==CCNN1[i+1].GRESULT&&CCNN1[i-1].GRESULT==1)
				CCNN1[i].GRESULT=1;
		}
	}


	GUJING *CCNN2=new GUJING[segmentCount];
	int CN2=1;
	CCNN2[0]=CCNN1[0];
	CCNN2[0].GNO=1;
	for (int i = 0; i <  segmentCount-1; i++) 
	{		
		if(CCNN1[i].GRESULT==CCNN1[i+1].GRESULT)
		{
			CCNN2[CN2-1].GEDEP=CCNN1[i+1].GEDEP;
		}
		else
		{
			CCNN2[CN2]=CCNN1[i+1];
			CCNN2[CN2].GNO=CN2+1;
			CN2++;	
		}
	}
	/*FILE *tb1;
	tb1=fopen("E:\\CN2.txt","w");
	for (int i = 0; i < CN2; i++) 
	{
		fprintf(tb1,"%d\t",CCNN2[i].GNO);
		fprintf(tb1,"%f\t",CCNN2[i].GSDEP);
		fprintf(tb1,"%f\t",CCNN2[i].GEDEP);
		fprintf(tb1,"%d\t",CCNN2[i].GRESULT);
		fprintf(tb1,"\n");
	}
	fclose(tb1);*/

	for (int i = 1; i < CN2-1; i++) 
	{
		if(CCNN2[i].GEDEP-CCNN2[i].GSDEP<1&&CCNN2[i].GRESULT==1)
		{
			if(CCNN2[i-1].GRESULT==CCNN2[i+1].GRESULT)
				CCNN2[i].GRESULT=CCNN2[i-1].GRESULT;
		}
	}
	for (int i = 1; i < CN2-1; i++) 
	{
		if(CCNN2[i].GEDEP-CCNN2[i].GSDEP<1)
		{
			if(CCNN2[i-1].GRESULT==CCNN2[i+1].GRESULT&&CCNN2[i-1].GRESULT==1)
				CCNN2[i].GRESULT=1;
		}
	}
	GUJING *CCNN3=new GUJING[CN2];
	int CN3=1;
	CCNN3[0]=CCNN2[0];
	CCNN3[0].GNO=1;
	for (int i = 0; i <  CN2-1; i++) 
	{		
		if(CCNN2[i].GRESULT==CCNN2[i+1].GRESULT)
		{
			CCNN3[CN3-1].GEDEP=CCNN2[i+1].GEDEP;
		}
		else
		{
			CCNN3[CN3]=CCNN2[i+1];
			CCNN3[CN3].GNO=CN3+1;
			CN3++;	
		}
	}
	//float *CSLG=new float[FLE];
	for (int i = 0; i < CN3; i++) 
	{
		float cspr=0;
		float cgpr=0;
		float cns=0;
		for(int j = 0; j < FLE; j++) 
		{
			if(FDEP[j]>=CCNN3[i].GSDEP&&FDEP[j]<=CCNN3[i].GEDEP)
			{
				cspr=cspr+FSPR[j];
				cgpr=cgpr+FGPR[j];
				cns++;
			}
		}
		cspr=cspr/cns;
		cgpr=cgpr/cns;
		CCNN3[i].GRESULT=Grs(cspr,cgpr,S1,S2,S3,L1,L2,L3,G1);
	}
	for (int i = 1; i < CN3-1; i++) 
	{
		if(CCNN3[i].GEDEP-CCNN3[i].GSDEP<1)
		{
			if(CCNN3[i-1].GRESULT==CCNN3[i+1].GRESULT)
				CCNN3[i].GRESULT=CCNN3[i-1].GRESULT;
			else if(CCNN3[i-1].GRESULT<CCNN3[i+1].GRESULT)
				CCNN3[i].GRESULT=CCNN3[i-1].GRESULT;
			else if(CCNN3[i-1].GRESULT>CCNN3[i+1].GRESULT)
				CCNN3[i].GRESULT=CCNN3[i+1].GRESULT;
		}
	}
	GUJING *CCNN4=new GUJING[CN3];
	int CN4=1;
	CCNN4[0]=CCNN3[0];
	CCNN4[0].GNO=1;
	for (int i = 0; i <  CN3-1; i++) 
	{		
		if(CCNN3[i].GRESULT==CCNN3[i+1].GRESULT)
		{
			CCNN4[CN4-1].GEDEP=CCNN3[i+1].GEDEP;
		}
		else
		{
			CCNN4[CN4]=CCNN3[i+1];
			CCNN4[CN4].GNO=CN4+1;
			CN4++;	
		}
	}
	for (int i = 0; i < CN4; i++) 
	{
		float cspr=0;
		float cgpr=0;
		float cns=0;
		for(int j = 0; j < FLE; j++) 
		{
			if(FDEP[j]>=CCNN4[i].GSDEP&&FDEP[j]<=CCNN4[i].GEDEP)
			{
				cspr=cspr+FSPR[j];
				cgpr=cgpr+FGPR[j];
				cns++;
			}
		}
		cspr=cspr/cns;
		cgpr=cgpr/cns;
		CCNN4[i].GRESULT=Grs(cspr,cgpr,S1,S2,S3,L1,L2,L3,G1);
	}
	GUJING *CCNN5=new GUJING[CN4];
	int CN5=1;
	CCNN5[0]=CCNN4[0];
	CCNN5[0].GNO=1;
	for (int i = 0; i <  CN4-1; i++) 
	{		
		if(CCNN4[i].GRESULT==CCNN4[i+1].GRESULT)
		{
			CCNN5[CN5-1].GEDEP=CCNN4[i+1].GEDEP;
		}
		else
		{
			CCNN5[CN5]=CCNN4[i+1];
			CCNN5[CN5].GNO=CN5+1;
			CN5++;	
		}
	}
	for (int i = 0; i < CN5; i++) 
	{
		switch(CCNN5[i].GRESULT)
		{
		case 0:
			CCNN5[i].GRESULT=7;
			break;
		case 1:
			CCNN5[i].GRESULT=8;
			break;
		case 2:
			CCNN5[i].GRESULT=9;
			break;
		case 3:
			CCNN5[i].GRESULT=10;
			break;
		case 4:
			CCNN5[i].GRESULT=6;
			break;
		case 5:
			CCNN5[i].GRESULT=11;
			break;
		}
	}
	for (int i = 0; i < CN5; i++) 
	{
		MemRdWt.WriteTable(itable1, i+1, &CCNN5[i]);
	}
	for (int i = 0; i < CN5; i++) 
	{
		switch(CCNN5[i].GRESULT)
		{
		case 7:
			CCNN5[i].GRESULT=12;
			break;
		case 8:
			CCNN5[i].GRESULT=12;
			break;
		case 9:
			CCNN5[i].GRESULT=13;
			break;
		case 10:
			{
				float cspr=0;
				float cns=0;
				for(int j = 0; j < FLE; j++) 
				{
					if(FDEP[j]>=CCNN5[i].GSDEP&&FDEP[j]<=CCNN5[i].GEDEP)
					{
						cspr=cspr+FSPR[j];
						cns++;
					}
				}
				cspr=cspr/cns;
				if(cspr>100-S2)
					CCNN5[i].GRESULT=15;
				else
					CCNN5[i].GRESULT=14;
				break;
			}
		case 6:
			CCNN5[i].GRESULT=15;
			break;
		case 11:
			CCNN5[i].GRESULT=15;
			break;
		}
	}
	GUJING *CCNN6=new GUJING[CN5];
	int CN6=1;
	CCNN6[0]=CCNN5[0];
	CCNN6[0].GNO=1;
	for (int i = 0; i <  CN5-1; i++) 
	{		
		if(CCNN5[i].GRESULT==CCNN5[i+1].GRESULT)
		{
			CCNN6[CN6-1].GEDEP=CCNN5[i+1].GEDEP;
		}
		else
		{
			CCNN6[CN6]=CCNN5[i+1];
			CCNN6[CN6].GNO=CN6+1;
			CN6++;	
		}
	}
	for (int i = 0; i < CN6; i++) 
	{
		MemRdWt.WriteTable(itable2, i+1, &CCNN6[i]);
	}
	// 释放动态分配的内存
	delete[] CCNN1;
	delete[] CCNN2;
	delete[] CCNN3;
	delete[] CCNN4;
	delete[] CCNN5;
	delete[] CCNN6;
	delete[] fdpr;
    for (int i = 0; i < segmentCount; ++i) {
        delete[] segments[i];  // 释放每个段的动态数组
    }
    delete[] segments;  // 释放存储段指针数组
    delete[] segmentLengths;  // 释放段长度数组
    delete[] segmentAverages;  // 释放平均值数组
	delete[] segmentGAverages;
	delete[] FDEP;
	delete[] FSPR;
	delete[] FGPR;

	#pragma region 空间释放
	for(int _ii = 0; _ii< 36; _ii++)
	{
		delete []N2D[_ii];
	}delete []N2D;
	for(int _ii = 0; _ii < 36; _ii++)
	{
		delete []F2D[_ii];
	}delete []F2D;
	for(int _ii = 0; _ii < 72; _ii++)
	{
		delete []R2D[_ii];
	}delete []R2D;
	for(int _ii = 0; _ii < 72; _ii++)
	{
		delete []RR2D[_ii];
	}delete []RR2D;
	//近
	for(int _ii = 0; _ii < 36; _ii++)
	{
		delete []N_hx_abs[_ii];
	}delete []N_hx_abs;
	for(int _ii = 0; _ii < 36; _ii++)
	{
		delete []F_hx_abs[_ii];
	}delete []F_hx_abs;
	//共振
	for (int _ii = 0; _ii < 36; _ii++)
	{
		delete[]R_hx_group[_ii];
	}delete[]R_hx_group;
	for(int _ii = 0; _ii < 72; _ii++)
	{
		delete []R_hx_abs[_ii];
	}delete []R_hx_abs;
	for(int _ii = 0; _ii < 72; _ii++)
	{
		delete []R_XX_abs[_ii];
	}delete []R_XX_abs;
	for (int _ii = 0; _ii < 36; _ii++)
	{
		delete[]F_lb[_ii];
	}delete[]F_lb;
	#pragma endregion

	
	/*N2D = nullptr; 
	F2D = nullptr; 
	R2D = nullptr; 
	RR2D = nullptr; 
	N_hx_abs = nullptr; 
	F_hx_abs = nullptr; 
	R_hx_group = nullptr; 
	R_hx_abs = nullptr; 
	R_XX_abs = nullptr; 
	F_lb = nullptr; */

	cout << "The run time is: " << (float)clock() / CLOCKS_PER_SEC << "s" << endl;
	return 1;
}