bool ZoomCameraCommand::
zoom(float delta, ZoomMode mode)
{
float L = model->project()->length();
float fs = model->project()->extent().sample_rate.get();
float min_xscale = 4.f/std::max(L,10/fs);
float max_xscale = 0.05f*fs;
// Could use VisualizationParams::detail_info instead
const Tfr::FreqAxis& tfa = model->transform_desc ()->freqAxis(fs);
unsigned maxi = tfa.getFrequencyScalar(fs/2);
float hza = tfa.getFrequency(0u);
float hza2 = tfa.getFrequency(1u);
float hzb = tfa.getFrequency(maxi - 1);
float hzb2 = tfa.getFrequency(maxi - 2);
const Heightmap::FreqAxis& ds = model->display_scale();
float scalara = ds.getFrequencyScalar( hza );
float scalara2 = ds.getFrequencyScalar( hza2 );
float scalarb = ds.getFrequencyScalar( hzb );
float scalarb2 = ds.getFrequencyScalar( hzb2 );
float minydist = std::min(fabsf(scalara2 - scalara), fabsf(scalarb2 - scalarb));
float min_yscale = 4.f;
float max_yscale = 1.f/minydist;
if (delta > 0)
{
switch(mode)
{
case ScaleX: if (model->xscale == min_xscale)
return false;
break;
case ScaleZ: if (model->zscale == min_yscale)
return false;
break;
default:
break;
}
}
switch(mode)
{
case Zoom: doZoom( delta, 0, 0, 0 ); break;
case ScaleX: doZoom( delta, &model->xscale, &min_xscale, &max_xscale); break;
case ScaleZ: doZoom( delta, &model->zscale, &min_yscale, &max_yscale ); break;
}
return true;
}
void VideoCaptureView::paintEvent(QPaintEvent* paintEvent)
{
QPainter painter(this);
if (!m_cleared)
{
QPoint brushOrigin = painter.brushOrigin();
// Paint window background
painter.setBrushOrigin(-mapToGlobal(QPoint(0, 0)));
painter.fillRect(paintEvent->rect(), window()->palette().brush(QPalette::Window));
// Reset origin
painter.setBrushOrigin(brushOrigin);
m_cleared = true;
}
if (m_tidUpdate && !available()) {
painter.drawText(rect(), Qt::AlignCenter | Qt::TextWordWrap, tr("No Camera"));
killTimer(m_tidUpdate);
}
else
{
if (m_tidUpdate > 0 || m_force)
{
m_capture->getCameraImage(m_image);
doZoom();
}
int w = m_image.width();
int h = m_image.height();
if (!(w == 0 || h == 0))
{
if (width() * w > height() * h) {
w = w * height() / h;
h = height();
}
else {
h = h * width() / w;
w = width();
}
painter.drawImage(QRect((width() - w) / 2, (height() - h) / 2, w, h),
m_image,
QRect(0, 0, m_image.width(), m_image.height()));
}
}
}
MainWindowImpl::MainWindowImpl( QWidget * parent, Qt::WFlags f)
: QMainWindow(parent, f)
{
setupUi(this);
//initialize Experiment Manager
treeWidget->setColumnCount(3);
QStringList header;//EP Header
header << "Name" << "Iteration" << "Step";
treeWidget->setHeaderLabels(header);//assign headers
//connect the signal related to the top bars
connect(actionOpen, SIGNAL(triggered()), this, SLOT(openSelect()));
connect(actionOpen_2, SIGNAL(clicked()), this, SLOT(openSelect()));
connect(actionSave, SIGNAL(triggered()), this, SLOT(saveFile()));
connect(actionSave_1, SIGNAL(triggered()), this, SLOT(saveFile()));
connect(actionSave_2, SIGNAL(clicked()), this, SLOT(saveFile()));
connect(actionAnimator, SIGNAL(clicked()), this, SLOT(OpenAnimatorWindow()));
connect(actionZoom_1, SIGNAL(clicked()), this, SLOT(doZoom()));
connect(actionZoom, SIGNAL(triggered()), this, SLOT(doZoom()));
connect(actionSlice, SIGNAL(triggered()), this, SLOT(doSlice()));
connect(actionSlice_1, SIGNAL(clicked()), this, SLOT(doSlice()));
connect(actionPan, SIGNAL(triggered()), this, SLOT(doPan()));
connect(actionRotate, SIGNAL(triggered()), this, SLOT(doRotate()));
//connect vel
connect(treeWidget, SIGNAL(itemDoubleClicked ( QTreeWidgetItem*, int ) ), this, SLOT(openModel(QTreeWidgetItem*)));
//vswork connect widgets to references
vswork.setTree(treeWidget);
//Initialize custom cursor pointers
QBitmap zoomB("zoom.png");
QBitmap rotateB("rotate.jpeg");
QBitmap sliceB("slice.png");
zoomCursor = QCursor(zoomB, -1, -1);
rotateCursor = QCursor(rotateB, -1, -1);
sliceCursor = QCursor(sliceB, -1, -1);
}
void GraphWidget::draw()
{
if (!valid()) {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glViewport(0, 0, w(), h());
glClearColor(GRID_BACKGROUND_INTENSITY, GRID_BACKGROUND_INTENSITY, GRID_BACKGROUND_INTENSITY, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glClear(GL_COLOR_BUFFER_BIT);
glColor3d(0,0,0);
glBegin(GL_POLYGON);
glVertex2d( -w(), -h() );
glVertex2d( -w(), h() );
glVertex2d( w(), h() );
glVertex2d( w(), -h() );
glEnd();
/************************************************************************************/
//The grid.. We're copying this from rulerwindow class.
//Really to two should have a single reference function.
double dRangeX = rightTime() - leftTime();
double dRangeY = (rightTime() - leftTime());
int iWindowWidth = w();
int iWindowHeight = h();
const int k_iAvgLongMarkLen = 15;
int iLongMarkCountX = iWindowWidth / k_iAvgLongMarkLen;
int iLongMarkCountY = iWindowHeight / k_iAvgLongMarkLen;
if (iLongMarkCountX > 0 && iWindowWidth > 0) {
// Computer the long mark length so that it's 10^i where i is an integer
double dLongMarkLengthX = dRangeX / (double)iLongMarkCountX;
double dLongMarkLengthPowX = log10(dLongMarkLengthX);
int iLongMarkLengthPowX = (int)ceil(dLongMarkLengthPowX);
dLongMarkLengthX = pow(10.0, (double)iLongMarkLengthPowX);
double dLongMarkLengthY = dRangeY / (double)iLongMarkCountY;
double dLongMarkLengthPowY = log10(dLongMarkLengthY);
int iLongMarkLengthPowY = (int)ceil(dLongMarkLengthPowY);
dLongMarkLengthY = pow(10.0, (double)iLongMarkLengthPowY);
int iStartX = (int)ceil(leftTime() / dLongMarkLengthX);
int iMarkX, iMarkY;
double x,y;
glColor3d(1,1,1);
glPointSize(0.5);
glBegin(GL_POINTS);
do {
iMarkX = 2*(int)(((double)iStartX * dLongMarkLengthX - leftTime()) / dRangeX * (double)iWindowWidth + 0.5) - w();
x = (double)iMarkX / w();
int iStartY = (int)ceil(leftTime() / dLongMarkLengthY);
do{
iMarkY = 2*(int)(((double)iStartY * dLongMarkLengthY - leftTime()) / dRangeY * (double)iWindowHeight + 0.5) - h();
y = (double)iMarkY / h();
glVertex2d(x,y);
++iStartY;
} while (iMarkY < iWindowHeight);
++iStartX;
} while (iMarkX < iWindowWidth);
glEnd();
}
/************************************************************************************/
if (m_bHasEvent) {
m_bHasEvent = false;
switch (m_iEventToDo) {
case LEFT_MOUSE_DOWN:
selectAddCtrlPt(m_iMouseX, m_iMouseY);
break;
case LEFT_MOUSE_DRAG:
dragCtrlPt(m_iMouseX, m_iMouseY);
break;
case LEFT_MOUSE_UP:
break;
case ALT_LEFT_DOWN:
startCtrlPtSelection(m_iMouseX, m_iMouseY);
break;
case ALT_LEFT_DRAG:
doCtrlPtSelection(m_iMouseX, m_iMouseY);
break;
case ALT_LEFT_UP:
endCtrlPtSelection(m_iMouseX, m_iMouseY);
break;
case CTRL_LEFT_DOWN:
selectCurrCurve(m_iMouseX, m_iMouseY);
break;
case SHIFT_LEFT_DOWN:
removeCtrlPt(m_iMouseX, m_iMouseY);
break;
case RIGHT_MOUSE_DOWN:
break;
case RIGHT_MOUSE_DRAG:
doZoom(m_iMouseDX, m_iMouseDY);
break;
case RIGHT_MOUSE_UP:
break;
case SHIFT_RIGHT_DOWN:
break;
case SHIFT_RIGHT_DRAG:
m_bPanning = true;
doPan(m_iMouseDX, m_iMouseDY);
break;
case SHIFT_RIGHT_UP:
m_bPanning = false;
break;
case CTRL_RIGHT_DOWN:
startZoomSelection(m_iMouseX, m_iMouseY);
break;
case CTRL_RIGHT_DRAG:
doZoomSelection(m_iMouseX, m_iMouseY);
break;
case CTRL_RIGHT_UP:
endZoomSelection(m_iMouseX, m_iMouseY);
break;
default:
break;
}
do_callback();
}
drawTimeBar();
drawActiveCurves();
drawZoomSelectionMap();
drawSelectionRect();
}
Phraktalus::Phraktalus(QWidget *parent) :
QMainWindow(parent),
lastDir(QString()),
ui(new Ui::Phraktalus),
viewport(new GLViewPort(this)),
ms(new ModelStacker(this)),
dots(new QSpinBox(this)),
statusLabel(new QLabel("Welcome to Phraktalus"))
{
//Sets up the premade ui
ui->setupUi(this);
setWindowTitle(windowTitle());
setStatusBar(new QStatusBar(this));
statusBar()->addWidget(statusLabel);
statusBar()->show();
//Populate the menuBar
ui->menuBar->addAction(ui->action_About);
//Populate toolBars
//File menu
ui->toolBar->addAction(ui->action_New);
ui->toolBar->addAction(ui->action_Open);
ui->toolBar->addSeparator();
//View Menu
QSpinBox *gridPrecision = new QSpinBox(this);
gridPrecision->setMinimum(1);
gridPrecision->setMaximum(5);
gridPrecision->setToolTip("Adjusts Grid precision");
ui->toolBar->addWidget(gridPrecision);
QAction* showGrids = new QAction(QIcon(":/icons/rule.png"), "Show Grids", this);
showGrids->setCheckable(true);
showGrids->setChecked(true);
showGrids->setMenu(ui->menu_Grids);
ui->toolBar->addAction(showGrids);
ui->toolBar->addAction(ui->action_Show_Labels);
ui->toolBar->addAction(ui->action_Surface);
ui->toolBar->addAction(ui->action_Lighting);
ui->toolBar->addAction(ui->action_Reset_Camera);
ui->toolBar->addSeparator();
//Process Menu
dots->setMinimum(1);
dots->setMaximum(4);
dots->setToolTip("Adjusts number of visible dots");
ui->toolBar->addWidget(dots);
ui->toolBar->addAction(ui->action_Previous);
connect(ms, SIGNAL(hasPrevious(bool)), ui->action_Previous, SLOT(setEnabled(bool)));
ui->toolBar->addAction(ui->action_Next);
connect(ms, SIGNAL(hasNext(bool)), ui->action_Next, SLOT(setEnabled(bool)));
ui->toolBar->addAction(ui->action_Zoom);
connect(ms, SIGNAL(isEmpty(bool)), ui->action_Zoom, SLOT(setDisabled(bool)));
ms->emitSignals();
ui->toolBar->setVisible(true);
//Set main viewport
setCentralWidget(viewport);
//Connect actions relative to GL
connect(ui->action_Lighting, SIGNAL(toggled(bool)), viewport, SLOT(setLighting(bool)));
connect(ui->action_Reset_Camera, SIGNAL(triggered()), viewport, SLOT(resetCamera()));
connect(ui->action_Horizontal, SIGNAL(toggled(bool)), viewport, SLOT(showHorizontalGrid(bool)));
connect(ui->action_Vertical, SIGNAL(toggled(bool)), viewport, SLOT(showVerticalGrid(bool)));
connect(ui->action_Surface, SIGNAL(toggled(bool)), viewport, SLOT(showSurface(bool)));
connect(gridPrecision, SIGNAL(valueChanged(int)), viewport, SLOT(setGridPrecision(int)));
connect(ui->action_Show_Labels, SIGNAL(toggled(bool)), viewport, SLOT(showLabels(bool)));
connect(ms, SIGNAL(topChanged(ElevationModel*)), viewport, SLOT(setModel(ElevationModel*)));
connect(ms, SIGNAL(topChanged(ElevationModel*)), this, SLOT(onTopChanged(ElevationModel*)));
//Zoom region
connect(ui->action_Zoom, SIGNAL(toggled(bool)), viewport, SLOT(zoomModeEnable(bool)));
connect(viewport, SIGNAL(doZoom(uint,uint,uint)), this, SLOT(zoomHandle(uint, uint, uint)));
connect(showGrids, SIGNAL(toggled(bool)), ui->action_Vertical, SLOT(setChecked(bool)));
connect(showGrids, SIGNAL(toggled(bool)), ui->action_Horizontal, SLOT(setChecked(bool)));
gridPrecision->setValue(GRIDPRECISION);
dots->setValue(VISIBLEDOTS);
}
