882 lines
23 KiB
C++
882 lines
23 KiB
C++
#include "formimage.h"
|
|
#include "ui_formimage.h"
|
|
#include <QPainter>
|
|
#include "CallManage.h"
|
|
#include "forminfo.h"
|
|
#include "formtrack.h"
|
|
#include "geometryutils.h"
|
|
#include "qtColorSchemeComboBox.h"
|
|
|
|
extern double g_dPixelPerCm;//每厘米像素数
|
|
|
|
FormImage::FormImage(QWidget *parent, QString strSlfName, QString strWellName, QString strTrackName, QString strLineName) :
|
|
QWidget(parent),
|
|
ui(new Ui::FormImage)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
m_strSlfName = strSlfName;
|
|
m_strWellName = strWellName;
|
|
m_strTrackName = strTrackName;
|
|
m_strLineName = strLineName;
|
|
|
|
//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)));
|
|
//黑白图
|
|
connect(CallManage::getInstance(), SIGNAL(sig_changeBlack(QString, bool)), this, SLOT(s_changeBlack(QString, bool)));
|
|
}
|
|
|
|
FormImage::~FormImage()
|
|
{
|
|
delete ui;
|
|
}
|
|
|
|
void FormImage::initGeometry(QString strUuid, int nscale, double fW, int nH)
|
|
{
|
|
if (strUuid.length() > 0)
|
|
this->m_strUuid = strUuid;
|
|
m_iScale = nscale;
|
|
|
|
int ntmpw = fW * g_dPixelPerCm;
|
|
this->setGeometry(0, 0, ntmpw - 2, (int)nH);
|
|
|
|
//修改滚动条，针对新建的
|
|
emit CallManage::getInstance()->sig_changeScrollBar(m_strUuid);
|
|
}
|
|
|
|
void FormImage::setDepthY(float fy1, float fy2)
|
|
{
|
|
this->m_iY1 = fy1;
|
|
this->m_iY2 = fy2;
|
|
|
|
m_PlotSdep = qAbs(this->m_iY2);
|
|
m_fTopY = m_PlotSdep;
|
|
}
|
|
|
|
void FormImage::updateDepthY(float fy1, float fy2)
|
|
{
|
|
this->m_iY1 = fy1;
|
|
this->m_iY2 = fy2;
|
|
m_fTopY = qAbs(this->m_iY2);
|
|
update();
|
|
}
|
|
|
|
bool FormImage::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 (qIsNaN(val) || !qIsFinite(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 FormImage::setSchemIndex(int nidx)
|
|
{
|
|
schemIndex = nidx;
|
|
m_rgbList = QtColorTableData::getInstance()->GetRgb_UseTag(1, schemIndex, 256);
|
|
}
|
|
|
|
void FormImage::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)
|
|
{
|
|
if (m_pInfo == NULL)
|
|
{
|
|
m_pInfo = m_formTrack->getFormInfoByParameters(m_strUuid, m_strWellName, m_strTrackName, m_strLineName);
|
|
}
|
|
if (m_pInfo)
|
|
{
|
|
if (m_pInfo->m_bShow3D)
|
|
this->DrawImage3D(&painter, rect);
|
|
else
|
|
this->DrawImage(&painter, rect);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void FormImage::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 FormImage::s_changeBlack(QString strUuid, bool bBlack)
|
|
{
|
|
if (m_strUuid != strUuid || m_bBlack == bBlack)
|
|
return;
|
|
m_bBlack = bBlack;
|
|
m_rgbList = QtColorTableData::getInstance()->GetRgb_UseTag(1, m_bBlack ? 2 : schemIndex, 256);
|
|
|
|
update();
|
|
}
|
|
|
|
//自定义滚动条
|
|
void FormImage::vertScrollBarChanged(QString strUuid, double value, double low, double upper)
|
|
{
|
|
if (m_strUuid == strUuid)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
m_fTopY = value;
|
|
update();
|
|
}
|
|
|
|
//打印
|
|
void FormImage::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 FormImage::vertScrollBarChanged_setGeometry(QString strUuid, double value, double low, double upper, int ndepth)
|
|
{
|
|
if (m_strUuid == strUuid)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
m_fTopY = ndepth;
|
|
update();
|
|
}
|
|
|
|
void FormImage::wheelEvent(QWheelEvent *event) // 滚轮事件
|
|
{
|
|
emit CallManage::getInstance()->sig_mouseWheel(event);
|
|
}
|
|
|
|
void FormImage::DrawImage(QPainter* pdc, QRectF mrt1)
|
|
{
|
|
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_pImage)
|
|
{
|
|
m_pInfo->m_pImage = this;
|
|
}
|
|
|
|
CLogIO *logio = new CLogIO();
|
|
logio->Open(m_strSlfName.toStdString().c_str(), CSlfIO::modeRead);
|
|
//
|
|
int iIndex = logio->OpenWave(m_strLineName.toStdString().c_str());
|
|
if (iIndex < 0) {
|
|
delete logio;
|
|
return;
|
|
}
|
|
|
|
Slf_WAVE _wave;
|
|
logio->GetWaveInfo(iIndex, &_wave);
|
|
|
|
m_SDep = _wave.StartDepth;
|
|
m_EDep = _wave.EndDepth;
|
|
m_Rlev = _wave.DepLevel;
|
|
|
|
float sdep, edep, flDepthScale = 18.897617f, temp;
|
|
|
|
// 计算显示深度
|
|
float sdepc = m_fTopY, edepc = m_fTopY + m_fAddY;
|
|
|
|
sdep = sdepc;
|
|
edep = edepc;
|
|
flDepthScale = mrt1.height() / (edepc - sdepc);
|
|
|
|
if (edep > m_EDep) edep = m_EDep;
|
|
if (sdep < m_SDep) sdep = m_SDep;
|
|
if (sdep > m_EDep) return;
|
|
if (edep < m_SDep) return;
|
|
if (edep > m_EDep) edep = m_EDep;
|
|
if (edep < sdep) edep = sdep;
|
|
if (edep > m_EDep) edep = m_EDep;
|
|
if (sdep > m_EDep) sdep = m_EDep;
|
|
|
|
int incount = (edep - sdep) / m_Rlev;
|
|
if (incount == 0)
|
|
return;
|
|
|
|
QRectF rt = mrt1;
|
|
float flDep;
|
|
int i, ii, j, nPoint = 0, m;
|
|
QRectF wrt;
|
|
float dep, ch;
|
|
double ratio;
|
|
CString cs;
|
|
QString qs;
|
|
|
|
int ytmp = -1;
|
|
float y = 9999999.0;
|
|
|
|
//计算数据点数
|
|
temp = _wave.TimeSamples;
|
|
if (temp < 0) temp -= 0.5;
|
|
nPoint = abs(temp);
|
|
|
|
ratio = 1.0;// int((float)incount * 1000 / rt.height()) / 1000.0; //比例
|
|
|
|
char *value = new char[incount*nPoint*_wave.CodeLen];
|
|
|
|
//按块读数据
|
|
if (iIndex >= 0)
|
|
{
|
|
logio->ReadWave(iIndex, sdep, incount, (void *)value);
|
|
}
|
|
else memset(value, 0, incount*nPoint*_wave.CodeLen);
|
|
|
|
float depcount = (float)incount / (edep - sdep);
|
|
float depcount1 = 0;
|
|
|
|
QSize qsize;
|
|
|
|
int rh = mrt1.height();
|
|
int rw = this->size().width();
|
|
long nLnBytes = (nPoint * 3 + 3) / 4 * 4;
|
|
unsigned char *pData = new unsigned char[nLnBytes*(int)(rh + 0.5)];
|
|
memset(pData, 255, nLnBytes*(int)(rh + 0.5));
|
|
|
|
int datatype = 0;
|
|
int m_LeftVal = 0;
|
|
int m_RightVal = 128;
|
|
float m_flBackVal = -9999;
|
|
if (m_pInfo)
|
|
{
|
|
datatype = m_pInfo->m_nCoord;
|
|
m_LeftVal = m_pInfo->m_ImgMinVal;
|
|
m_RightVal = m_pInfo->m_ImgMaxVal;
|
|
m_flBackVal = -9999;
|
|
schemIndex = m_pInfo->m_nSchemeIndex;
|
|
}
|
|
if (m_rgbList.size() <= 0)
|
|
{
|
|
m_rgbList = QtColorTableData::getInstance()->GetRgb_UseTag(1, schemIndex, 256);
|
|
}
|
|
QRgb rgbbg = QtColorTableData::getInstance()->getRgb_Bg(schemIndex);
|
|
|
|
for (double dep1 = sdep; dep1 < edep; dep1 += ratio * m_Rlev)
|
|
{
|
|
y = (dep1 - sdepc)*flDepthScale;
|
|
//y = ConvertY( eCoord_GEO,dep1,eCoord_GEONormal );
|
|
if (y < 0) continue;
|
|
if (ytmp == int(y)) continue;
|
|
else ytmp = y;
|
|
wrt.setTop(y);
|
|
depcount1 = (dep1 - sdep)*depcount;
|
|
|
|
for (i = 0; i < nPoint; i++)
|
|
{
|
|
ch = GetData(_wave.RepCode, (char *)&value[(int(depcount1)*nPoint + i)*_wave.CodeLen]);
|
|
if (wrt.top() >= rh)
|
|
break;
|
|
m = (int)wrt.top();
|
|
if (m_flBackVal != ch)
|
|
{
|
|
if (datatype == 0) //线性刻度
|
|
{
|
|
ii = 256 * (ch - m_LeftVal) / (m_RightVal - m_LeftVal);
|
|
}
|
|
else
|
|
{
|
|
if (m_LeftVal < 1.0)
|
|
ii = 256 * (log10(ch)) / log10(m_RightVal);
|
|
else
|
|
ii = 256 * (log10(ch) - log10(m_LeftVal)) / (log10(m_RightVal) - log10(m_LeftVal));
|
|
}
|
|
if (ii > 254) ii = 254;
|
|
if (ii < 0) ii = 0;
|
|
|
|
pData[m*nLnBytes + 3 * i] = qRed(m_rgbList.at(ii));
|
|
pData[m*nLnBytes + 3 * i + 1] = qGreen(m_rgbList.at(ii));
|
|
pData[m*nLnBytes + 3 * i + 2] = qBlue(m_rgbList.at(ii));
|
|
}
|
|
else
|
|
{
|
|
pData[m*nLnBytes + 3 * i] = qRed(rgbbg);
|
|
pData[m*nLnBytes + 3 * i + 1] = qGreen(rgbbg);
|
|
pData[m*nLnBytes + 3 * i + 2] = qBlue(rgbbg);
|
|
}
|
|
}
|
|
} //read data end
|
|
|
|
int nheight = rh;
|
|
if (wrt.top() < rh - 1)
|
|
nheight = (int)(wrt.top() + 0.5); //若数据行数小于rt.Height()
|
|
|
|
//防止图片扭曲：同时限定每一行的数据大小可以保证
|
|
QImage membmp(pData, nPoint, nheight, 3 * nPoint, QImage::Format_RGB888);
|
|
qsize.setWidth(rw - 2);
|
|
qsize.setHeight(nheight);
|
|
// 图像缩放
|
|
QImage result = membmp.scaled(qsize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
|
|
pdc->drawImage(rt.left() + 1, rt.top(), result);
|
|
|
|
delete[]pData; pData = NULL;
|
|
delete[]value;
|
|
|
|
}
|
|
|
|
void FormImage::DrawImage3D(QPainter* pdc, QRectF mrt)
|
|
{
|
|
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_pImage)
|
|
{
|
|
m_pInfo->m_pImage = this;
|
|
}
|
|
|
|
CLogIO *logio = new CLogIO();
|
|
logio->Open(m_strSlfName.toStdString().c_str(), CSlfIO::modeRead);
|
|
//
|
|
int iIndex = logio->OpenWave(m_strLineName.toStdString().c_str());
|
|
if (iIndex < 0) {
|
|
delete logio;
|
|
return;
|
|
}
|
|
|
|
Slf_WAVE _wave;
|
|
logio->GetWaveInfo(iIndex, &_wave);
|
|
|
|
m_SDep = _wave.StartDepth;
|
|
m_EDep = _wave.EndDepth;
|
|
m_Rlev = _wave.DepLevel;
|
|
|
|
float sdep, edep, flDepthScale = 18.897617f, temp;
|
|
|
|
// 计算显示深度
|
|
float sdepc = m_fTopY, edepc = m_fTopY + m_fAddY;
|
|
|
|
sdep = sdepc;
|
|
edep = edepc;
|
|
flDepthScale = mrt.height() / (edepc - sdepc);
|
|
|
|
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;
|
|
|
|
int iDepCount = (edep - sdep) / m_Rlev;
|
|
if (iDepCount == 0)
|
|
return;
|
|
|
|
// 计算开始数据点及数据点数
|
|
int nPoint, m;
|
|
float flVal;
|
|
//计算数据点数
|
|
temp = _wave.TimeSamples;
|
|
if (temp < 0) temp -= 0.5;
|
|
nPoint = abs(temp);
|
|
// 绘制
|
|
QRectF wrt;
|
|
int dep = 0;
|
|
float detp = sdepc;
|
|
|
|
int rh = mrt.height();
|
|
int rw = this->size().width();
|
|
double ratio = 1;// int((float)iDepCount * 1000 / rt.height()) / 1000.0;
|
|
if (ratio > 1) ratio = 1;
|
|
char *value = new char[iDepCount*nPoint*_wave.CodeLen];
|
|
long nLnBytes = (nPoint * 3 + 3) / 4 * 4;
|
|
unsigned char *pData = new unsigned char[nLnBytes*(int)(rh + 0.5)];
|
|
memset(pData, 255, nLnBytes*(int)(rh + 0.5));
|
|
|
|
int m_iStartAngle = 20;
|
|
int m_iStartPos = 0;
|
|
int datatype = 0;
|
|
int m_LeftVal = 0;
|
|
int m_RightVal = 128;
|
|
if (m_pInfo)
|
|
{
|
|
m_iStartAngle = m_pInfo->m_nOverlook;
|
|
m_iStartPos = m_pInfo->m_nAzimuth;
|
|
datatype = m_pInfo->m_nCoord;
|
|
m_LeftVal = m_pInfo->m_ImgMinVal;
|
|
m_RightVal = m_pInfo->m_ImgMaxVal;
|
|
schemIndex = m_pInfo->m_nSchemeIndex;
|
|
}
|
|
//QList<QRgb> rgbList = QtColorTableData::getInstance()->GetRgb_UseTag(1, m_nSchemeIndex, 256);
|
|
if (m_rgbList.size() <= 0)
|
|
{
|
|
m_rgbList = QtColorTableData::getInstance()->GetRgb_UseTag(1, schemIndex, 256);
|
|
}
|
|
float pi = 3.1415926;
|
|
float angle = pi / ((float)nPoint / 2.0);
|
|
int drawdep;
|
|
float fangle = m_iStartAngle / 90.0;
|
|
int r = rw / 4 * fangle;
|
|
int dis = nPoint / 4;
|
|
float flOffset = 0;
|
|
int drawFlag = -1;
|
|
int drawHead = 0;
|
|
|
|
|
|
bool flag1 = ((sdep > detp) || (sdep > detp));
|
|
bool flag2 = ((m_SDep < sdep) || (m_SDep > sdep));
|
|
int ioffset = m_iStartPos * nPoint / 360.0 + 0.5;
|
|
|
|
int ytmp = -1;
|
|
for (double dep1 = sdep; dep1 < edep; dep1 += ratio * m_Rlev)
|
|
{
|
|
float y = (dep1 - sdepc)*flDepthScale;
|
|
if (ytmp == int(y)) continue;
|
|
else ytmp = y;
|
|
wrt.setTop(y);
|
|
|
|
drawFlag++;
|
|
if (!drawFlag)
|
|
drawHead = wrt.top();
|
|
if (!flag1)
|
|
drawHead = r;
|
|
if (!flag2)
|
|
wrt.setTop(wrt.top() - r);
|
|
|
|
if (wrt.top() == r)
|
|
flOffset = dep1 - sdep;
|
|
|
|
//画带头的圆柱
|
|
if (!flag1 || !flag2)
|
|
{
|
|
if (iIndex >= 0)
|
|
{
|
|
logio->ReadWave(iIndex, dep1 + flOffset, 1, (void *)value);
|
|
}
|
|
else memset(value, 0, m_nSamples*_wave.DepLevel);
|
|
|
|
for (int i = 0; i <= nPoint / 2; i++)
|
|
{
|
|
drawdep = wrt.top() + r + r * sin(angle*i);
|
|
flVal = GetData(_wave.RepCode, (char *)&value[(i + ioffset) % nPoint*_wave.CodeLen]);
|
|
|
|
if (drawdep > rh - 1)
|
|
continue;
|
|
else
|
|
{
|
|
// if (m_flBackVal == flVal)
|
|
// {
|
|
// pData[drawdep*nLnBytes + 3 * (i + dis)] = GetBValue(m_GraInfo.GetBackgroundColour());
|
|
// pData[drawdep*nLnBytes + 3 * (i + dis) + 1] = GetGValue(m_GraInfo.GetBackgroundColour());
|
|
// pData[drawdep*nLnBytes + 3 * (i + dis) + 2] = GetRValue(m_GraInfo.GetBackgroundColour());
|
|
// }
|
|
// else
|
|
{
|
|
int ii;
|
|
if (datatype == 0) //线性刻度
|
|
{
|
|
ii = 256 * (flVal - m_LeftVal) / (m_RightVal - m_LeftVal);
|
|
}
|
|
else
|
|
{
|
|
if (m_LeftVal < 1.0)
|
|
ii = 256 * (log10(flVal)) / log10(m_RightVal);
|
|
else
|
|
ii = 256 * (log10(flVal) - log10(m_LeftVal)) / (log10(m_RightVal) - log10(m_LeftVal));
|
|
}
|
|
if (ii > 254) ii = 254;
|
|
if (ii < 0) ii = 0;
|
|
|
|
pData[drawdep*nLnBytes + 3 * (i + dis)] = qRed(m_rgbList.at(ii));// GetBValue(pColorArr[ii]);
|
|
pData[drawdep*nLnBytes + 3 * (i + dis) + 1] = qGreen(m_rgbList.at(ii));// GetGValue(pColorArr[ii]);
|
|
pData[drawdep*nLnBytes + 3 * (i + dis) + 2] = qBlue(m_rgbList.at(ii));// GetRValue(pColorArr[ii]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/* else //不带头
|
|
{
|
|
if (iIndex >= 0)
|
|
{
|
|
mrw.ReadWave(iIndex, dep1 - flOffset, 1, (void *)value);
|
|
}
|
|
else memset(value, 0, m_nSamples*WaveInfo.DepLevel);
|
|
|
|
for (i = 0; i <= nPoint / 2; i++)
|
|
{
|
|
drawdep = wrt.top() - r + r * sin(angle*i);
|
|
|
|
|
|
if (drawdep < 0)
|
|
continue;
|
|
else
|
|
{
|
|
flVal = GetData(WaveInfo.RepCode, (char *)&value[(i + ioffset) % nPoint*WaveInfo.CodeLen]);
|
|
if (m_flBackVal == flVal)
|
|
{
|
|
pData[drawdep*nLnBytes + 3 * (i + dis)] = GetBValue(m_GraInfo.GetBackgroundColour());
|
|
pData[drawdep*nLnBytes + 3 * (i + dis) + 1] = GetGValue(m_GraInfo.GetBackgroundColour());
|
|
pData[drawdep*nLnBytes + 3 * (i + dis) + 2] = GetRValue(m_GraInfo.GetBackgroundColour());
|
|
}
|
|
else
|
|
{
|
|
int ii;
|
|
if (datatype == LINEAR) //线性刻度
|
|
{
|
|
ii = 256 * (flVal - m_LeftVal) / (m_RightVal - m_LeftVal);
|
|
}
|
|
else
|
|
{
|
|
if (m_LeftVal < 1.0)
|
|
ii = 256 * (log10(flVal)) / log10(m_RightVal);
|
|
else
|
|
ii = 256 * (log10(flVal) - log10(m_LeftVal)) / (log10(m_RightVal) - log10(m_LeftVal));
|
|
}
|
|
|
|
if (ii > 255) ii = 255;
|
|
if (ii < 0) ii = 0;
|
|
|
|
pData[drawdep*nLnBytes + 3 * (i + dis)] = GetBValue(pColorArr[ii]);
|
|
pData[drawdep*nLnBytes + 3 * (i + dis) + 1] = GetGValue(pColorArr[ii]);
|
|
pData[drawdep*nLnBytes + 3 * (i + dis) + 2] = GetRValue(pColorArr[ii]);
|
|
}
|
|
}
|
|
}
|
|
}*/
|
|
}
|
|
|
|
int nheight = rh;
|
|
if (wrt.top() < rh - 1)
|
|
nheight = (int)(wrt.top() + 0.5);
|
|
|
|
long nLnBytes1 = (nPoint * 3 + 3) / 4 * 4;
|
|
BYTE *pData1 = new BYTE[nLnBytes1*nheight];
|
|
memcpy(pData1, pData, nLnBytes1*nheight);
|
|
|
|
QImage membmp(pData1, nPoint, nheight, 3 * nPoint, QImage::Format_RGB888);
|
|
QSize qsize;
|
|
qsize.setWidth(rw - 2);
|
|
qsize.setHeight(nheight);
|
|
// 图像缩放
|
|
QImage result = membmp.scaled(qsize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
|
|
pdc->drawImage(mrt.left() + 1, mrt.top(), result);
|
|
delete[]pData1;
|
|
delete[]pData;
|
|
delete[]value;
|
|
delete logio;
|
|
}
|
|
|
|
double FormImage::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 FormImage::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 FormImage::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;
|
|
}
|