void halg::AnimPloter::paintEvent( QPaintEvent * event )
{
if ( m_animPlots.empty( ) ) return;
bool hasNewFrames = false;
for (auto plotAnim : m_animPlots)
{
Plot * plot;
if ( m_frameCount < plotAnim.size( ) )
{
plot = plotAnim[ m_frameCount ];
hasNewFrames = true;
}
else
{
plot = plotAnim[ plotAnim.size( ) - 1 ];
}
DrawPlot( plot );
}
if ( hasNewFrames )
{
++m_frameCount;
}
else
{
m_timer.stop( );
}
Ploter::paintEvent( event );
}
void FreqWindow::OnAxisChoice(wxCommandEvent & event)
{
mLogAxis = (mAxisChoice->GetSelection())?true:false;
DrawPlot();
mFreqPlot->Refresh(true);
}
void halg::Ploter::paintEvent( QPaintEvent * )
{
for(auto plot: m_plots)
{
DrawPlot( plot );
}
}
void Widget::on_keyErr_clicked()
{
DWORD keyBlobLen, blockLen = 0;
BYTE *keyBlob, *srcData, *newData, *blockData1, *blockData2;
HCRYPTPROV hCryptProv;
HCRYPTKEY hKey, dhKey;
QVector<int> values;
QFile myFile(fName);
plot->clear();
if (myFile.exists())
myFile.open(QIODevice::ReadOnly);
else
{
QMessageBox::critical(0, "Ошибка", "Файл не выбран", QMessageBox::Ok);
return;
}
CryptAcquireContext(&hCryptProv, NULL, MS_DEF_RSA_SCHANNEL_PROV, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT);
CryptGenKey(hCryptProv, CALG_AES_256, 0, &hKey);
CryptEncrypt(hKey, 0, true, 0, NULL, &blockLen, myFile.size());
srcData = new BYTE[block * blockLen];
newData = new BYTE[block * blockLen];
blockData1 = new BYTE[blockLen];
blockData2 = new BYTE[blockLen];
myFile.read((char*)srcData, block * blockLen);
myFile.close();
memcpy((char*)newData, (char*)srcData, block * blockLen);
newData[0] = -newData[0];
CryptDuplicateKey(hKey, NULL, 0, &dhKey);
CryptExportKey(dhKey, 0, SIMPLEBLOB, 0, NULL, &keyBlobLen);
keyBlob = new BYTE[keyBlobLen];
CryptExportKey(dhKey, 0, SIMPLEBLOB, 0, keyBlob, &keyBlobLen);
keyBlob[0] = -keyBlob[0];
CryptImportKey(hCryptProv, keyBlob, keyBlobLen, 0, 0, &dhKey);
for (uint i = 0; i < (block * blockLen); i++)
{
CryptEncrypt(hKey, 0, i < 2, 0, srcData + i, &blockLen, block * blockLen);
CryptEncrypt(dhKey, 0, i < 2, 0, newData + i, &blockLen, block * blockLen);
}
for(uint i = 0; i < (block * blockLen); i += blockLen)
{
int k = 0;
memcpy(blockData1, srcData + i, blockLen);
memcpy(blockData2, newData + i, blockLen);
for (uint j = i; j < (i + blockLen); j++)
k += trueBitsCount(srcData[j] ^ newData[j]);
values.push_back(k);
}
delete[] newData;
delete[] srcData;
delete[] blockData1;
delete[] blockData2;
delete[] keyBlob;
CryptReleaseContext(hCryptProv, 0);
CryptDestroyKey(hKey);
CryptDestroyKey(dhKey);
DrawPlot(plot, values);
plot->show();
}
void FreqWindow::OnSize(wxSizeEvent & WXUNUSED(event))
{
Layout();
DrawPlot();
Refresh(true);
}
//*******************************************************************************************************/
//* FileName: clPlot.cpp
//*
//* Contents: Implementation of clPlot, axis, legend, serie and timeaxis
//*
//* NOTE 1: Only a minimum of parameter validation is implemented to save time since this plot is
//* time critical.
//*
//* NOTE 2: All functionality is not fully implemented.
//*
//* Author: Jan Vidar Berger
//*******************************************************************************************************/
//* 12.feb.98 Jan Vidar Berger Implemented flicker free drawing. Thanks to John Kim for providing
//* the CGridMemDC and to Keith Rule, the author of CMemDC.
//*******************************************************************************************************/
#include "stdafx.h"
#include "clPlot.h"
#include "GridMemDC.h"
#include "malloc.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
long clPlot::m_lMaxDataPrSerie; // max allowed data pr. serie.
long clPlot::m_lMaxDataTotal; // max allowed data total.
//*******************************************************************************************************/
//* time axis threshold. contains grid and label intervals to be used within specified
//* seconds pr. pixels thresholds. The array is terminated by a 'bIAmInUse'=FALSE.
//*******************************************************************************************************/
struct{
BOOL bIAmInUse; // indicate valid entry, last=FALSE
long lgridinterval; // grid line interval in seconds
long llabelinterval; // time label interval in seconds
long lmodethreshold; // mode threshold in seconds pr. pixel
}gridsetting[]={
TRUE, 1, 4, 0, // 0: pr. second
FALSE, 1, 1,0, // last entry in table
};
//*******************************************************************************************************/
//* Function: serie::serie
//*******************************************************************************************************/
serie::serie()
{
m_bIAmInUse = FALSE;
m_color = RGB(0,0,0);
m_iLineStyle = PS_SOLID;
m_bRightAxisAlign = FALSE;
m_lNoValues = 0;
m_lbegin = 0;
m_lend = 0;
m_pvalues = NULL;
}
//*******************************************************************************************************/
//* Function: serie::~serie
//*******************************************************************************************************/
serie::~serie()
{
if(m_pvalues !=NULL)
free(m_pvalues);
}
//*******************************************************************************************************/
//* Function: serie::AddPoint
//*
//* Description: AddPoint add new data to the end of a data serie. It will simply append the data,
//* update the list index and get out.
//*
//* This function will also call realloc or malloc to re-size or create the plot array as
//* needed.
//*
//* The nice thing about circular lists is that they are multi thread enabled as is. You
//* must however implement a syncronization mechanism if more than one thread is supposed
//* to enter data into the plot.
//*
//* Parameters: valuetime Time (x value).
//* y y value
//*
//* Return Value: -none-
//*
//* Author: Jan Vidar Berger
//*******************************************************************************************************/
void serie::AddPoint(CTime &valuetime , double &y)
{
if(m_lNoValues > 0)
m_pvalues = (value*)realloc(m_pvalues, (m_lNoValues+1)*sizeof(value));
else
m_pvalues = (value*)malloc((m_lNoValues+1)*sizeof(value));
m_pvalues[m_lend].ValueTime = valuetime;
m_pvalues[m_lend].dValue = y;
m_lNoValues++;
m_lend++;
if(m_lend >= clPlot::m_lMaxDataPrSerie)
m_lend=0;
if(m_lbegin == m_lend){
m_lbegin++;
if(m_lbegin >= clPlot::m_lMaxDataPrSerie)
m_lbegin=0;
}
}
//*******************************************************************************************************/
//* Function: serie::Reset
//*
//* Description: Reset the serie. Remove data and reset indexes and pointers.
//*
//* Parameters: -none-
//*
//* Return Value: -none-
//*
//* Author: Jan Vidar Berger
//*******************************************************************************************************/
void serie::Reset()
{
m_lNoValues=0;
if(m_pvalues !=NULL)
free(m_pvalues);
m_pvalues = NULL;
m_lbegin = 0;
m_lend = 0;
}
//*******************************************************************************************************/
//*******************************************************************************************************/
clPlot::clPlot()
{
m_ctlBkColor = RGB(255,255,255);
m_plotBkColor = RGB(255,255,255);
m_legendBkColor = RGB(255,255,255);
m_gridColor = RGB(127,127,127);
m_bctlBorder = TRUE;
m_bplotBorder = TRUE;
m_blegendBorder = TRUE;
m_bPrimaryLegend = FALSE;
m_bSecondaryLegend = FALSE;
m_bAxisLY = TRUE;
m_bAxisRY = TRUE;
m_bAxisBX = TRUE;
m_bAutoScrollX = FALSE;
m_bSimMode = FALSE;
m_lMaxDataPrSerie = 10000;
m_lMaxDataTotal = 100000;
m_dNoData = 0.0;
m_dzoom = 1.0;
lArraySize = 1000; // only points with differebt x,y will be put into the array
pLineArray = new CPoint[lArraySize];
SetBXRange(CTime::GetCurrentTime()-CTimeSpan(60),CTime::GetCurrentTime());
m_logFont.lfHeight = -13;
m_logFont.lfWidth = 0;
m_logFont.lfEscapement = 0;
m_logFont.lfOrientation = 0;
m_logFont.lfWeight = 400;
m_logFont.lfItalic = FALSE;
m_logFont.lfUnderline = FALSE;
m_logFont.lfStrikeOut = FALSE;
m_logFont.lfCharSet = ANSI_CHARSET;
m_logFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
m_logFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
m_logFont.lfQuality = PROOF_QUALITY;
m_logFont.lfPitchAndFamily = DEFAULT_PITCH;
wcscpy(m_logFont.lfFaceName,_T("Ariel"));
m_zoomFont.lfHeight = -13;
m_zoomFont.lfWidth = 0;
m_zoomFont.lfEscapement = 0;
m_zoomFont.lfOrientation = 0;
m_zoomFont.lfWeight = 400;
m_zoomFont.lfItalic = FALSE;
m_zoomFont.lfUnderline = FALSE;
m_zoomFont.lfStrikeOut = FALSE;
m_zoomFont.lfCharSet = ANSI_CHARSET;
m_zoomFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
m_zoomFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
m_zoomFont.lfQuality = PROOF_QUALITY;
m_zoomFont.lfPitchAndFamily = DEFAULT_PITCH;
wcscpy(m_zoomFont.lfFaceName,_T("Ariel"));
m_font.CreateFontIndirect(&m_zoomFont);
}
//*******************************************************************************************************/
//*******************************************************************************************************/
clPlot::~clPlot()
{
delete [] pLineArray;
}
//*******************************************************************************************************/
//*******************************************************************************************************/
BEGIN_MESSAGE_MAP(clPlot, CWnd)
//{{AFX_MSG_MAP(clPlot)
ON_WM_PAINT()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
//*******************************************************************************************************/
//*******************************************************************************************************/
BOOL clPlot::Create(DWORD dwstyle, CRect &rect, CWnd *pParent, UINT id)
{
DWORD style = dwstyle & (~WS_BORDER);
if(dwstyle & WS_BORDER)
m_bctlBorder=TRUE;
else
m_bctlBorder=FALSE;
if(!CWnd::Create(NULL, _T(""), style, rect, pParent, id, NULL))
return FALSE;
m_ctlRect = rect;
pParent->ClientToScreen(m_ctlRect);
ScreenToClient(m_ctlRect);
ComputeRects(TRUE);
return TRUE;
}
//*******************************************************************************************************/
//* Function : clPlot::ComputeRects
//*
//* Description : Compute rects used for internal possitioning of different objects. This function is
//* called when the plot is created or sized.
//*
//* Return type : void
//*
//* Parameter(s) : bInitialization indicate wherever parameters that can be changed abu the user
//* also should be computed.
//*
//* Author : Jan Vidar Berger
//*******************************************************************************************************/
void clPlot::ComputeRects(BOOL bInitialization)
{
// adjust the client rect for borders
//GetClientRect(m_ctlRect);
CClientDC dc(this);
int w = 0;
int n=0;
CSize z=dc.GetTextExtent(CString("A"));
// m_TextHeight = z.cy;
m_dzoom = ((double)m_ctlRect.Height()/(double)z.cy) / 25.0;
m_zoomFont.lfWidth = (int)(m_logFont.lfWidth * m_dzoom);
m_zoomFont.lfHeight = (int)(m_logFont.lfHeight * m_dzoom);
m_font.Detach();
m_font.CreateFontIndirect(&m_zoomFont);
CFont *oFont = dc.SelectObject(&m_font);
// SetFont(&m_font);
z=dc.GetTextExtent(CString("A"));
m_TextHeight = z.cy;
if(m_bctlBorder){
m_clientRect.left = m_ctlRect.left+2;
m_clientRect.right = m_ctlRect.right-2;
m_clientRect.top = m_ctlRect.top+2;
m_clientRect.bottom = m_ctlRect.bottom-2;
}else{
m_clientRect = m_ctlRect;
}
if(bInitialization)
{
m_iMtop = m_iMbottom = m_clientRect.Height()/10;
m_iMleft = m_iMright = m_clientRect.Width()/10;
}
// compute plot rect.
m_plotRect.left = m_clientRect.left + m_iMleft;
m_plotRect.right = m_clientRect.right - m_iMright;
m_plotRect.top = m_clientRect.top + m_iMtop;
m_plotRect.bottom = m_clientRect.bottom - m_iMbottom;
// compute default legend possition
if(bInitialization)
{
m_legendRect.left = m_plotRect.left + (m_iMleft/5);
m_legendRect.right = m_plotRect.left + (m_plotRect.Width()/5);
m_legendRect.top = m_plotRect.top - (m_iMtop/2);
m_legendRect.bottom = m_plotRect.top + (m_iMtop);
int w = 0;
int n=0;
for(int x = 0; x< MAXLEGENDS;x++){
if(m_primarylegends[x].m_bIAmInUse){
n++;
z=dc.GetTextExtent(CString(m_primarylegends[x].m_szTitle));
if(z.cx > w )
w=z.cx;
// m_TextHeight = z.cy;
}
}
m_legendRect.right = m_legendRect.left + 40 + w;
m_legendRect.bottom = m_legendRect.top + 10 + (m_TextHeight*n);
}
// compute left axis area
m_axisLYRect.left = m_clientRect.left + (m_iMleft/5);
m_axisLYRect.right = m_plotRect.left;
m_axisLYRect.top = m_plotRect.top;
m_axisLYRect.bottom = m_plotRect.bottom;
// compute right axis area
m_axisRYRect.left = m_plotRect.left;
m_axisRYRect.right = m_clientRect.right - (m_iMright/5);
m_axisRYRect.top = m_plotRect.top;
m_axisRYRect.bottom = m_plotRect.bottom;
// compute bottom axis area
m_axisBXRect.left = m_plotRect.left;
m_axisBXRect.right = m_plotRect.right;
m_axisBXRect.top = m_plotRect.bottom;
m_axisBXRect.bottom = m_clientRect.bottom - (m_iMbottom/5);
// if(bInitialization)
// {
m_timeaxis.m_dSecondsPrPixel = ((double)(m_timeaxis.m_maxtime.GetTime() - m_timeaxis.m_mintime.GetTime())) / (double)m_plotRect.Width();
m_leftaxis.m_dValuePrPixel = ((double)(m_leftaxis.maxrange- m_leftaxis.minrange) / (double)m_plotRect.Height());
m_rightaxis.m_dValuePrPixel = ((double)(m_rightaxis.maxrange- m_rightaxis.minrange) / (double)m_plotRect.Height());
// }
dc.SelectObject(oFont);
}
//*******************************************************************************************************/
//* Function: clPlot::OnPaint
//*
//* Description: This function will create a memory image, call Draw to draw the plot on it, and when
//* copy the image into memory.
//*
//* This is fast and provides flicker free plot update.
//*
//* Author: Jan Vidar Berger
//*******************************************************************************************************/
void clPlot::OnPaint()
{
CPaintDC dc(this); // device context for painting
CGridMemDC pdc(&dc); // non flickering painting
Draw(&pdc);
// Do not call CWnd::OnPaint() for painting messages
}
BOOL clPlot::OnEraseBkgnd(CDC* pDC)
{
return FALSE;
}
//*******************************************************************************************************/
//*******************************************************************************************************/
void clPlot::Draw(CDC * dc)
{
CFont *oFont = dc->SelectObject(&m_font);
DrawBasic(dc);
DrawGrid(dc);
DrawPlot(dc);
DrawLegend(dc);
dc->SelectObject(oFont);
}
void FreqWindow::Recalc()
{
if (!mData || mDataLen < mWindowSize) {
DrawPlot();
return;
}
SpectrumAnalyst::Algorithm alg =
SpectrumAnalyst::Algorithm(mAlgChoice->GetSelection());
int windowFunc = mFuncChoice->GetSelection();
wxWindow *hadFocus = FindFocus();
// In wxMac, the skipped window MUST be a top level window. I'd originally made it
// just the mProgress window with the idea of preventing user interaction with the
// controls while the plot was being recalculated. This doesn't appear to be necessary
// so just use the the top level window instead.
{
Maybe<wxWindowDisabler> blocker;
if (IsShown())
blocker.create(this);
wxYieldIfNeeded();
mAnalyst->Calculate(alg, windowFunc, mWindowSize, mRate,
mData.get(), mDataLen,
&mYMin, &mYMax, mProgress);
}
if (hadFocus) {
hadFocus->SetFocus();
}
if (alg == SpectrumAnalyst::Spectrum) {
if(mYMin < -dBRange)
mYMin = -dBRange;
if(mYMax <= -dBRange)
mYMax = -dBRange + 10.; // it's all out of range, but show a scale.
else
mYMax += .5;
}
// Prime the scrollbar
mPanScroller->SetScrollbar(0, (mYMax - mYMin) * 100, (mYMax - mYMin) * 100, 1);
DrawPlot();
}
// CDlgPathMOE message handlers
void CDlgPathMOE::OnPaint()
{
CPaintDC dc(this); // device context for painting
CRect PlotRect;
GetClientRect(PlotRect);
CRect PlotRectOrg = PlotRect;
if(m_TimeLeft<0)
m_TimeLeft = 0;
if(m_TimeRight< m_TimeLeft+30)
m_TimeRight= m_TimeLeft+30;
if(Cur_MOE_type1>=0)
{
if(Cur_MOE_type2==-1 )
{
PlotRect.top += 200;
PlotRect.bottom -= 35;
PlotRect.left += 60;
PlotRect.right -= 100;
DrawPlot(&dc,Cur_MOE_type1, PlotRect);
}else
{
PlotRect.top += 200;
PlotRect.bottom = 200+ (PlotRect.bottom-200-35)/2;
PlotRect.left += 60;
PlotRect.right -= 100;
DrawPlot(&dc, Cur_MOE_type1, PlotRect);
PlotRect.top = PlotRect.bottom+45;
PlotRect.bottom = PlotRectOrg.bottom -20;
PlotRect.left = PlotRectOrg.left+60;
PlotRect.right = PlotRectOrg.right-100;
DrawPlot(&dc,Cur_MOE_type2, PlotRect);
}
}
}
void FreqWindow::OnSize(wxSizeEvent & event)
{
Layout();
mUpdateRect.x = 0;
mUpdateRect.y = 0;
mUpdateRect.SetSize( mFreqPlot->GetSize() );
mPlotRect = mUpdateRect;
DrawPlot();
Refresh(true);
}
void Widget::on_srcTextErr_clicked()
{
DWORD blockLen = 32; // Хотя должно быть 16ж
DWORD dataSize;
HCRYPTPROV hCryptProv;
HCRYPTKEY hKey;
uchar srcData[blockLen];
uchar newData[blockLen];
QVector<int> values;
QFile myFile(fName);
plot->clear();
if (myFile.exists())
myFile.open(QIODevice::ReadOnly);
else
{
QMessageBox::critical(0, "Ошибка", "Файл не выбран", QMessageBox::Ok);
return;
}
CryptAcquireContext(&hCryptProv, NULL, MS_DEF_RSA_SCHANNEL_PROV, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT);
CryptGenKey(hCryptProv, CALG_AES_256, 0, &hKey);
//CryptEncrypt(hKey, 0, true, 0, NULL, &blockLen, myFile.size());
//srcData = new uchar[blockLen];
//newData = new uchar[blockLen];
dataSize = myFile.read((char *)(&srcData[0]), blockLen);
memcpy(&newData[0], &srcData[0], blockLen);
newData[0] = -newData[0];
for (uint i = 0; i < block; i++)
{
int k = 0;
CryptEncrypt(hKey, 0, i < 2, 0, &srcData[0], &dataSize, block*blockLen);
CryptEncrypt(hKey, 0, i < 2, 0, &newData[0], &dataSize, block*blockLen);
for (uint j = 0; j < blockLen; j++)
k += trueBitsCount((uint)(srcData[j] ^ newData[j]));
values.push_back(k);
memset(&srcData[0], 0, blockLen);
dataSize = myFile.read((char *)(&srcData[0]), blockLen);
memcpy(&newData[0], &srcData[0], blockLen);
}
myFile.close();
CryptReleaseContext(hCryptProv, 0);
CryptDestroyKey(hKey);
//delete[] srcData;
//srcData = 0;
//delete[] newData;
//newData = 0;
DrawPlot(plot, values);
plot->show();
}
void FreqWindow::Recalc()
{
wxLogMessage(wxT("Starting FreqWindow::Recalc()"));
if (mProcessed)
delete[] mProcessed;
mProcessed = NULL;
if (!mData) {
mFreqPlot->Refresh(true);
return;
}
int alg = mAlgChoice->GetSelection();
int windowFunc = mFuncChoice->GetSelection();
long windowSize = 0;
(mSizeChoice->GetStringSelection()).ToLong(&windowSize);
int f = NumWindowFuncs();
if (!(windowSize >= 32 && windowSize <= 65536 &&
alg >= 0 && alg <= 4 && windowFunc >= 0 && windowFunc < f)) {
mFreqPlot->Refresh(true);
return;
}
mWindowSize = windowSize;
if (mDataLen < mWindowSize) {
mFreqPlot->Refresh(true);
return;
}
mProcessed = new float[mWindowSize];
int i;
for (i = 0; i < mWindowSize; i++)
mProcessed[i] = float(0.0);
int half = mWindowSize / 2;
float *in = new float[mWindowSize];
float *in2 = new float[mWindowSize];
float *out = new float[mWindowSize];
float *out2 = new float[mWindowSize];
float *win = new float[mWindowSize];
// initialize the window
for(int i=0; i<mWindowSize; i++)
win[i] = 1.0;
WindowFunc(windowFunc, mWindowSize, win);
// Scale window such that an amplitude of 1.0 in the time domain
// shows an amplitude of 0dB in the frequency domain
double wss = 0;
for(int i=0; i<mWindowSize; i++)
wss += win[i];
if(wss > 0)
wss = 4.0 / (wss*wss);
else
wss = 1.0;
//Progress dialog over FFT operation
wxLogMessage(wxT("Starting progress dialogue in FreqWindow::Recalc()"));
ProgressDialog *mProgress = new ProgressDialog(_("FreqWindow"),_("Drawing Spectrum"));
int start = 0;
int windows = 0;
while (start + mWindowSize <= mDataLen) {
for (i = 0; i < mWindowSize; i++)
in[i] = win[i] * mData[start + i];
switch (alg) {
case 0: // Spectrum
PowerSpectrum(mWindowSize, in, out);
for (i = 0; i < half; i++)
mProcessed[i] += out[i];
break;
case 1:
case 2:
case 3: // Autocorrelation, Cuberoot AC or Enhanced AC
// Take FFT
#ifdef EXPERIMENTAL_USE_REALFFTF
RealFFT(mWindowSize, in, out, out2);
#else
FFT(mWindowSize, false, in, NULL, out, out2);
#endif
// Compute power
for (i = 0; i < mWindowSize; i++)
in[i] = (out[i] * out[i]) + (out2[i] * out2[i]);
if (alg == 1) {
for (i = 0; i < mWindowSize; i++)
in[i] = sqrt(in[i]);
}
if (alg == 2 || alg == 3) {
// Tolonen and Karjalainen recommend taking the cube root
// of the power, instead of the square root
for (i = 0; i < mWindowSize; i++)
in[i] = pow(in[i], 1.0f / 3.0f);
}
// Take FFT
#ifdef EXPERIMENTAL_USE_REALFFTF
RealFFT(mWindowSize, in, out, out2);
#else
FFT(mWindowSize, false, in, NULL, out, out2);
#endif
// Take real part of result
for (i = 0; i < half; i++)
mProcessed[i] += out[i];
break;
case 4: // Cepstrum
#ifdef EXPERIMENTAL_USE_REALFFTF
RealFFT(mWindowSize, in, out, out2);
#else
FFT(mWindowSize, false, in, NULL, out, out2);
#endif
// Compute log power
// Set a sane lower limit assuming maximum time amplitude of 1.0
float power;
float minpower = 1e-20*mWindowSize*mWindowSize;
for (i = 0; i < mWindowSize; i++)
{
power = (out[i] * out[i]) + (out2[i] * out2[i]);
if(power < minpower)
in[i] = log(minpower);
else
in[i] = log(power);
}
// Take IFFT
#ifdef EXPERIMENTAL_USE_REALFFTF
InverseRealFFT(mWindowSize, in, NULL, out);
#else
FFT(mWindowSize, true, in, NULL, out, out2);
#endif
// Take real part of result
for (i = 0; i < half; i++)
mProcessed[i] += out[i];
break;
} //switch
start += half;
windows++;
// only update the progress dialogue infrequently to reduce it's overhead
// If we do it every time, it spends as much time updating X11 as doing
// the calculations. 10 seems a reasonable compromise on Linux that
// doesn't make it unresponsive, but avoids the slowdown.
if ((windows % 10) == 0)
mProgress->Update(1 - static_cast<float>(mDataLen - start) / mDataLen);
}
wxLogMessage(wxT("Finished updating progress dialogue in FreqWindow::Recalc()"));
switch (alg) {
double scale;
case 0: // Spectrum
// Convert to decibels
mYMin = 1000000.;
mYMax = -1000000.;
scale = wss / (double)windows;
for (i = 0; i < half; i++)
{
mProcessed[i] = 10 * log10(mProcessed[i] * scale);
if(mProcessed[i] > mYMax)
mYMax = mProcessed[i];
else if(mProcessed[i] < mYMin)
mYMin = mProcessed[i];
}
if(mYMin < -dBRange)
mYMin = -dBRange;
if(mYMax <= -dBRange)
mYMax = -dBRange + 10.; // it's all out of range, but show a scale.
else
mYMax += .5;
mProcessedSize = half;
mYStep = 10;
break;
case 1: // Standard Autocorrelation
case 2: // Cuberoot Autocorrelation
for (i = 0; i < half; i++)
mProcessed[i] = mProcessed[i] / windows;
// Find min/max
mYMin = mProcessed[0];
mYMax = mProcessed[0];
for (i = 1; i < half; i++)
if (mProcessed[i] > mYMax)
mYMax = mProcessed[i];
else if (mProcessed[i] < mYMin)
mYMin = mProcessed[i];
mYStep = 1;
mProcessedSize = half;
break;
case 3: // Enhanced Autocorrelation
for (i = 0; i < half; i++)
mProcessed[i] = mProcessed[i] / windows;
// Peak Pruning as described by Tolonen and Karjalainen, 2000
// Clip at zero, copy to temp array
for (i = 0; i < half; i++) {
if (mProcessed[i] < 0.0)
mProcessed[i] = float(0.0);
out[i] = mProcessed[i];
}
// Subtract a time-doubled signal (linearly interp.) from the original
// (clipped) signal
for (i = 0; i < half; i++)
if ((i % 2) == 0)
mProcessed[i] -= out[i / 2];
else
mProcessed[i] -= ((out[i / 2] + out[i / 2 + 1]) / 2);
// Clip at zero again
for (i = 0; i < half; i++)
if (mProcessed[i] < 0.0)
mProcessed[i] = float(0.0);
// Find new min/max
mYMin = mProcessed[0];
mYMax = mProcessed[0];
for (i = 1; i < half; i++)
if (mProcessed[i] > mYMax)
mYMax = mProcessed[i];
else if (mProcessed[i] < mYMin)
mYMin = mProcessed[i];
mYStep = 1;
mProcessedSize = half;
break;
case 4: // Cepstrum
for (i = 0; i < half; i++)
mProcessed[i] = mProcessed[i] / windows;
// Find min/max, ignoring first and last few values
int ignore = 4;
mYMin = mProcessed[ignore];
mYMax = mProcessed[ignore];
for (i = ignore + 1; i < half - ignore; i++)
if (mProcessed[i] > mYMax)
mYMax = mProcessed[i];
else if (mProcessed[i] < mYMin)
mYMin = mProcessed[i];
mYStep = 1;
mProcessedSize = half;
break;
}
delete[]in;
delete[]in2;
delete[]out;
delete[]out2;
delete[]win;
wxLogMessage(wxT("About to draw plot in FreqWindow::Recalc()"));
DrawPlot();
mFreqPlot->Refresh(true);
delete mProgress;
}
void FreqWindow::OnAxisChoice(wxCommandEvent & WXUNUSED(event))
{
mLogAxis = mAxisChoice->GetSelection() ? true : false;
DrawPlot();
}
void FreqWindow::OnZoomSlider(wxCommandEvent & WXUNUSED(event))
{
DrawPlot();
}
void FreqWindow::OnPanScroller(wxScrollEvent & WXUNUSED(event))
{
DrawPlot();
}
void FreqWindow::OnGridOnOff(wxCommandEvent & WXUNUSED(event))
{
mDrawGrid = mGridOnOff->IsChecked();
DrawPlot();
}
void CCube::RenderCube(const GLfloat* asize)
{
static double dOff[3] = {-1.0f, -1.0f, -.5f};
static const double dMin[3] = {-1.0f, -1.0f, -.5f};
static const double dMax[3] = {2.0f, 1.5f, 1.0f};
static const double dFactor[3] = {.01f, .01f, .01f};
static bool bDec[3] = { false, false, false};
InitCamera();
glLineWidth(3);
diffuse[0] = diffuse[1] = diffuse[2] = 0.8 + scaleAll;
specular[0] = specular[1] = specular[2] = 1.0;
glPushMatrix(); // light matrix
OrthographicMatrix();
// get an appropriate lOffset if available - we want at least 100 points + 2 for "padding"
long lOffset = 0;
if (sm && sm->bSensorFound) {
if (sm->lOffset > MAX_PLOT_POINTS+2) { // note the two point "padding" so we are reading the latest value that isn't in use by the sensor (i.e. writing)
lOffset = sm->lOffset-2;
}
}
if (bIsQCNLive) {
glTranslatef(asize[E_DX], asize[E_DZ], 0.0);//Jesse Lawrence Changed - X & Z MOTIONS (Y IS SIZE)
} else {
glTranslatef(-.50 + dOff[0], dOff[1], dOff[2]);
}
for (int i = 0; i < 3; i++) {
if (dOff[i]>dMax[i]) {
bDec[i] = true;
}
else if (dOff[i]<dMin[i]) {
bDec[i] = false;
}
dOff[i] += (dFactor[i] * (bDec[i] ? -1.0 : 1.0));
}
glRotatef(rot.x, rot.y, rot.y/3.0f, 0.0);
rot.x += rotationSpeed * 1.9134f;
rot.y += rotationSpeed * 2.1234f;
glPushMatrix();
//glTranslatef(0.0f, 0.0f,-7.0f); // Translate Into The Screen 7.0 Units
//glRotatef(rotqube,0.0f,1.0f,0.0f); // Rotate The cube around the Y axis
//glRotatef(rotqube,1.0f,1.0f,1.0f);
if (bIsQCNLive) {
float asize_all = asize[E_DY];//Jesse Lawrence Added - Constant size for all dimensions
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(blue); // Color Green
glVertex3f( asize_all, asize_all, -asize_all); // Top Right Of The Quad (Top)
glVertex3f(-asize_all, asize_all,-asize_all); // Top Left Of The Quad (Top)
glVertex3f(-asize_all, asize_all, asize_all); // Bottom Left Of The Quad (Top)
glVertex3f( asize_all, asize_all, asize_all); // Bottom Right Of The Quad (Top)
glEnd();
// note the asize in DrawPlot below should be the "y-axis" for whichever face we're looking at
// DrawPlot(lOffset ? (const GLfloat*) &(sm->x0[lOffset]) : NULL, asize, CUBE_TOP); // x-axis is green
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(blue); // Color Yellow
glVertex3f( asize_all,-asize_all, asize_all); // Top Right Of The Quad (Bottom)
glVertex3f(-asize_all,-asize_all, asize_all); // Top Left Of The Quad (Bottom)
glVertex3f(-asize_all,-asize_all,-asize_all); // Bottom Left Of The Quad (Bottom)
glVertex3f( asize_all,-asize_all,-asize_all); // Bottom Right Of The Quad (Bottom)
glEnd();
// DrawPlot(lOffset ? (const float*) &(sm->y0[lOffset]) : NULL, asize, CUBE_BOTTOM); // y-axis is yellow
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(orange); // Color Blue
glVertex3f( asize_all, asize_all, asize_all); // Top Right Of The Quad (Front)
glVertex3f(-asize_all, asize_all, asize_all); // Top Left Of The Quad (Front)
glVertex3f(-asize_all,-asize_all, asize_all); // Bottom Left Of The Quad (Front)
glVertex3f( asize_all,-asize_all, asize_all); // Bottom Right Of The Quad (Front)
glEnd();
// DrawPlot(lOffset ? (const float*) &(sm->z0[lOffset]) : NULL, asize, CUBE_FRONT); // z-axis is blue
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(green); // Color Red
glVertex3f( asize_all,-asize_all,-asize_all); // Top Right Of The Quad (Back)
glVertex3f(-asize_all,-asize_all,-asize_all); // Top Left Of The Quad (Back)
glVertex3f(-asize_all, asize_all,-asize_all); // Bottom Left Of The Quad (Back)
glVertex3f( asize_all, asize_all,-asize_all); // Bottom Right Of The Quad (Back)
glEnd();
// DrawPlot(lOffset ? (const float*) &(sm->fsig[lOffset]) : NULL, asize, CUBE_BACK); // fsig/significance is red
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(green); // Color Cyan
glVertex3f(-asize_all, asize_all, asize_all); // Top Right Of The Quad (Left)
glVertex3f(-asize_all, asize_all,-asize_all); // Top Left Of The Quad (Left)
glVertex3f(-asize_all,-asize_all,-asize_all); // Bottom Left Of The Quad (Left)
glVertex3f(-asize_all,-asize_all, asize_all); // Bottom Right Of The Quad (Left)
glEnd();
// DrawPlot(lOffset ? (const float*) &(sm->fmag[lOffset]) : NULL, asize, CUBE_LEFT); // magnitude
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(orange); // Color Magenta
glVertex3f( asize_all, asize_all,-asize_all); // Top Right Of The Quad (Right)
glVertex3f( asize_all, asize_all, asize_all); // Top Left Of The Quad (Right)
glVertex3f( asize_all,-asize_all, asize_all); // Bottom Left Of The Quad (Right)
glVertex3f( asize_all,-asize_all,-asize_all); // Bottom Right Of The Quad (Right)
glEnd();
// DrawPlot(lOffset ? (const float*) &(sm->vari[lOffset]) : NULL, asize, CUBE_RIGHT); // variance
} else { // screensaver mode
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(green); // Color Green
glVertex3f( asize[E_DX], asize[E_DY], -asize[E_DZ]); // Top Right Of The Quad (Top)
glVertex3f(-asize[E_DX], asize[E_DY],-asize[E_DZ]); // Top Left Of The Quad (Top)
glVertex3f(-asize[E_DX], asize[E_DY], asize[E_DZ]); // Bottom Left Of The Quad (Top)
glVertex3f( asize[E_DX], asize[E_DY], asize[E_DZ]); // Bottom Right Of The Quad (Top)
glEnd();
// note the asize in DrawPlot below should be the "y-axis" for whichever face we're looking at
DrawPlot(lOffset ? (const GLfloat*) &(sm->x0[lOffset]) : NULL, asize, CUBE_TOP); // x-axis is green
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(yellow); // Color Yellow
glVertex3f( asize[E_DX],-asize[E_DY], asize[E_DZ]); // Top Right Of The Quad (Bottom)
glVertex3f(-asize[E_DX],-asize[E_DY], asize[E_DZ]); // Top Left Of The Quad (Bottom)
glVertex3f(-asize[E_DX],-asize[E_DY],-asize[E_DZ]); // Bottom Left Of The Quad (Bottom)
glVertex3f( asize[E_DX],-asize[E_DY],-asize[E_DZ]); // Bottom Right Of The Quad (Bottom)
glEnd();
DrawPlot(lOffset ? (const float*) &(sm->y0[lOffset]) : NULL, asize, CUBE_BOTTOM); // y-axis is yellow
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(blue); // Color Blue
glVertex3f( asize[E_DX], asize[E_DY], asize[E_DZ]); // Top Right Of The Quad (Front)
glVertex3f(-asize[E_DX], asize[E_DY], asize[E_DZ]); // Top Left Of The Quad (Front)
glVertex3f(-asize[E_DX],-asize[E_DY], asize[E_DZ]); // Bottom Left Of The Quad (Front)
glVertex3f( asize[E_DX],-asize[E_DY], asize[E_DZ]); // Bottom Right Of The Quad (Front)
glEnd();
DrawPlot(lOffset ? (const float*) &(sm->z0[lOffset]) : NULL, asize, CUBE_FRONT); // z-axis is blue
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(red); // Color Red
glVertex3f( asize[E_DX],-asize[E_DY],-asize[E_DZ]); // Top Right Of The Quad (Back)
glVertex3f(-asize[E_DX],-asize[E_DY],-asize[E_DZ]); // Top Left Of The Quad (Back)
glVertex3f(-asize[E_DX], asize[E_DY],-asize[E_DZ]); // Bottom Left Of The Quad (Back)
glVertex3f( asize[E_DX], asize[E_DY],-asize[E_DZ]); // Bottom Right Of The Quad (Back)
glEnd();
DrawPlot(lOffset ? (const float*) &(sm->fsig[lOffset]) : NULL, asize, CUBE_BACK); // fsig/significance is red
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(cyan); // Color Cyan
glVertex3f(-asize[E_DX], asize[E_DY], asize[E_DZ]); // Top Right Of The Quad (Left)
glVertex3f(-asize[E_DX], asize[E_DY],-asize[E_DZ]); // Top Left Of The Quad (Left)
glVertex3f(-asize[E_DX],-asize[E_DY],-asize[E_DZ]); // Bottom Left Of The Quad (Left)
glVertex3f(-asize[E_DX],-asize[E_DY], asize[E_DZ]); // Bottom Right Of The Quad (Left)
glEnd();
DrawPlot(lOffset ? (const float*) &(sm->fmag[lOffset]) : NULL, asize, CUBE_LEFT); // magnitude
glBegin(GL_QUADS); // Draw The Cube Using quads
glColor4fv(magenta); // Color Magenta
glVertex3f( asize[E_DX], asize[E_DY],-asize[E_DZ]); // Top Right Of The Quad (Right)
glVertex3f( asize[E_DX], asize[E_DY], asize[E_DZ]); // Top Left Of The Quad (Right)
glVertex3f( asize[E_DX],-asize[E_DY], asize[E_DZ]); // Bottom Left Of The Quad (Right)
glVertex3f( asize[E_DX],-asize[E_DY],-asize[E_DZ]); // Bottom Right Of The Quad (Right)
glEnd();
DrawPlot(lOffset ? (const float*) &(sm->vari[lOffset]) : NULL, asize, CUBE_RIGHT); // variance
}
glPopMatrix();
glPopMatrix(); // rotation matrix
glFlush();
}
