#include "FormWave.h"
#include "ui_FormWave.h"
#include <QPainter>
#include "CallManage.h"
#include "forminfo.h"
#include "formtrack.h"
#include "geometryutils.h"
#include "qtColorSchemeComboBox.h"

extern double g_dPixelPerCm;//每厘米像素数

FormWave::FormWave(QWidget *parent, QString strSlfName, QString strWellName, QString strTrackName, QString strLineName) :
    QWidget(parent),
    ui(new Ui::FormWave)
{
    ui->setupUi(this);

    m_strSlfName = strSlfName;
    m_strWellName = strWellName;
    m_strTrackName = strTrackName;
    m_strLineName = strLineName;

	QString path = GetConfPath() + "selfcolorrank.ini";
	FILE*fp = fopen(path.toStdString().c_str(), "rt");
	if (fp)
	{
		float val = 0;
		while (!feof(fp))
		{
			if (fscanf(fp, "%f\n", &val))
			{
				selfcolorrank.append(val);
			}
		}
		fclose(fp);
	}
	changeColor(schemIndex, colornum);

	LoadFromSLF_wave();


    m_parent = parent;
    //斜井三图一表
//     connect(CallManage::getInstance(), SIGNAL(sig_ChangeTvdProperty(QString, QString, QString, QString, QString, QString, QString, QVariant)),
//             this, SLOT(s_ChangeTvdProperty(QString, QString, QString, QString, QString, QString, QString, QVariant)));
    //自定义滚动条
    //connect(CallManage::getInstance(), SIGNAL(sig_vertScrollBarChanged_santuyibiao(QString, double, double, double)), this, SLOT(vertScrollBarChanged(QString, double, double, double)));
    //打印
    //connect(CallManage::getInstance(), SIGNAL(sig_vertScrollBarChanged_santu_Print(QString, int, int)), this, SLOT(vertScrollBarChanged_Print(QString, int, int)));
	connect(CallManage::getInstance(), SIGNAL(sig_vertScrollBarChanged(QString, double, double, double)), this, SLOT(vertScrollBarChanged(QString, double, double, double)));
	connect(CallManage::getInstance(), SIGNAL(sig_vertScrollBarChanged_setGeometry(QString, double, double, double, int)), this, SLOT(vertScrollBarChanged_setGeometry(QString, double, double, double, int)));
	connect(CallManage::getInstance(), SIGNAL(sig_ResizeDepth(QString, int, float)), this, SLOT(s_ResizeDepth(QString, int, float)));
}

FormWave::~FormWave()
{
    delete ui;
}

void FormWave::initGeometry(QString strUuid, int nscale, double fW, int nH)
{
	if (strUuid.length() > 0)
		this->m_strUuid = strUuid;
	m_iScale = nscale;

// 	double dHight = (m_iY2 - m_iY1)*100.0 / (double)nscale * g_dPixelPerCm;
// // 	if (g_iShow == 1)
// // 	{
// // 		//显示刻度
// // 		dHight = dHight + 30;
// // 	}
// 
// 	qDebug() << "FormWave dHight=" << QString::number((int)dHight);
// 	if (dHight > 32767)
// 	{
// 		dHight = 32767;
// 	}

	int ntmpw = fW * g_dPixelPerCm;
	this->setGeometry(0, 0, ntmpw - 2, (int)nH);

	//修改滚动条，针对新建的
	emit CallManage::getInstance()->sig_changeScrollBar(m_strUuid);
}

void FormWave::setDepthY(float fy1, float fy2)
{
	this->m_iY1 = fy1;
	this->m_iY2 = fy2;

	m_PlotSdep = qAbs(this->m_iY2);
	m_fTopY = m_PlotSdep;
}

void FormWave::updateDepthY(float fy1, float fy2)
{
	this->m_iY1 = fy1;
	this->m_iY2 = fy2;
	m_fTopY = qAbs(this->m_iY2);
	update();
}

bool FormWave::LoadFromSLF_wave()
{
	CLogIO * logio = new CLogIO();
	if (!logio->Open(m_strSlfName.toStdString().c_str(), CSlfIO::modeRead))
	{
		delete logio;
		m_vMD.SetSize(0);
		m_vMD.m_vProperty = 0;
		m_vProperty.SetSize(0);
		m_vProperty.m_vProperty = NULL;
		return false;
	}
	int curveindex = logio->OpenWave(m_strLineName.toStdString().c_str());
	if (curveindex < 0)
	{
 		m_vMD.SetSize(0);
 		m_vMD.m_vProperty = 0;
 		m_vProperty.SetSize(0);
 		m_vProperty.m_vProperty = NULL;
		delete logio;
		return false;
	}
	//m_ObjectType = WAVE_OBJECT;
	logio->GetWaveInfo(curveindex, &waveinfo);
// 	if (m_ArrayNum > 1) {
// 		if (waveinfo.RepCode == REPR_CHAR) waveinfo.RepCode = REPR_UCHAR;
// 	}
// 	acurveinfo.RepCode = waveinfo.RepCode;
// 	acurveinfo.CodeLen = waveinfo.CodeLen;
// 	acurveinfo.DepLevel = waveinfo.DepLevel;
// 	acurveinfo.StartDepth = waveinfo.StartDepth;
// 	acurveinfo.EndDepth = waveinfo.EndDepth;
// 	isRun = true;

	int samplenum = (waveinfo.EndDepth - waveinfo.StartDepth) / waveinfo.DepLevel + 1.5;
	QString name = m_strSlfName + m_strLineName;
// 	if (m_ArrayNum > 1) {
// 		name += "Array";
// 	}
// 	key = name;
	int nbpp = waveinfo.SamplePoint;
	int mlen = 0;
	int myWidth = 0;
	int chlen = 0;
	int nPadZ = 0;
	int myWidth1 = waveinfo.SamplePoint;
	int shift0 = 0;
// 	if (m_ArrayNum > 1) {
// 		shift0 = pMsa->shift0;
// 		nPadZ = pMsa->nPadZ;
// 		myWidth = pMsa->Width;
// 		nbpp = pMsa->nSample;
// 		m_ArrayNum = pMsa->nPad;
// 		mlen = myWidth - m_ArrayNum * nbpp;//总盲区宽度
// 		mlen /= m_ArrayNum;
// 		if (mlen % 2 != 0) mlen += 1;
// 		if (nPadZ < 4) chlen = mlen / 8;
// 		else chlen = mlen / 4;
// 		if (chlen % 2 != 0) chlen += 1;
// 		if (chlen == 0) chlen = 2;
// 		//		mlen=mlen-chlen;
// 		mlen = m_ArrayNum * chlen / nPadZ;
// 		if (mlen % 2 != 0) mlen++;
// 		if (mlen > 20) mlen = 20;
// 		if (chlen < 4) chlen = 4;
// 		//		chlen=(myWidth-(mlen*m_ArrayNum+nbpp*m_ArrayNum))/nPadZ;
// 		int klen = pMsa->nPadZ*waveinfo.SamplePoint + mlen + pMsa->nPadZ*chlen;
// 		myWidth1 = klen * pMsa->nPad / pMsa->nPadZ;
// 	}
// 	else 
 	myWidth = waveinfo.SamplePoint;
	int nlen = waveinfo.CodeLen*waveinfo.SamplePoint;
	int reclen = waveinfo.CodeLen*myWidth*waveinfo.ArrayNum;

	m_SDep = waveinfo.StartDepth;
	m_EDep = waveinfo.EndDepth;
	m_Rlev = waveinfo.DepLevel;
	m_nSamples = waveinfo.SamplePoint*waveinfo.ArrayNum;
	m_PointNum = (float)(fabs((m_EDep - m_SDep) / m_Rlev + 0.5));

	m_sharedMemory.setKey(name);
	// 3. 创建或附加到共享内存
	if (m_sharedMemory.isAttached())
	{
		m_sharedMemory.detach();
	}

	int nMemnum = 3 * sizeof(float) + sizeof(int) + reclen * (samplenum + 1);

	if (!m_sharedMemory.attach())
	{
		// 尝试创建共享内存
		if (!m_sharedMemory.create(nMemnum))
		{
			qDebug() << "Failed to create shared memory:"
				<< m_sharedMemory.errorString();
			return false;
		}

		float *buffer = (float*)m_sharedMemory.data();
		buffer[0] = waveinfo.StartDepth;
		buffer[1] = waveinfo.EndDepth;
		buffer[2] = waveinfo.DepLevel;
		((int *)buffer)[3] = samplenum;
		char *pchar = (char *)&buffer[4];
		//double laa = (double)reclen*(double)samplenum / waveinfo.CodeLen;
		int num = reclen * samplenum / waveinfo.CodeLen;
		float defval = -9999;
		if (waveinfo.RepCode == REPR_CHAR || waveinfo.RepCode == REPR_UCHAR) defval = 0;
		else if (waveinfo.RepCode == REPR_SHORT || waveinfo.RepCode == REPR_USHORT) defval = 0xffff;

		for (int i = 0; i < num; i++)
		{
			this->SetData(waveinfo.RepCode, &pchar[i*waveinfo.CodeLen], defval);
		}

		logio->ReadWave(curveindex, waveinfo.StartDepth, samplenum, (void *)pchar);
	}

	// 4. 锁定共享内存并写入数据
	if (!m_sharedMemory.lock())
	{
		qDebug() << "Failed to lock shared memory";
		m_sharedMemory.detach();
		return false;
	}

	m_vMD.SetSize(3);
	m_vMD.m_vProperty = (float *)m_sharedMemory.data();
	int size = ((int *)m_sharedMemory.data())[3];
	m_vProperty.SetSize(size);
	m_vProperty.m_vProperty = &m_vMD.m_vProperty[4];

	if (m_vMD.size() > 0) {
		m_TopDepth = m_vMD.m_vProperty[0];
		m_BottomDepth = m_vMD.m_vProperty[1];
		m_Rlev = m_vMD.m_vProperty[2];
	}

	float val = 0;
	valMin.clear();
	valMax.clear();
	valMin.resize((waveinfo.SamplePoint)*waveinfo.ArrayNum);
	valMax.resize((waveinfo.SamplePoint)*waveinfo.ArrayNum);
	for (int j = 0; j < (waveinfo.SamplePoint)*waveinfo.ArrayNum; j++) {
		valMin[j] = 999999999;
		valMax[j] = -99999999;
	}
	char buf[200];
	for (int i = 0; i < samplenum; i++) {
		for (int j = 0; j < waveinfo.SamplePoint*waveinfo.ArrayNum; j++)
		{
			val = GetData(i, j, buf);
			if (val == 0 || val == -9999 || val == -999.25 || val == -99999 || val == -32767 || val == 32767) continue;
			if (_isnan(val) || !_finite(val)) continue;
			if (valMax[j] < val)valMax[j] = val;
			if (valMin[j] > val)valMin[j] = val;
		}
	}
	if (waveinfo.MaxValue == -50 || waveinfo.MinValue == 50 || fabs(waveinfo.MaxValue) < 1e-6 || waveinfo.MinValue < 1e-6 || waveinfo.MaxValue == -99999 || waveinfo.MaxValue == -9999 || waveinfo.MinValue == 999999 || waveinfo.MinValue == 999999 || waveinfo.MinValue == 99999 || waveinfo.MinValue == 99999 || waveinfo.MinValue == -9999)
	{
		float valmin = 99999;
		float valmax = -99999;
		for (int j = 0; j < waveinfo.SamplePoint*waveinfo.ArrayNum; j++) {
			if (valmin > valMax[j]) valmin = valMax[j];
			if (valmin > valMin[j]) valmin = valMin[j];
			if (valmax < valMin[j]) valmin = valMin[j];
			if (valmax < valMax[j]) valmax = valMax[j];
		}
		waveinfo.MaxValue = valmax;
		waveinfo.MinValue = valmin;
		//BWAVEINFO.MaxValue = valmax;
		//BWAVEINFO.MinValue = valmin;
		//logio->SetWaveInfo(curveindex, &BWAVEINFO);
	}
	m_sharedMemory.unlock();
	
	logio->Clear();
	delete logio;

	return true;
}

void FormWave::changeColor(int nidx, int ncolorNum)
{
	QList<QRgb> rgbList = QtColorTableData::getInstance()->GetRgb_UseTag(0, nidx, ncolorNum);
	for (int i = 0; i < rgbList.size(); i++)
	{
		QColor acolor = rgbList.at(i);
		m_Color[i] = acolor;
	}
}

void FormWave::paintEvent(QPaintEvent*)
{
    //
    QPainter painter(this);
    QRect rect = this->rect();
    // QRect rect = m_parent->rect();
    //背景透明
    painter.fillRect(rect.left(), rect.top(), rect.width(), rect.height(), QColor(0, 0, 0, 0)); //QColor(67, 67, 67, 100)
	if (m_formTrack)
	{
		this->DrawWave(&painter, rect);
	}

}

void FormWave::s_ResizeDepth(QString strUuid, int nHeight, float fDepthLowerY)
{
	if (m_strUuid != strUuid)
		return;

	this->setFixedHeight(nHeight);
	m_fDepthLowerY = qAbs(fDepthLowerY);
	m_fAddY = m_fDepthLowerY - m_fTopY;
}

void FormWave::s_ChangeTvdProperty(QString strUuid, QString strSlfName, QString strWellName, QString strTrackName, QString strLineName,
                         QString strGroup, QString strProperty, QVariant variant)
{
    if(m_strUuid != strUuid ||
        m_strSlfName != strSlfName ||
        m_strWellName != strWellName ||
        m_strTrackName != strTrackName ||
        m_strLineName != strLineName)
    {
        return;
    }
   if("通常" == strGroup)
    {

    }
    if("绘制图形对象" == strGroup)
    {
       
    }
    if("边框线型" == strGroup)
    {
		if ("线宽" == strProperty)
			;
		else if ("颜色" == strProperty)
			;
    }
 
    update();
}

//自定义滚动条
void FormWave::vertScrollBarChanged(QString strUuid, double value, double low, double upper)
{
    if(m_strUuid==strUuid)
    {
    }
    else
    {
        return;
    }
	m_fTopY = value;
	update();
}

//打印
void FormWave::vertScrollBarChanged_Print(QString strUuid, int iNum, int iHeightOfScreen)
{
    if(m_strUuid==strUuid)
    {
    }
    else
    {
        return;
    }
    //上移或下移
    QRect geoRect = geometry();
    //
    double dDelta = iHeightOfScreen*(iNum-1);
    setGeometry(0, -dDelta, geoRect.width(), geoRect.height());
}

void FormWave::vertScrollBarChanged_setGeometry(QString strUuid, double value, double low, double upper, int ndepth)
{
	if (m_strUuid == strUuid)
	{
	}
	else
	{
		return;
	}
	m_fTopY = ndepth;
	update();
}

void FormWave::wheelEvent(QWheelEvent *event)    // 滚轮事件
{
    emit CallManage::getInstance()->sig_mouseWheel(event);
}

/*图像的转置函数*/
QImage Transpose(QImage* image)
{
	QImage newImage(image->height(), image->width(), QImage::Format_ARGB32);
	unsigned char* copyPixel = NULL;
	unsigned char* objPixel = NULL;
	unsigned int tempJ = 0;
	for (int j = 0; j < image->height(); j++)
	{
		for (int i = 0; i < image->width(); i++)
		{
			copyPixel = image->bits() + j * image->width() * 4 + i * 4;
			objPixel = newImage.bits() + i * image->height() * 4 + j * 4;
			memcpy(objPixel, copyPixel, 4);
		}
	}
	return newImage;
}
/*图像的转置函数*/
QImage TTranspose(QImage* image)
{
	QImage newImage(image->width(), image->height(), QImage::Format_ARGB32);
	unsigned char* copyPixel = NULL;
	unsigned char* objPixel = NULL;
	unsigned int tempJ = 0;
	for (int j = 0; j < image->height(); j++)
	{
		memmove((void *)newImage.constScanLine(j), (void *)image->constScanLine(image->height() - 1 - j), image->bytesPerLine());
	}
	return newImage;
}

void FormWave::DrawWave(QPainter* pdc, QRectF mrt1)
{
	if (m_vMD.size() <= 0 || m_vProperty.size() <= 0)
	{
		return;
	}
	if (m_pInfo == NULL)
	{
		m_pInfo = m_formTrack->getFormInfoByParameters(m_strUuid, m_strWellName, m_strTrackName, m_strLineName);
	}
	if (m_pInfo == NULL)
		return;

	if (!m_pInfo->m_pWave)
	{
		m_pInfo->m_pWave = this;
	}

	if (m_pInfo->m_nSchemeIndex != schemIndex || m_pInfo->m_nColorNum != colornum)
	{
		schemIndex = m_pInfo->m_nSchemeIndex;
		colornum = m_pInfo->m_nColorNum;
		changeColor(schemIndex, colornum);
	}

	if (m_vMD.m_vProperty) {
		m_EDep = m_vMD.m_vProperty[1];
		m_SDep = m_vMD.m_vProperty[0];
		m_Rlev = m_vMD.m_vProperty[2];
	}

	float m_MaxRange = m_pInfo->m_fMaxAmp;
	float m_Base = m_pInfo->m_fWaveBase;
	if (fabs(m_MaxRange - /*mWaveMes.*/m_Base) < 1e-6) {
		m_MaxRange = waveinfo.MaxValue;
		//objViewInfo->m_maxRange = mWaveMes.m_MaxRange;
	}

	float m_flRlev2 = waveinfo.TimeLevel;
	QColor crColor = qRgb(0, 200, 200);
	QPen cPen;
	QBrush cBrush;
	float sdep, edep, scale, flDepthScale, temp;
	int   i, j, k, iPoint = 0, nOffset = 0;
	float y = 9999999.0;
	//POINT *points;
	flDepthScale = 1;
	float te00 = 0;

	qDebug() << "FormWave : m_fTopY " << m_fTopY;
	// 计算显示深度
	float sdepc = m_fTopY, edepc = m_fTopY + m_fAddY;
	QRectF rt;// = mrt1;
	//GetDepth(pdc, mrt1, rt, sdep, edep, sdepc, edepc);
	int SamplePoint = 0;
	if (sdep > m_EDep) sdep = m_EDep;
	if (edep < m_SDep) edep = m_SDep;
	if (sdep < m_SDep) sdep = m_SDep;
	if (edep > m_EDep) edep = m_EDep;
	if (edep < sdep) edep = sdep;
	// 计算开始数据点及数据点数
	temp = (sdep - m_SDep) / m_Rlev;
	iPoint = (float)(temp + 0.5);
	int nPoint, lpoint, flag, nFillPoint, m, nStep;
	int iStartPoint = 0;
	float ch, nRep;
	int flColorScale;
	int m_ArrayNum = 0;

	QRectF mrt = mrt1;
	float y0 = mrt1.top();//ConvertY0(sdepc);
	float y1 = mrt1.bottom();//ConvertY0(edepc);
	float ddep = (y1 - y0);

	rt = mrt;
	QRectF rtd = mrt;
	QRectF tt;
	if (m_flRlev2 <= 0) m_flRlev2 = 0.1;
	int Mode = m_pInfo->m_nCurveMode;// objViewInfo->GetLogarithmic();
	//objViewInfo->m_Rlev = waveinfo.DepLevel;
	if (Mode == 2 || Mode == 5) {
		if (m_pInfo->m_vmin < waveinfo.StartTime)m_pInfo->m_vmin = waveinfo.StartTime;
		if (m_pInfo->m_vmax < waveinfo.StartTime)m_pInfo->m_vmax = waveinfo.StartTime;
// 		if (mWaveMes.m_Left < waveinfo.StartTime)mWaveMes.m_Left = waveinfo.StartTime;
// 		if (mWaveMes.m_Right < waveinfo.StartTime)mWaveMes.m_Right = waveinfo.StartTime;
		temp = m_nSamples;
	}
	else if (Mode == 3) {
		if (m_pInfo->m_ArrayNum > 1) {
			m_ArrayNum = m_pInfo->m_ArrayNum;
			SamplePoint = m_nSamples / m_ArrayNum;
		}
		else {
			m_ArrayNum = sqrt((double)m_nSamples);
			m_pInfo->m_ArrayNum = m_ArrayNum;
			SamplePoint = m_ArrayNum;
		}
		temp = SamplePoint;//(mWaveMes.m_Right - mWaveMes.m_Left) / m_flRlev2;
	}
	else if (Mode == 6) {
		if (m_pInfo->m_vmin < pow(2.f, waveinfo.StartTime))m_pInfo->m_vmin = pow(2.f, waveinfo.StartTime);
		if (m_pInfo->m_vmax < pow(2.f, waveinfo.StartTime))m_pInfo->m_vmax = pow(2.f, waveinfo.StartTime);
		temp = m_nSamples;
	}
	else {
		temp = (m_pInfo->m_vmax - m_pInfo->m_vmin) / m_flRlev2;
	}
	if (temp < 0)
		temp -= 0.5;

	nPoint = fabs(temp);
	QPointF  *cPoints = new QPointF[nPoint + 10];
	QPointF  *points = new QPointF[nPoint + 10];
	cBrush = QBrush();
	cPen = QPen();
// 	osg::Vec4f vco = objViewInfo->GetLineProperty().GetLineColor();
// 	if (!m_pWellSceneManager->m_isColorPrint) {
// 		cPen.setColor(qRgb(0, 0, 0));
// 	}
	//else 
	cPen.setColor(m_pInfo->m_lineColor);// QColor::fromRgb(vco[0] * 255, vco[1] * 255, vco[2] * 255, vco[3] * 255));
	cPen.setWidth(m_pInfo->m_dWidth);// objViewInfo->GetLineProperty().GetLineWidth());
	cPen.setStyle(m_pInfo->m_lineStyle);
// 	osgLineStyle iLineStyle = objViewInfo->GetLineProperty().GetLineStyle();
// 	TranslateOSGLineStyleToQtPenStyle(cPen, iLineStyle);
	switch (m_pInfo->m_nDrawType)
	{
	case 1:
		switch (m_pInfo->m_nFillType){//mWaveMes.Mode) {
		case 1:
		case 2:
			cBrush = QBrush(m_pInfo->m_FillColor);
			break;
		}
		break;
	case 2:
	case 6:
	case 10:
	case 13:
		cBrush = QBrush();
		break;
	}
	j = 0;

	float d = 1;

	if (m_pInfo->m_nDrawType/*mWaveMes.WaveType*/ == 6) {
		float w = rt.width();
		if (nPoint > 1) scale = w / (float)(nPoint - 1);
		else scale = w;
	}
	else {
		if (nPoint > 1) scale = ((float)rt.right() - (float)rt.left()) / (float)(nPoint - 1);//change by whp 11.13 from nPoint to nPoint-1因为波列画不到头
		else scale = ((float)rt.right() - (float)rt.left());
	}
	lpoint = (/*mWaveMes.m_Left*/m_pInfo->m_vmin - waveinfo.StartTime) / m_flRlev2;

	float dpoint = (edepc - sdepc) / m_Rlev;
	if (dpoint < 1) {
		delete cPoints;
		delete points;
		return;
	}
	int v = qRound(dpoint / mrt.height() + 0.5);
	if (v < 1) v = 1;
	float MH = 0;
	if (m_ArrayNum) {
		//WellWindowViewInfo *m_pWellWindowViewInfo = dynamic_cast<WellWindowViewInfo *>(m_pSceneManager->GetViewInfo(m_pSceneManager->GetVecWindow()->GetWindowID()));
		float scale = m_iScale;
		//if (m_pWellWindowViewInfo) {
		//	scale = m_pWellWindowViewInfo->GetYScale();
		//}
		MH = 2;
		if (scale == 1000) MH = 10;
		else if (scale == 2000) MH = 20;
		nStep = ((int)(MH / m_Rlev + 0.5));
		// 		if (objViewInfo) {
		// 			if (objViewInfo->GetisDot()) nStep = mWaveMes.m_WaveSpace;
		// 		}
	}
	else
		nStep = m_pInfo->m_nWaveJg;// .m_WaveSpace;
	if (nStep < 1) nStep = 1;
	if (nStep < v) nStep = v;
	float m_r = m_Rlev * nStep;
	float dd = (ddep) / dpoint;
	nRep = fabs(dd)*nStep;
	if (nRep < 1) nRep = 1;

	pdc->setPen(cPen);
	pdc->setBrush(cBrush);
	// 绘制
	float Base0;
	QRectF wrt;
	int dep = 0;
	float m_MoveDep = 0;
	float m_MoveSdep = -9999;
	float m_MoveEdep = -9999;
// 	if (m_pWellLog)
// 	{
// 		m_MoveDep = m_pWellLog->GetShiftOffset();
// 		m_MoveSdep = m_pWellLog->GetShiftTopDepth();
// 		m_MoveEdep = m_pWellLog->GetShiftBottomDepth();
// 		if (m_MoveDep != 0 && m_MoveDep != -9999 && (m_MoveSdep == -9999.0 || m_MoveEdep == -9999.0)) {
// 			m_MoveSdep = m_SDep;
// 			m_MoveEdep = m_EDep;
// 		}
// 	}
	////////////深度方向比例因子
	float yscale = m_pInfo->m_fWaveHei;// mWaveMes.m_WaveHight;
	//if (mWaveMes.WaveType == 0 || mWaveMes.WaveType == 1)
	if (m_pInfo->m_nDrawType == 0 || m_pInfo->m_nDrawType == 1)
		yscale *= g_dPixelPerCm;// m_pSceneManager->GetCoordinate()->GetPixelPerCm();
	float base = m_pInfo->m_fWaveBase; //mWaveMes.m_Base;
	if (Mode == AXIS_LOGARITHMIC) {
		if (base < 0) base = 0.1;
		if (m_pInfo->m_nDrawType == 6 || m_pInfo->m_nDrawType == 2) {
			float DifBase = (log10(/*mWaveMes.m_MaxRange*/m_MaxRange) - log10(base)) / m_pInfo->m_nColorNum;
			if (fabs(DifBase) <= 1e-6) DifBase = 1;
			yscale = yscale / DifBase;
		}
	}
	else
	{
		float DifBase = 1;
		if (m_pInfo->m_nDrawType == 2 || m_pInfo->m_nDrawType == 6 || m_pInfo->m_nDrawType == 10) {
			DifBase = (m_MaxRange - m_Base) / m_pInfo->m_nColorNum;
		}
		else {
			DifBase = (m_MaxRange - m_Base) / 1;
		}
		if (fabs(DifBase) <= 1e-6) DifBase = 1;
		yscale = yscale / DifBase;
	}
	if (_isnan(m_MaxRange) || !_finite(m_MaxRange)) yscale = 1;

	int mOffset = m_MoveDep / m_Rlev;
	float detp = sdepc;
	int ppos = 0;
	float vval = 0;
	if (detp < m_PlotSdep) detp = m_PlotSdep;
	detp = sdepc;
	int tl = m_pInfo->m_vmin;
	int atime = 0;
// 	if (m_vTimeMD.size()) {
// 		vTime.vchar = &((char *)m_vTimeProperty.m_vProperty)[0 * TimeCurveInfo.TimeSamples*TimeCurveInfo.CodeLen];
// 		float vval = GetData(TimeCurveInfo.RepCode, (char *)&vTime.vchar[0 * TimeCurveInfo.CodeLen]);
// 		if (vval == -32767) vval = 0;
// 		for (int i = 1; i < TimeCurveInfo.TimeSamples; i++) {
// 			float vval1 = GetData(TimeCurveInfo.RepCode, (char *)&vTime.vchar[i*TimeCurveInfo.CodeLen]);
// 			if (vval == -32767) vval = 0;
// 			if (tl >= vval && tl < vval1) atime = vval;
// 			if (tl == vval1) atime = vval1;
// 		}
// 	}
	//////////////////// 数据值方向
	int left = 0;
	int right = 0;
	if (Mode == AXIS_LINEAR || Mode == AXIS_LOGARITHMIC || Mode == 4) {
		left = (tl - waveinfo.StartTime + atime) / m_flRlev2;
		right = (m_pInfo->m_vmax - waveinfo.StartTime) / m_flRlev2;
	}
	else if (Mode == 2) {
		left = 0;
		right = m_nSamples;
	}
	else if (Mode == 3) {
		left = 0;
		if (m_pInfo->m_ArrayNum > 1) {
			right = m_nSamples / m_ArrayNum;
		}
		else {
			right = sqrt((double)m_nSamples);
		}
	}
	else if (Mode == 5) {
		if (waveinfo.StartTime <= 0) {
			left = log10(m_pInfo->m_vmin / 1) / m_flRlev2 + 0.5;
			right = log10(m_pInfo->m_vmax / 1) / m_flRlev2 + 1.5;
		}
		else {
			left = log10(m_pInfo->m_vmin / waveinfo.StartTime) / m_flRlev2 + 0.5;
			right = log10(m_pInfo->m_vmax / waveinfo.StartTime) / m_flRlev2 + 1.5;
		}
	}
	else if (Mode == 6) {
		left = log10(m_pInfo->m_vmin / waveinfo.StartTime) / m_flRlev2 + 0.5;
		right = log10(m_pInfo->m_vmax / waveinfo.StartTime) / m_flRlev2 + 1.5;
	}
	if (right == left) right = left + 1;
	if (m_pInfo->m_nDrawType == 10) {
		if (left > m_pInfo->m_FirstRange) left = m_pInfo->m_FirstRange;
		if (right < m_pInfo->m_EndRange) right = m_pInfo->m_EndRange;
	}
	if (m_pInfo->m_nDrawType == 0 || m_pInfo->m_nDrawType == 1)
	{
		if (abs(right - left) > 1) {
			scale = rt.width() / (right - left - 1);
		}
		else scale = rt.width();
	}
	else scale = rt.width() / (right - left);
	int left1 = left;
	int right1 = right;
	if (left > right) {
		left1 = right;
		right1 = left;
	}
	if (left1 < 0) left1 = 0;
	if (right1 > m_nSamples) right1 = m_nSamples;

	/////////////绘图缓冲区
	int w = right1 - left1;
	float yy0 = mrt.top();
	float yy1 = mrt.bottom();
	float curEdep = edepc;
	float curSdep = sdepc;
	//if (pWellNode->m_curEdep - pWellNode->m_curSdep <= 0) return;
	if (curEdep - curSdep <= 0) return;
	d = (yy1 - yy0) / (curEdep - curSdep);
	wrt.setTop((int)(yy0));
	wrt.setBottom((int)(yy1));

	if (left > right) {
		wrt.setLeft(rt.left() + (left1 - right)*scale);
		wrt.setRight(rt.right() - (right1 - left)*scale);
	}
	else {
		wrt.setLeft(rt.left() + (left1 - left)*scale);
		wrt.setRight(rt.left() + (right1 - left)*scale);
	}
	float h = int(wrt.height() / nRep + 0.5);
	QRectF srt(0, 0, w, h);
	QImage aa(srt.width(), srt.height(), QImage::Format::Format_RGB32);
	aa.fill(qRgba(255, 255, 255, 0));
	int mh = srt.bottom();
	float te01 = 0;
	float *val = NULL;
	int point = (m_EDep - m_SDep) / m_Rlev + 1.5;
	if (m_pInfo->m_nDrawType == 10) {
		val = new float[point + 1];
		CMemRdWt mrw;
		QString wellname(m_strSlfName);
		if (mrw.Open(wellname.toStdString().c_str()))  // 打开井文件
		{
			int index = mrw.OpenCurve("JIEGU");
			if (index > -1) {
				mrw.ReadCurve(index, m_SDep, point, val);
			}
			else {
				memset(val, 0, sizeof(float)*(point + 1));
			}
			mrw.Clear();
		}
	}
	int basecolor = m_pInfo->m_nColorNum / 4.0;
	QVector<float> vals;
	float vmin = waveinfo.MinValue;
	float vmax = -waveinfo.MaxValue;
	///////////////////////////////////////
	//	QRegion qRgn;
		//	rt.setBottom(rt.top()+ConvertY( eCoord_GEO,edepc,eCoord_GEONormal ));
		// 设置裁剪区域，预防画出边界
	//	qRgn = pdc->clipRegion();
	//	rt.adjust(0,0,0,1);
	pdc->setClipRect(rt);
	detp = int((detp - m_PlotSdep) / m_r)*m_r + m_PlotSdep;
	/*
		osg::Vec3d vecSheet;
		m_pSceneManager->GetCoordinate()->ConvertCoordDouble(this->GetID(),eCoord_GEO,osg::Vec3d(0,detp,0) ,eCoord_GDIPixel,vecSheet  );
		if(m_pWellSceneManager->IsWellSectonHorizonLayout()) yy0=vecSheet[0];
		else yy0=vecSheet[1];
		*/
		//	yy0=yy0-(pWellNode->m_curSdep-(detp-10*m_r))*d;
	pdc->setPen(m_pInfo->m_WaveColor);
	int odd = 0;
	int ifist = -lpoint, eend = nPoint;
	if (ifist < 0) ifist = 0;
	if (eend > m_nSamples - lpoint) eend = m_nSamples - lpoint;
// 	if (objViewInfo->GetisDrawBase()) {
// 		ifist = 0, eend = nPoint;
// 	}
	int m_Logarithmic = 0;

	int iIndex;
	for (float dep1 = detp - 10 * m_r; dep1 < edepc + m_MoveDep + 10 * m_r; dep1 += m_r)
	{
		odd++;
		dep = Slf_Int(dep1, curSdep, m_Rlev);
		if (dep1 > m_MoveSdep&&dep1 < m_MoveEdep) {
			dep -= mOffset;
			if (dep < 0) dep = 0;
			if (dep*m_Rlev + m_SDep > m_EDep) dep = (m_EDep - m_SDep) / m_Rlev;
		}
		if (dep1 >= m_EDep || dep1 + m_r < m_SDep)
		{
			continue;
		}
		iIndex = Slf_Int(dep1 + m_MoveDep, m_SDep, m_Rlev);
		if (iIndex < 0) {
			continue;
		}
		if (iIndex >= 0 && iIndex < m_PointNum&&iIndex < m_vProperty.size())
		{
			short nv = -9999.0f;
			vVdl.vchar = &((char *)m_vProperty.m_vProperty)[iIndex*m_nSamples*waveinfo.CodeLen];
// 			if (m_vTimeProperty.size()) {
// 				vTime.vchar = &((char *)m_vTimeProperty.m_vProperty)[iIndex*TimeCurveInfo.TimeSamples*TimeCurveInfo.CodeLen];
// 			}
// 			if (m_vGainProperty.size()) {
// 				vGain.vchar = &((char *)m_vGainProperty.m_vProperty)[iIndex*GainCurveInfo.TimeSamples*GainCurveInfo.CodeLen];
// 			}
		}
		else {
			continue;
		}
		y = yy0 + dep * dd;
		te00 = (int)((y - yy0) / nRep + 0.5);
		if (te00 >= mh) {
			te00 = mh - 1;
		}
		if (te01 == 0) te01 = te00;
		flag = 1;
		int Num = 0;
		Base0 = y;

		int i0 = 0;
		int pos = 0;
		int jpos = 0;
		int isVert = 0;// objViewInfo->GetIsVertDraw();
		switch (m_pInfo->m_nDrawType)
		{
		case 6:    // 变密度
		case 2:    // 变密度
		case 10:    // 电磁探伤
		case 13:    // 电磁探伤
			switch (m_pInfo->m_nFillType)
			{
			case 0:
				flag = 0;
				break;
			case 1:
				flag = 1;
				break;
			case 2:
				flag = -1;
			}

			if (!m_ArrayNum) {
				QRgb rgb = 0;
				for (int i = left1; i < right1; i += 1)
				{
					if (i < 0) continue;
					pos = i - left1;
					if (left > right || m_pInfo->m_nDrawType == 6) {
						pos = aa.width() - pos - 1;
					}
					if (pos >= aa.width() || pos < 0) continue;
					if (waveinfo.RepCode == REPR_CHAR) {
						ch = vVdl.vchar[i];
					}
					else if (waveinfo.RepCode == REPR_UCHAR) {
						ch = vVdl.vuchar[i];
					}
					else if (waveinfo.RepCode == REPR_SHORT) {
						ch = vVdl.vshort[i];
						if (ch == -32767) {
// 							if (objViewInfo->Getskipinval()) aa.setPixel(pos, j, qRgba(0, 0, 0, 0));
// 							else aa.setPixel(pos, j, qRgb(255, 255, 255));
							continue;
						}
					}
					else if (waveinfo.RepCode == REPR_USHORT) {
						ch = vVdl.vushort[i];
						if ((short)ch == -32767) {
// 							if (objViewInfo->Getskipinval()) aa.setPixel(pos, j, qRgba(0, 0, 0, 0));
// 							else aa.setPixel(pos, j, qRgb(255, 255, 255));
							continue;
						}
					}
					else if (waveinfo.RepCode == REPR_FLOAT) {
						ch = vVdl.vfloat[i];
						if (ch == -9999.0) {
// 							if (objViewInfo->Getskipinval()) aa.setPixel(pos, j, qRgba(0, 0, 0, 0));
// 							else aa.setPixel(pos, j, qRgb(255, 255, 255));
							continue;
						}
					}
					else ch = GetData(waveinfo.RepCode, (char *)&vVdl.vchar[i*waveinfo.CodeLen]);
					if (/*objViewInfo->GetisRGBA() || */m_pInfo->m_nDrawType == 13) {
						if (waveinfo.RepCode == REPR_UINT) {
							rgb = vVdl.vulong[i];
						}
						else rgb = ch;
					}
					else {
// 						if (m_vGainProperty.size()) {
// 							ppos = i / WaveInfo.TimeSamples;
// 							if (ppos < 0) ppos = 0;
// 							if (ppos >= GainCurveInfo.TimeSamples) ppos >= GainCurveInfo.TimeSamples - 1;
// 							vval = GetData(GainCurveInfo.RepCode, (char *)&vGain.vchar[ppos*GainCurveInfo.CodeLen]);
// 							if (vval == -32767) vval = 0;
// 							if (vval > 0 && vval < 1000) ch = 10 * ch / powf(1.4142, vval);
// 						}
						if (flag == 0) ch = fabs(ch);
						else ch = ch * flag;
						if (m_Logarithmic == AXIS_LOGARITHMIC) {
							ch = (ch - /*pWave->*/valMin[i]) / (/*pWave->*/valMax[i] - /*pWave->*/valMin[i]) * 100000;
							if (ch <= 0) ch = 0;
							else ch = log10(ch) - log10(base);
							m = (int)(ch*m_pInfo->m_nColorNum / log10(100000.0) + 0.5);
						}
						else if (m_Logarithmic == 4)
						{
							ch = ch - m_pInfo->m_bDrawBase;
							if (ch < 0) ch = 0;
							m = selfcolorrank.size();
							for (int j = 1; j < selfcolorrank.size(); j++)
							{
								float v0 = selfcolorrank[j - 1];
								float v1 = selfcolorrank[j];
								if (ch >= v0 && ch < v1)
								{
									m = j - 1;
									break;
								}
							}
						}
						else
						{
							if (m_pInfo->m_nDrawType == 10) {
								//平滑接箍
								if ((m_pInfo->m_vmax - waveinfo.StartTime) / waveinfo.TimeLevel > i&&i >= (m_pInfo->m_vmin - waveinfo.StartTime) / waveinfo.TimeLevel) {
									if (iIndex >= 6 && iIndex + 6 < point) {
										if (val && (val[iIndex - 4] || val[iIndex - 3] || val[iIndex - 2] || val[iIndex - 1] || val[iIndex] || val[iIndex + 1] || val[iIndex + 2] || val[iIndex + 3] || val[iIndex + 4])) {
											char *p = (char *)m_vProperty.m_vProperty;
											int j0 = iIndex - 1;
											if (val[iIndex - 4]) j0 = iIndex - 4;
											else if (val[iIndex - 3]) j0 = iIndex - 3;
											else if (val[iIndex - 2]) j0 = iIndex - 2;
											else if (val[iIndex - 1]) j0 = iIndex - 1;
											else if (val[iIndex]) j0 = iIndex;
											else if (val[iIndex + 1]) j0 = iIndex + 1;
											else if (val[iIndex + 2]) j0 = iIndex + 2;
											else if (val[iIndex + 3]) j0 = iIndex + 3;
											else if (val[iIndex + 4]) j0 = iIndex + 4;
											int j2 = j0;
											for (j2 = j0; j2 > 0; j2--) {
												if (val[j2] < 1) break;
											}
											int j1 = j0;
											for (j1 = j0; j1 < point; j1++) {
												if (val[j1] < 1) break;
											}
											int n = 0;
											if (j2 - 4 >= 0) {
												ch = GetData(waveinfo.RepCode, &p[(j2 - 4)* waveinfo.SamplePoint*waveinfo.ArrayNum*waveinfo.CodeLen + i * waveinfo.CodeLen]);
												n++;
											}
											if (j1 + 4 < point) {
												ch += GetData(waveinfo.RepCode, &p[(j1 + 4)* waveinfo.SamplePoint*waveinfo.ArrayNum*waveinfo.CodeLen + i * waveinfo.CodeLen]);
												n++;
											}
											if (n) ch /= n;
										}
									}
								}
								if (valMax[i] - valMin[i] == 0) m = 2 * basecolor;
								else {
									ch = (ch - valMin[i]) / (valMax[i] - valMin[i])*(m_pInfo->m_nColorNum - 2 * basecolor);
									m = ch * m_pInfo->m_fWaveHei + basecolor;
								}
							}
							else if (m_pInfo->m_midValue) {
								ch = (ch - valMin[i]) / (valMax[i] - valMin[i])*m_pInfo->m_midValue;
								m = (int)((ch - m_pInfo->m_fWaveBase)*yscale + 0.5);
							}
							else m = (int)((ch - m_pInfo->m_fWaveBase)*yscale + 0.5);
						}
						if (m >= m_pInfo->m_nColorNum) m = m_pInfo->m_nColorNum - 1;
						else if (m < 0) m = 0;
						rgb = m_Color[m].rgb();
					}
					if (te01 + 1 > te00) {
						if (te00 >= 0) {
							aa.setPixel(pos, te00, rgb);
						}
					}
					else for (int j = te01 + 1; j <= te00; j++) {
						if (j >= 0) {
							aa.setPixel(pos, j, rgb);
						}
					}
				}
			}
			else {
				QImage aaa = QImage(right1 - left1, m_ArrayNum, QImage::Format::Format_RGB32);
				float cc = 0;
				int nu0 = 0;
				bool ffg = 0;
				float m_LeftVal = 0;
				float m_RightVal = 0;
				for (int j = 0; j < m_ArrayNum; j++)
				{
					for (int i = left1; i < right1; i += 1)
					{
						if (i < 0) continue;
						pos = i - left1;
						if (m_RightVal < m_LeftVal || m_pInfo->m_nDrawType == 6)
						{
							pos = aaa.width() - pos - 1;
						}
						if (pos >= aaa.width() || pos < 0) continue;
						if (waveinfo.RepCode == REPR_CHAR) {
							ch = vVdl.vchar[j*SamplePoint + i];
						}
						else if (waveinfo.RepCode == REPR_UCHAR) {
							ch = vVdl.vuchar[j*SamplePoint + i];
						}
						else if (waveinfo.RepCode == REPR_SHORT) {
							ch = vVdl.vshort[j*SamplePoint + i];
						}
						else if (waveinfo.RepCode == REPR_USHORT) {
							ch = vVdl.vushort[j*SamplePoint + i];
						}
						else if (waveinfo.RepCode == REPR_FLOAT) {
							ch = vVdl.vfloat[j*SamplePoint + i];
						}
						else ch = GetData(waveinfo.RepCode, (char *)&vVdl.vchar[(j*SamplePoint + i)*waveinfo.CodeLen]);
						m = (int)((ch - m_pInfo->m_fWaveBase)*yscale + 0.5);
						if (m >= m_pInfo->m_nColorNum) m = m_pInfo->m_nColorNum - 1;
						else if (m < 0) m = 0;
						jpos = isVert ? m_ArrayNum - j - 1 : j;
						if (jpos < aaa.height()) {
							if (m_RightVal < m_LeftVal) pos = aaa.width() - pos - 1;
							aaa.setPixel(pos, jpos, m_Color[m].rgb());
						}
						if (!nu0)cc = ch;
						else if (!ffg&&cc != ch) ffg = true;
						nu0++;
					}
				}
				bool m_isDot = false;
				if (!ffg&&/*objViewInfo->GetisDot()*/m_isDot) continue;
				float v11 = MH;
				if (dep1 + MH > edepc) {
					v11 = dep1 + MH - edepc;
					v11 = MH - v11;
				}
				QRectF wrt1(wrt.left(), y, wrt.width(), v11 / m_Rlev * dd);
				int line = 0;
				bool m_IsExchange = false; //objViewInfo->m_IsExchange
				if (m_IsExchange) {
					aaa = Transpose(&aaa);
					aaa = TTranspose(&aaa);
					int w = aaa.width();
					int h1 = aaa.height();
					for (int i = 0; i < w; i++) aaa.setPixel(i, h1 - 1, qRgb(255, 255, 255));
					line = m_ArrayNum / m_r * v11;
					if (line > h1) line = h1;
					int line0 = 0;
					//					if(xban) {
					//						line0=xban*m_ArrayNum/m_r;
					//						dep1=vpos;
					//					}
					pdc->drawImage(wrt1, aaa, QRectF(0, line0, w, line - line0));
				}
				else {
					int w = aaa.width();
					int h1 = aaa.height();
					for (int i = 0; i < w; i++) aaa.setPixel(i, h1 - 1, qRgb(255, 255, 255));
					int line0 = 0;
					if (dep1 < sdepc) {
						//line0=(sdepc-dep1)*m_ArrayNum/m_r;
						h1 = (m_r - (sdepc - dep1)) / m_Rlev * dd;
					}
					line = m_ArrayNum / m_r * v11;
					if (line > m_ArrayNum) line = m_ArrayNum;

					pdc->drawImage(wrt1, aaa, QRectF(0, line0, right1 - left1, line - line0));
				}
			}
			break;
		case 0:// wf
		case 1://填充
		{
			vals.resize(nPoint);
			if (/*objViewInfo->m_Logarithmic==AXIS_LOGARITHMIC||*/
				m_pInfo->m_fMaxAmp == -99999) {
				vmin = waveinfo.MinValue;
				vmax = waveinfo.MaxValue;
			}
			for (int i = 0; i < nPoint; i++)
			{
				if (i + lpoint < 0) ch = 0;
				else if (i + lpoint < m_nSamples) {
					if (waveinfo.RepCode == REPR_CHAR) {
						ch = vVdl.vchar[i + lpoint];
					}
					else if (waveinfo.RepCode == REPR_UCHAR) {
						ch = vVdl.vuchar[i + lpoint];
					}
					else if (waveinfo.RepCode == REPR_SHORT) {
						ch = vVdl.vshort[i + lpoint];
						if (ch == -32767) ch = 0;
					}
					else if (waveinfo.RepCode == REPR_USHORT) {
						ch = vVdl.vushort[i + lpoint];
						if ((short)ch == -32767) ch = 0;
					}
					else if (waveinfo.RepCode == REPR_FLOAT) {
						ch = vVdl.vfloat[i + lpoint];
					}
					else ch = GetData(waveinfo.RepCode, (char *)&vVdl.vchar[(i + lpoint)*waveinfo.CodeLen]);
					if (ch == -9999.0 || ch == -99999.0 || ch == -999.25) ch = 0;
				}
				else ch = 0;
				vals[i] = ch;
				if (m_Logarithmic == AXIS_LOGARITHMIC ||
					m_pInfo->m_fMaxAmp == -99999) {
					if (vmin > ch) vmin = ch;
					if (vmax < ch) vmax = ch;
				}
			}
			int ffl = 0;
			float cc = 0;
			for (int i = ifist; i < eend; i++) {
				if (left <= right) temp = rt.left() + (i)*scale;
				else temp = rt.right() - (i)*scale;
				points[i].setX(temp);
				if (m_Logarithmic == AXIS_LOGARITHMIC) {
					ch = (vals[i] - vmin) / (vmax - vmin)*vmax;
					if (ch <= 0) ch = 1;
					ch = log10(ch);//-log10(mWaveMes.m_Base);
					points[i].setY((log10(vmax) - ch)*yscale + y);
				}
				else
				{
					if (m_pInfo->m_fMaxAmp == -99999)
						ch = (vals[i] - vmin) / (vmax - vmin)*vmax;
					else ch = (vals[i] - m_pInfo->m_fWaveBase);
					points[i].setY(-ch * yscale + y);
				}
				if (points[i].y() < yy0) points[i].setY(yy0);
				if (points[i].y() > yy1) points[i].setY(yy1);
				if (!i) cc = ch;
				else if (!ffl&&cc != ch) ffl = 1;
			}
			if (!ffl) continue;
			if (m_pInfo->m_nDrawType == 0) {
				bool isOddColor = false; //objViewInfo->GetisOddColor()
				bool isDrawBase0 = false; //objViewInfo->GetisDrawBase0()
				bool isDrawDepth = false; //objViewInfo->GetisDrawDepth()
				if (isOddColor) {
					if (odd % 2)
						pdc->setPen(m_pInfo->m_WaveColor);
					else pdc->setPen(QColor(255, 0, 0));
				}
				pdc->drawPolyline(&points[ifist], eend - ifist);
				if (isDrawBase0) {
					pdc->drawLine(QPointF(mrt.x(), y), QPointF(mrt.right(), y));
				}
				if (isDrawDepth)
				{
					pdc->drawText(mrt.x(), y, QString::number(dep1));
				}
				continue;
			}
			switch (m_pInfo->m_nFillType) {
			case 2:           // fill down ：波列，下部填充
				flag = -1;
			case 1:           // fill up ：波列，上部填充
			{
				nFillPoint = 0;
				iStartPoint = 0;
				for (i = ifist; i < eend; i++) {
					if ((flag == 1 && points[i].y() < y) || (flag == -1 && points[i].y() > Base0))
					{
						if (nFillPoint == 0) {
							iStartPoint = i;
							int i0 = 0;
							if (i&&flag == 1 && points[i - 1].y() >= Base0) {
								float x = points[i - 1].x() + (points[i].x() - points[i - 1].x()) / (points[i].y() - points[i - 1].y())*(y - points[i - 1].y());
								cPoints[0].setX(x);
								i0 = 1;
							}
							if (i&&flag == -1 && points[i - 1].y() <= Base0) {
								float x = points[i - 1].x() + (points[i].x() - points[i - 1].x()) / (points[i].y() - points[i - 1].y())*(y - points[i - 1].y());
								cPoints[0].setX(x);
								i0 = 1;
							}
							if (!i0) {
								cPoints[0].setX(points[i].x());
							}
							cPoints[0].setY(Base0);
						}
						nFillPoint++;
					}
					else
					{
						if (nFillPoint)///两端已被封闭
						{
							if (nFillPoint == 1) cPoints[1] = points[iStartPoint];
							else for (m = 1; m < nFillPoint; m++)
							{
								cPoints[m] = points[m + iStartPoint - 1];
							}
							int i0 = 0;
							if (i&&flag == 1 && points[i - 1].y() <= Base0) {
								cPoints[nFillPoint] = points[i - 1];
								nFillPoint++;
								float x = points[i - 1].x() + (points[i].x() - points[i - 1].x()) / (points[i].y() - points[i - 1].y())*(y - points[i - 1].y());
								cPoints[nFillPoint].setX(x);
								i0 = 1;
							}
							if (i&&flag == -1 && points[i - 1].y() >= Base0) {
								cPoints[nFillPoint] = points[i - 1];
								nFillPoint++;
								float x = points[i - 1].x() + (points[i].x() - points[i - 1].x()) / (points[i].y() - points[i - 1].y())*(y - points[i - 1].y());
								cPoints[nFillPoint].setX(x);
								i0 = 1;
							}
							if (!i0) {
								cPoints[nFillPoint].setX(points[nPoint - 1].x());
							}
							cPoints[nFillPoint].setY(Base0);
							cPoints[nFillPoint + 1] = cPoints[0];
							QPolygonF cRgn;
							for (int j = 0; j < nFillPoint + 2; j++) {
								cRgn.push_back(cPoints[j]);
							}
							QPainterPath path;
							path.addPolygon(cRgn);
							//paths.append(path);
							pdc->fillPath(path, cBrush);
							nFillPoint = 0;
						}
					}
				}
				////////////////////
				//数据已结束，但尾没被封住
				if (nFillPoint > 1) {
					for (m = 1; m < nFillPoint; m++)
					{
						cPoints[m] = points[m + iStartPoint];
					}
					cPoints[nFillPoint].setY(Base0);
					cPoints[nFillPoint].setX(cPoints[nFillPoint - 1].x());
					cPoints[nFillPoint + 1] = cPoints[0];
					QPolygonF cRgn;
					for (int j = 0; j < nFillPoint + 2; j++) {
						cRgn.push_back(cPoints[j]);
					}
					QPainterPath path;
					path.addPolygon(cRgn);
					pdc->fillPath(path, cBrush);
				}
				pdc->drawPolyline(&points[ifist], eend - ifist);//nPoint);
				bool isDrawBase0 = false; //objViewInfo->GetisDrawBase0()
				if (isDrawBase0) {
					pdc->drawLine(QPointF(mrt.x(), y), QPointF(mrt.right(), y));
				}
				bool isDrawDepth = false; //objViewInfo->GetisDrawDepth()
				if (isDrawDepth)
				{
					pdc->drawText(mrt.x(), y, QString::number(dep1));
				}
			}
			break;
			}
		}
		break;
		}
		te01 = te00;
	}

	if (Mode == 3) {
		delete[]cPoints;
		delete[]points;
		//m_Value = 0;
		//		pdc->setClipRegion(qRgn);
		return;
	}

	if (m_pInfo->m_nDrawType == 2 ||
		m_pInfo->m_nDrawType == 6 ||
		m_pInfo->m_nDrawType == 10 ||
		m_pInfo->m_nDrawType == 13
		) {
		pdc->setRenderHint(QPainter::SmoothPixmapTransform, true/*m_AutoSmooth*/);
		if (m_pInfo->m_nDrawType == 10) {
			QRectF srt1 = wrt, srt2 = wrt,
				srt12(0.0f, srt.y(), m_pInfo->m_EndRange - m_pInfo->m_FirstRange, srt.height()),
				srt22((m_pInfo->m_vmin - waveinfo.StartTime) / waveinfo.TimeLevel - left1, srt.y(), (m_pInfo->m_vmax - m_pInfo->m_vmin) / waveinfo.TimeLevel, srt.height());
			srt1.setWidth(wrt.width() / 2.0);
			srt2.setLeft(srt1.right());
			pdc->drawImage(srt1, aa, srt12);
			pdc->drawImage(srt2, aa, srt22);
		}
		else {
			int w = aa.width();
			int h = aa.height();
			pdc->drawImage(wrt, aa, srt);
		}
	}

	delete[]cPoints;
	delete[]points;

}

double FormWave::GetData(int i, int j, char *buffer)
{
	float yy = -9999;
	if (m_vProperty.size() > i) {
		int pos = (int)(i*waveinfo.TimeSamples + j);
		yy = GetData(waveinfo.RepCode, (char *)&((char *)m_vProperty.m_vProperty)[pos*waveinfo.CodeLen], waveinfo.CodeLen);
	}
	return yy;
}
double FormWave::GetData(int repCode, char *buffer, int repLen)
{
	double yy = -99999;
	if (!buffer)
	{
		return 0;
	}
	switch (repCode)
	{
	case REPR_INT:  //0
		yy = (double)(*((int*)buffer));
		break;
	case REPR_SHORT: //1
		yy = (double)(*((short *)buffer));
		break;
	case REPR_LONG://2
		yy = (double)(*((long *)buffer));
		break;
	case REPR_FLOAT://3
		yy = (double)(*((float *)buffer));
		break;
	case REPR_DOUBLE://4
		yy = (double)(*((double *)buffer));
		break;
	case REPR_CHAR://5
		yy = (double)(*((char *)buffer));
		break;
	case REPR_UCHAR://6
		yy = (double)(*((unsigned char *)buffer));
		break;
	case REPR_USHORT://7
		yy = (double)(*((unsigned short *)buffer));
		break;
	case REPR_UINT://8
		yy = (double)(*((unsigned int *)buffer));
		break;
	case REPR_ULONG://9
		yy = (double)(*((unsigned long *)buffer));
		break;
	case REPR_STRING://10
		if (repLen >= 200)
			repLen = 199;
		if (repLen > 0)
		{
			memmove(m_strValue, buffer, repLen);
			m_strValue[repLen] = 0;
		}
		else
		{
			m_strValue[0] = 0;
			yy = -99999;
		}
		break;
	}
	return yy;
}
void FormWave::SetData(int repCode, char *buffer, double yy)
{
	if (!buffer)
	{
		return;
	}
	switch (repCode)
	{
	case REPR_INT:  //0
		(*((int*)buffer)) = (int)yy;
		break;
	case REPR_SHORT: //1
		(*((short *)buffer)) = (short)yy;
		break;
	case REPR_LONG://2
		(*((long *)buffer)) = (long)yy;
		break;
	case REPR_FLOAT://3
		(*((float *)buffer)) = yy;
		break;
	case REPR_DOUBLE://4
		(*((double *)buffer)) = (double)yy;
		break;
	case REPR_CHAR://5
		(*((char *)buffer)) = (char)yy;
		break;
	case REPR_UCHAR://6
		(*((unsigned char *)buffer)) = (unsigned char)yy;
		break;
	case REPR_USHORT://7
		(*((unsigned short *)buffer)) = (unsigned short)yy;
		break;
	case REPR_UINT://8
		(*((unsigned int *)buffer)) = (unsigned int)yy;
		break;
	case REPR_ULONG://9
		(*((unsigned long *)buffer)) = (unsigned long)yy;
		break;
	case REPR_STRING://10
		//			*yy=-99999;
		break;
	}
	return;
}