From 0bdc4110ac010685ee3e81552041bc553d848294 Mon Sep 17 00:00:00 2001 From: Samuel Fadel Date: Mon, 4 Apr 2016 17:16:08 -0300 Subject: LinePlot: working properly (and updates settings). Added the several options to the bundling (from CUBu) as properties of the LinePlot component, which are set from the options UI. In addition, many changes to the UI regarding those options. Added a new shortcut to hide options (for cleaner demos). --- lineplot.cpp | 382 ++++++++++++++++++++++++++--------- lineplot.h | 119 +++++++++-- main.cpp | 53 +++-- main.h | 4 + main_view.qml | 627 +++++++++++++++++++++++++++++++++++++++------------------- 5 files changed, 857 insertions(+), 328 deletions(-) diff --git a/lineplot.cpp b/lineplot.cpp index b4d7412..83f6e12 100644 --- a/lineplot.cpp +++ b/lineplot.cpp @@ -19,86 +19,124 @@ #include "geometry.h" #include "scatterplot.h" +static const int SAMPLES = 128; + LinePlot::LinePlot(QQuickItem *parent) : QQuickFramebufferObject(parent) , m_sx(0, 1, 0, 1) , m_sy(0, 1, 0, 1) - , m_xyChanged(false) + , m_linesChanged(false) , m_valuesChanged(false) , m_colorScaleChanged(false) + + // Q_PROPERTY's + , m_iterations(15) + , m_kernelSize(32) + , m_smoothingFactor(0.2) + , m_smoothingIterations(1) + + , m_blockEndpoints(true) + , m_endsIterations(0) + , m_endsKernelSize(32) + , m_endsSmoothingFactor(0.5) + + , m_edgeSampling(15) + , m_advectionSpeed(0.5) + , m_relaxation(0) , m_bundleGPU(true) { + setFlag(QQuickItem::ItemHasContents); setTextureFollowsItemSize(false); } -void LinePlot::setColorScale(const ColorScale *colorScale) +void LinePlot::setColorScale(const ColorScale *scale) { - m_colorScale = colorScale; - if (m_values.size() > 0) { - // FIXME - m_colorScaleChanged = true; - update(); - } + m_cmap.resize(SAMPLES * 3); + scale->sample(SAMPLES, m_cmap.begin()); + + setColorScaleChanged(true); + update(); } void LinePlot::bundle() { - Graph g(m_xy.n_rows); - PointSet points; + m_gdBundlePtr.reset(new GraphDrawing); + *m_gdBundlePtr.get() = *m_gdPtr.get(); - for (arma::uword i = 0; i < m_xy.n_rows; i++) { - const arma::rowvec &row = m_xy.row(i); - points.push_back(Point2d(row[0], row[1])); + CPUBundling bundling(std::min(width(), height())); + bundling.setInput(m_gdBundlePtr.get()); - if (i > 0) { - g(i - 1, i) = m_values[i]; - g(i, i - 1) = m_values[i]; - } - } + bundling.niter = m_iterations; + bundling.h = m_kernelSize; + bundling.lambda = m_smoothingFactor; + bundling.liter = m_smoothingIterations; - m_gdPtr.reset(new GraphDrawing); - m_gdPtr.get()->build(&g, &points); + bundling.block_endpoints = m_blockEndpoints; + bundling.niter_ms = m_endsIterations; + bundling.h_ms = m_endsKernelSize; + bundling.lambda_ends = m_endsSmoothingFactor; + + bundling.spl = m_edgeSampling; + bundling.eps = m_advectionSpeed; + // TODO: use m_relaxation as lerp param towards original (without bundling) - CPUBundling bundling(std::min(width(), height())); - bundling.setInput(m_gdPtr.get()); if (m_bundleGPU) { bundling.bundleGPU(); } else { bundling.bundleCPU(); } + + setLinesChanged(true); } -void LinePlot::setXY(const arma::mat &xy) +void LinePlot::setLines(const arma::uvec &indices, const arma::mat &Y) { - if (xy.n_cols != 2) { + if (indices.n_elem % 2 != 0 || Y.n_cols != 2) { return; } - m_xy = xy; - m_xyChanged = true; - emit xyChanged(m_xy); + m_lines = Y.rows(indices); + + // Build the line plot's internal representation: a graph where each + // endpoint of a line is a node, each line is a link... + Graph g(Y.n_rows); + PointSet points; + + m_sx.setRange(0, width()); + m_sy.setRange(0, height()); + for (arma::uword i = 0; i < Y.n_rows; i++) { + points.push_back(Point2d(m_sx(Y(i, 0)), m_sy(Y(i, 1)))); + } + + for (arma::uword k = 0; k < m_values.size(); k++) { + arma::uword i = indices(2*k + 0), + j = indices(2*k + 1); - // Build the line plot's internal representation: graph where each endpoint - // of a line is a node, each line is a link; and then bundle the graph's - // edges + g(i, j) = g(j, i) = m_values[k]; + } + + m_gdPtr.reset(new GraphDrawing); + m_gdPtr.get()->build(&g, &points); + + // ... then bundle the edges bundle(); + emit linesChanged(m_lines); update(); } void LinePlot::setValues(const arma::vec &values) { - if (m_xy.n_rows > 0 - && (values.n_elem > 0 && values.n_elem != m_xy.n_rows)) { + if (m_lines.n_rows > 0 + && (values.n_elem > 0 && values.n_elem != m_lines.n_rows)) { return; } m_values.resize(values.n_elem); - LinearScale scale(values.min(), values.max(), 0, 1.0f); - std::transform(values.begin(), values.end(), m_values.begin(), scale); + std::copy(values.begin(), values.end(), m_values.begin()); emit valuesChanged(values); - m_valuesChanged = true; + setValuesChanged(true); update(); } @@ -111,6 +149,162 @@ void LinePlot::setScale(const LinearScale &sx, update(); } +// Q_PROPERTY's +void LinePlot::setIterations(int iterations) { + if (m_iterations == iterations) { + return; + } + + m_iterations = iterations; + emit iterationsChanged(m_iterations); + + bundle(); + update(); +} + +void LinePlot::setKernelSize(float kernelSize) +{ + if (m_kernelSize == kernelSize) { + return; + } + + m_kernelSize = kernelSize; + emit kernelSizeChanged(m_kernelSize); + + bundle(); + update(); +} + +void LinePlot::setSmoothingFactor(float smoothingFactor) +{ + if (m_smoothingFactor == smoothingFactor) { + return; + } + + m_smoothingFactor = smoothingFactor; + emit smoothingFactorChanged(m_smoothingFactor); + + bundle(); + update(); +} + +void LinePlot::setSmoothingIterations(int smoothingIterations) +{ + if (m_smoothingIterations == smoothingIterations) { + return; + } + + m_smoothingIterations = smoothingIterations; + emit smoothingIterationsChanged(m_smoothingIterations); + + bundle(); + update(); +} + +void LinePlot::setBlockEndpoints(bool blockEndpoints) +{ + if (m_blockEndpoints == blockEndpoints) { + return; + } + + m_blockEndpoints = blockEndpoints; + emit blockEndpointsChanged(m_blockEndpoints); + + bundle(); + update(); +} + +void LinePlot::setEndsIterations(int endsIterations) +{ + if (m_endsIterations == endsIterations) { + return; + } + + m_endsIterations = endsIterations; + emit endsIterationsChanged(m_endsIterations); + + bundle(); + update(); +} + +void LinePlot::setEndsKernelSize(float endsKernelSize) +{ + if (m_endsKernelSize == endsKernelSize) { + return; + } + + m_endsKernelSize = endsKernelSize; + emit endsKernelSizeChanged(m_endsKernelSize); + + bundle(); + update(); +} + +void LinePlot::setEndsSmoothingFactor(float endsSmoothingFactor) +{ + if (m_endsSmoothingFactor == endsSmoothingFactor) { + return; + } + + m_endsSmoothingFactor = endsSmoothingFactor; + emit endsSmoothingFactorChanged(m_endsSmoothingFactor); + + bundle(); + update(); +} + +void LinePlot::setEdgeSampling(float edgeSampling) +{ + if (m_edgeSampling == edgeSampling) { + return; + } + + m_edgeSampling = edgeSampling; + emit edgeSamplingChanged(m_edgeSampling); + + bundle(); + update(); +} + +void LinePlot::setAdvectionSpeed(float advectionSpeed) +{ + if (m_advectionSpeed == advectionSpeed) { + return; + } + + m_advectionSpeed = advectionSpeed; + emit advectionSpeedChanged(m_advectionSpeed); + + bundle(); + update(); +} + +void LinePlot::setRelaxation(float relaxation) +{ + if (m_relaxation == relaxation) { + return; + } + + m_relaxation = relaxation; + emit relaxationChanged(m_relaxation); + + bundle(); + update(); +} + +void LinePlot::setBundleGPU(bool bundleGPU) +{ + if (m_bundleGPU == bundleGPU) { + return; + } + + m_bundleGPU = bundleGPU; + emit bundleGPUChanged(m_bundleGPU); + + bundle(); + update(); +} + // ---------------------------------------------------------------------------- class LinePlotRenderer @@ -133,23 +327,21 @@ private: void updatePoints(); void updateValues(); void updateColormap(); - void updateTransform(); void copyPolylines(const GraphDrawing *gd); QSize m_size; std::vector m_points; - const std::vector *m_values; + const std::vector *m_values, *m_cmap; std::vector m_offsets; - float m_alpha, m_beta; - GLfloat m_transform[4][4]; - LinearScale m_sx, m_sy; QQuickWindow *m_window; // used to reset OpenGL state (as per docs) QOpenGLFunctions gl; QOpenGLShaderProgram *m_program; GLuint m_VBOs[2], m_colormapTex; QOpenGLVertexArrayObject m_VAO; + GLfloat m_transform[4][4]; + LinearScale m_sx, m_sy; bool m_pointsChanged, m_valuesChanged, m_colormapChanged; }; @@ -159,13 +351,12 @@ QQuickFramebufferObject::Renderer *LinePlot::createRenderer() const } LinePlotRenderer::LinePlotRenderer() - : m_sx(0, 1, 0, 1) - , m_sy(0, 1, 0, 1) - , gl(QOpenGLContext::currentContext()) + : gl(QOpenGLContext::currentContext()) + , m_sx(0.0f, 1.0f, 0.0f, 1.0f) + , m_sy(0.0f, 1.0f, 0.0f, 1.0f) { std::fill(&m_transform[0][0], &m_transform[0][0] + 16, 0.0f); m_transform[3][3] = 1.0f; - setupShaders(); setupVAOs(); setupTextures(); @@ -236,12 +427,39 @@ void LinePlotRenderer::setupTextures() LinePlotRenderer::~LinePlotRenderer() { + gl.glDeleteBuffers(2, m_VBOs); + gl.glDeleteTextures(1, &m_colormapTex); + delete m_program; } QOpenGLFramebufferObject *LinePlotRenderer::createFramebufferObject(const QSize &size) { m_size = size; + GLfloat w = m_size.width(), h = m_size.height(); + + GLfloat rangeOffset = Scatterplot::PADDING / w; + m_sx.setDomain(0, w); + m_sx.setRange(rangeOffset, 1.0f - rangeOffset); + GLfloat sx = 2.0f * m_sx.slope(); + GLfloat tx = 2.0f * m_sx.offset() - 1.0f; + + rangeOffset = Scatterplot::PADDING / h; + m_sy.setDomain(0, h); + m_sy.setRange(1.0f - rangeOffset, rangeOffset); // inverted on purpose + GLfloat sy = 2.0f * m_sy.slope(); + GLfloat ty = 2.0f * m_sy.offset() - 1.0f; + + // The transform matrix should be this (but transposed -- column major): + // [ sx 0.0f 0.0f tx ] + // [ 0.0f sy 0.0f ty ] + // [ 0.0f 0.0f 0.0f 0.0f ] + // [ 0.0f 0.0f 0.0f 1.0f ] + m_transform[0][0] = sx; + m_transform[1][1] = sy; + m_transform[3][0] = tx; + m_transform[3][1] = ty; + return QQuickFramebufferObject::Renderer::createFramebufferObject(m_size); } @@ -262,20 +480,31 @@ void LinePlotRenderer::render() updateColormap(); } + if (m_offsets.size() < 2) { + // Nothing to draw + return; + } + m_program->bind(); - m_program->setUniformValue("transform", m_transform); gl.glActiveTexture(GL_TEXTURE0); gl.glBindTexture(GL_TEXTURE_2D, m_colormapTex); m_program->setUniformValue("colormap", 0); + m_program->setUniformValue("transform", m_transform); gl.glClearColor(0, 0, 0, 0); gl.glClear(GL_COLOR_BUFFER_BIT); m_VAO.bind(); - for (int i = 0; i < m_offsets.size() - 1; i++) { - gl.glDrawArrays(GL_LINES, m_offsets[i], m_offsets[i + 1]); + gl.glEnable(GL_LINE_SMOOTH); + gl.glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); + gl.glEnable(GL_BLEND); + gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + for (int i = 1; i < m_offsets.size(); i++) { + gl.glDrawArrays(GL_LINE_STRIP, m_offsets[i - 1], m_offsets[i] - m_offsets[i - 1]); } + gl.glDisable(GL_LINE_SMOOTH); + gl.glDisable(GL_BLEND); m_VAO.release(); m_program->release(); @@ -290,22 +519,20 @@ void LinePlotRenderer::copyPolylines(const GraphDrawing *gd) int pointsNum = 0; m_offsets.clear(); + m_offsets.reserve(gd->draw_order.size() + 1); m_offsets.push_back(0); - for (std::pair p : gd->draw_order) { + for (auto &p : gd->draw_order) { pointsNum += p.second->size(); m_offsets.push_back(pointsNum); } - m_points.resize(2 * pointsNum); - arma::uword i = 0, k = 0; - for (std::pair p : gd->draw_order) { - for (arma::uword j = 0; j < p.second->size(); j++) { - m_points[i + j + 0] = (*p.second)[j].x; - m_points[i + j + 1] = (*p.second)[j].y; + m_points.clear(); + m_points.reserve(2 * pointsNum); + for (auto &p : gd->draw_order) { + for (auto &point : *p.second) { + m_points.push_back(point.x); + m_points.push_back(point.y); } - - i += p.second->size(); - k++; } } @@ -313,54 +540,29 @@ void LinePlotRenderer::synchronize(QQuickFramebufferObject *item) { LinePlot *plot = static_cast(item); - m_pointsChanged = plot->xyChanged(); + m_pointsChanged = plot->linesChanged(); m_valuesChanged = plot->valuesChanged(); m_colormapChanged = plot->colorScaleChanged(); - copyPolylines(plot->graphDrawing()); + if (m_pointsChanged) { + copyPolylines(plot->bundleGraphDrawing()); + } m_values = &(plot->values()); - m_sx = plot->scaleX(); - m_sy = plot->scaleY(); + m_cmap = &(plot->colorScale()); m_window = plot->window(); // Reset so that we have the correct values by the next synchronize() - plot->setXYChanged(false); + plot->setLinesChanged(false); plot->setValuesChanged(false); plot->setColorScaleChanged(false); } -void LinePlotRenderer::updateTransform() -{ - GLfloat w = m_size.width(), h = m_size.height(); - - GLfloat rangeOffset = Scatterplot::PADDING / w; - m_sx.setRange(rangeOffset, 1.0f - rangeOffset); - GLfloat sx = 2.0f * m_sx.slope(); - GLfloat tx = 2.0f * m_sx.offset() - 1.0f; - - rangeOffset = Scatterplot::PADDING / h; - m_sy.setRange(1.0f - rangeOffset, rangeOffset); - GLfloat sy = 2.0f * m_sy.slope(); - GLfloat ty = 2.0f * m_sy.offset() - 1.0f; - - // The transform matrix should be this (but transposed -- column major): - // [ sx 0.0f 0.0f -tx ] - // [ 0.0f sy 0.0f -ty ] - // [ 0.0f 0.0f 0.0f 0.0f ] - // [ 0.0f 0.0f 0.0f 1.0f ] - m_transform[0][0] = sx; - m_transform[1][1] = sy; - m_transform[3][0] = tx; - m_transform[3][1] = ty; -} - void LinePlotRenderer::updatePoints() { gl.glBindBuffer(GL_ARRAY_BUFFER, m_VBOs[0]); gl.glBufferData(GL_ARRAY_BUFFER, m_points.size() * sizeof(float), m_points.data(), GL_DYNAMIC_DRAW); - updateTransform(); m_pointsChanged = false; } @@ -376,8 +578,8 @@ void LinePlotRenderer::updateValues() void LinePlotRenderer::updateColormap() { gl.glBindTexture(GL_TEXTURE_2D, m_colormapTex); - //gl.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_cmap->size() / 3, 1, 0, GL_RGB, - // GL_FLOAT, m_cmap->data()); + gl.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_cmap->size() / 3, 1, 0, GL_RGB, + GL_FLOAT, m_cmap->data()); m_colormapChanged = false; } diff --git a/lineplot.h b/lineplot.h index 060171d..bc6340c 100644 --- a/lineplot.h +++ b/lineplot.h @@ -18,27 +18,46 @@ class LinePlot : public QQuickFramebufferObject { Q_OBJECT + + // Main bundling + Q_PROPERTY(int iterations READ iterations WRITE setIterations NOTIFY iterationsChanged) + Q_PROPERTY(float kernelSize READ kernelSize WRITE setKernelSize NOTIFY kernelSizeChanged) + Q_PROPERTY(float smoothingFactor READ smoothingFactor WRITE setSmoothingFactor NOTIFY smoothingFactorChanged) + Q_PROPERTY(int smoothingIterations READ smoothingIterations WRITE setSmoothingIterations NOTIFY smoothingIterationsChanged) + + // Ends bundling + Q_PROPERTY(bool blockEndpoints READ blockEndpoints WRITE setBlockEndpoints NOTIFY blockEndpointsChanged) + Q_PROPERTY(int endsIterations READ endsIterations WRITE setEndsIterations NOTIFY endsIterationsChanged) + Q_PROPERTY(float endsKernelSize READ endsKernelSize WRITE setEndsKernelSize NOTIFY endsKernelSizeChanged) + Q_PROPERTY(float endsSmoothingFactor READ endsSmoothingFactor WRITE setEndsSmoothingFactor NOTIFY endsSmoothingFactorChanged) + + // General bundling options + Q_PROPERTY(float edgeSampling READ edgeSampling WRITE setEdgeSampling NOTIFY edgeSamplingChanged) + Q_PROPERTY(float advectionSpeed READ advectionSpeed WRITE setAdvectionSpeed NOTIFY advectionSpeedChanged) + Q_PROPERTY(float relaxation READ relaxation WRITE setRelaxation NOTIFY relaxationChanged) + Q_PROPERTY(bool bundleGPU READ bundleGPU WRITE setBundleGPU NOTIFY bundleGPUChanged) + public: static const int PADDING = 20; LinePlot(QQuickItem *parent = 0); - void setColorScale(const ColorScale *colorScale); - void setAutoScale(bool autoScale); + void setColorScale(const ColorScale *scale); - const GraphDrawing *graphDrawing() const { return m_gdPtr.get(); } - const std::vector &values() const { return m_values; } + const GraphDrawing *bundleGraphDrawing() const { return m_gdBundlePtr.get(); } + const std::vector &values() const { return m_values; } + const std::vector &colorScale() const { return m_cmap; } LinearScale scaleX() const { return m_sx; } LinearScale scaleY() const { return m_sy; } Renderer *createRenderer() const; - bool xyChanged() const { return m_xyChanged; } - bool valuesChanged() const { return m_valuesChanged; } + bool linesChanged() const { return m_linesChanged; } + bool valuesChanged() const { return m_valuesChanged; } bool colorScaleChanged() const { return m_colorScaleChanged; } - void setXYChanged(bool xyChanged) { - m_xyChanged = xyChanged; + void setLinesChanged(bool linesChanged) { + m_linesChanged = linesChanged; } void setValuesChanged(bool valuesChanged) { m_valuesChanged = valuesChanged; @@ -47,15 +66,66 @@ public: m_colorScaleChanged = colorScaleChanged; } + // Q_PROPERTY's + int iterations() const { return m_iterations; } + float kernelSize() const { return m_kernelSize; } + float smoothingFactor() const { return m_smoothingFactor; } + int smoothingIterations() const { return m_smoothingIterations; } + + void setIterations(int iterations); + void setKernelSize(float kernelSize); + void setSmoothingFactor(float smoothingFactor); + void setSmoothingIterations(int smoothingIterations); + + bool blockEndpoints() const { return m_blockEndpoints; } + int endsIterations() const { return m_endsIterations; } + float endsKernelSize() const { return m_endsKernelSize; } + float endsSmoothingFactor() const { return m_endsSmoothingFactor; } + + void setBlockEndpoints(bool blockEndpoints); + void setEndsIterations(int endsIterations); + void setEndsKernelSize(float endsKernelSize); + void setEndsSmoothingFactor(float endsSmoothingFactor); + + float edgeSampling() const { return m_edgeSampling; } + float advectionSpeed() const { return m_advectionSpeed; } + float relaxation() const { return m_relaxation; } + bool bundleGPU() const { return m_bundleGPU; } + + void setEdgeSampling(float edgeSampling); + void setAdvectionSpeed(float advectionSpeed); + void setRelaxation(float relaxation); + void setBundleGPU(bool bundleGPU); + signals: - void xyChanged(const arma::mat &xy); + void linesChanged(const arma::mat &xy); void valuesChanged(const arma::vec &values) const; void scaleChanged(const LinearScale &sx, const LinearScale &sy) const; + // Q_PROPERTY's + void iterationsChanged(int iterations) const; + void kernelSizeChanged(float kernelSize) const; + void smoothingFactorChanged(float smoothingFactor) const; + void smoothingIterationsChanged(int smoothingIterations) const; + + void blockEndpointsChanged(bool blockEndpoints) const; + void endsIterationsChanged(int endsIterations) const; + void endsKernelSizeChanged(float endsKernelSize) const; + void endsSmoothingFactorChanged(float endsSmoothingFactor) const; + + void edgeSamplingChanged(float edgeSampling) const; + void advectionSpeedChanged(float advectionSpeed) const; + void relaxationChanged(float relaxation) const; + void bundleGPUChanged(bool bundleGPU) const; + public slots: - void setXY(const arma::mat &xy); + // Lines are two consecutive elements in 'indices' (ref. points in 'Y') + void setLines(const arma::uvec &indices, const arma::mat &Y); + + // One value for each line void setValues(const arma::vec &values); + void setScale(const LinearScale &sx, const LinearScale &sy); @@ -63,21 +133,32 @@ private: void bundle(); // Data - arma::mat m_xy; + arma::mat m_lines; std::vector m_values; // Visuals - const ColorScale *m_colorScale; - - void autoScale(); - bool m_autoScale; + std::vector m_cmap; LinearScale m_sx, m_sy; - - std::unique_ptr m_gdPtr; + std::unique_ptr m_gdPtr, m_gdBundlePtr; // Internal state - bool m_xyChanged, m_valuesChanged, m_colorScaleChanged; - bool m_bundleGPU; + bool m_linesChanged, m_valuesChanged, m_colorScaleChanged; + + // Q_PROPERTY's + int m_iterations; + float m_kernelSize; + float m_smoothingFactor; + int m_smoothingIterations; + + bool m_blockEndpoints; + int m_endsIterations; + float m_endsKernelSize; + float m_endsSmoothingFactor; + + float m_edgeSampling; + float m_advectionSpeed; + float m_relaxation; + bool m_bundleGPU; }; #endif // LINEPLOT_H diff --git a/main.cpp b/main.cpp index c7a6f5c..bf9042a 100644 --- a/main.cpp +++ b/main.cpp @@ -153,9 +153,10 @@ int main(int argc, char **argv) // Initialize pointers to visual components m->cpPlot = engine.rootObjects()[0]->findChild("cpPlot"); m->rpPlot = engine.rootObjects()[0]->findChild("rpPlot"); + m->splat = engine.rootObjects()[0]->findChild("splat"); + m->bundlePlot = engine.rootObjects()[0]->findChild("bundlePlot"); m->cpColormap = engine.rootObjects()[0]->findChild("cpColormap"); m->rpColormap = engine.rootObjects()[0]->findChild("rpColormap"); - m->splat = engine.rootObjects()[0]->findChild("splat"); m->cpBarChart = engine.rootObjects()[0]->findChild("cpBarChart"); m->rpBarChart = engine.rootObjects()[0]->findChild("rpBarChart"); TransitionControl *plotTC = engine.rootObjects()[0]->findChild("plotTC"); @@ -170,6 +171,20 @@ int main(int argc, char **argv) QObject::connect(m->cpPlot, &Scatterplot::xyInteractivelyChanged, m, &Main::setCP); + // Keep both scatterplots, the splat and line plot scaled equally and + // relative to the full plot + MapScaleHandler mapScaleHandler; + QObject::connect(&mapScaleHandler, &MapScaleHandler::scaleChanged, + m->cpPlot, &Scatterplot::setScale); + QObject::connect(&mapScaleHandler, &MapScaleHandler::scaleChanged, + m->rpPlot, &Scatterplot::setScale); + QObject::connect(&mapScaleHandler, &MapScaleHandler::scaleChanged, + m->splat, &VoronoiSplat::setScale); + QObject::connect(&mapScaleHandler, &MapScaleHandler::scaleChanged, + m->bundlePlot, &LinePlot::setScale); + QObject::connect(m->projectionHistory, &ProjectionHistory::currentMapChanged, + &mapScaleHandler, &MapScaleHandler::scaleToMap); + // Update projection as the cp are modified (either directly in the // manipulationHandler object or interactively in cpPlot ManipulationHandler manipulationHandler(X, cpIndices); @@ -183,18 +198,32 @@ int main(int argc, char **argv) // ... and update visual components whenever the history changes QObject::connect(m->projectionHistory, &ProjectionHistory::currentMapChanged, m, &Main::updateMap); - - // Keep both scatterplots and the splat scaled equally and relative to the - // full plot - MapScaleHandler mapScaleHandler; - QObject::connect(&mapScaleHandler, &MapScaleHandler::scaleChanged, - m->cpPlot, &Scatterplot::setScale); - QObject::connect(&mapScaleHandler, &MapScaleHandler::scaleChanged, - m->rpPlot, &Scatterplot::setScale); - QObject::connect(&mapScaleHandler, &MapScaleHandler::scaleChanged, - m->splat, &VoronoiSplat::setScale); QObject::connect(m->projectionHistory, &ProjectionHistory::currentMapChanged, - &mapScaleHandler, &MapScaleHandler::scaleToMap); + [m](const arma::mat &Y) { + // ... and bundling + const arma::mat &unreliability = m->projectionHistory->unreliability(); + arma::uvec indicesLargest = arma::sort_index(unreliability, "descending"); + auto numLargest = Y.n_rows * 0.1f; + indicesLargest = indicesLargest.subvec(0, numLargest-1); + m->bundlePlot->setValues(unreliability(indicesLargest)); + + const arma::uvec &cpIndices = m->projectionHistory->cpIndices(); + arma::uvec CPs = cpIndices(indicesLargest / unreliability.n_rows); + + const arma::uvec &rpIndices = m->projectionHistory->rpIndices(); + arma::uvec RPs = indicesLargest; + RPs.transform([&unreliability](arma::uword v) { + return v % unreliability.n_rows; + }); + RPs = rpIndices(RPs); + + arma::uvec indices(CPs.n_elem + RPs.n_elem); + for (arma::uword i = 0; i < CPs.n_elem; i++) { + indices(2*i + 0) = CPs(i); + indices(2*i + 1) = RPs(i); + } + m->bundlePlot->setLines(indices, Y); + }); // Linking between selections SelectionHandler cpSelectionHandler(cpIndices.n_elem); diff --git a/main.h b/main.h index 830c742..143d49e 100644 --- a/main.h +++ b/main.h @@ -12,6 +12,7 @@ #include "numericrange.h" #include "barchart.h" #include "colormap.h" +#include "lineplot.h" #include "scatterplot.h" #include "voronoisplat.h" @@ -96,6 +97,7 @@ public: cpPlot->setColorScale(colorScaleCPs.get()); cpBarChart->setColorScale(colorScaleCPs.get()); cpColormap->setColorScale(colorScaleCPs.get()); + bundlePlot->setColorScale(colorScaleCPs.get()); } Q_INVOKABLE void setRPColorScale(ColorScaleType colorScaleType) { @@ -122,6 +124,7 @@ public: Colormap *cpColormap, *rpColormap; Scatterplot *cpPlot, *rpPlot; VoronoiSplat *splat; + LinePlot *bundlePlot; // Color scales in use std::unique_ptr colorScaleCPs, colorScaleRPs; @@ -188,6 +191,7 @@ private: , cpPlot(0) , rpPlot(0) , splat(0) + , bundlePlot(0) , projectionHistory(0) { } diff --git a/main_view.qml b/main_view.qml index bce7005..60a85aa 100644 --- a/main_view.qml +++ b/main_view.qml @@ -14,9 +14,6 @@ ApplicationWindow { Component.onCompleted: { setX(Screen.width / 2 - width / 2); setY(Screen.height / 2 - height / 2); - - this.minimumWidth = width; - this.minimumHeight = height; } menuBar: MenuBar { @@ -38,6 +35,11 @@ ApplicationWindow { MenuItem { action: selectRPsAction } MenuItem { action: selectCPsAction } } + + Menu { + title: "View" + MenuItem { action: toggleOptionsAction } + } } statusBar: StatusBar { @@ -78,28 +80,28 @@ ApplicationWindow { anchors.fill: parent } - Scatterplot { - id: rpPlot - objectName: "rpPlot" + LinePlot { + id: bundlePlot + objectName: "bundlePlot" x: parent.x y: parent.y z: 1 anchors.fill: parent - glyphSize: 3.0 } Scatterplot { - id: cpPlot - objectName: "cpPlot" + id: rpPlot + objectName: "rpPlot" x: parent.x y: parent.y z: 2 anchors.fill: parent + glyphSize: 3.0 } - LinePlot { - id: linePlot - objectName: "linePlot" + Scatterplot { + id: cpPlot + objectName: "cpPlot" x: parent.x y: parent.y z: 3 @@ -237,234 +239,434 @@ ApplicationWindow { } // Options panel - ColumnLayout { - Layout.alignment: Qt.AlignTop | Qt.AlignLeft - - GroupBox { - Layout.fillWidth: true - title: "Control points" - checkable: true - __checkbox.onClicked: { - cpPlot.visible = this.checked; - - if (this.checked) { - cpPlot.z = 0; - rpPlot.z = 0; - } else { - cpPlot.z = 0; - rpPlot.z = 1; - } - } - - ColumnLayout { - GroupBox { - flat: true - title: "Colors" - - GridLayout { - columns: 2 + RowLayout { + id: optionsPanel - Label { text: "Map to:" } - ComboBox { - id: cpPlotMetricComboBox - model: metricsModel - } + ColumnLayout { + Layout.alignment: Qt.AlignTop | Qt.AlignLeft - Label { text: "Color map:" } - ComboBox { - id: cpPlotColormapCombo - model: colormapModel - onActivated: - Main.setCPColorScale(model.get(index).value); - } + GroupBox { + Layout.fillWidth: true + title: "Control points" + checkable: true + __checkbox.onClicked: { + cpPlot.visible = this.checked; + + if (this.checked) { + cpPlot.z = 0; + rpPlot.z = 0; + } else { + cpPlot.z = 0; + rpPlot.z = 1; } } - GroupBox { - flat: true - title: "Glyphs" - - GridLayout { - columns: 2 - - Label { text: "Size:" } - SpinBox { - id: cpGlyphSizeSpinBox - maximumValue: 100 - minimumValue: 6 - decimals: 1 - stepSize: 1 - value: cpPlot.glyphSize - onValueChanged: cpPlot.glyphSize = this.value + ColumnLayout { + GroupBox { + flat: true + title: "Colors" + + GridLayout { + columns: 2 + + Label { text: "Map to:" } + ComboBox { + id: cpPlotMetricComboBox + model: metricsModel + } + + Label { text: "Color map:" } + ComboBox { + id: cpPlotColormapCombo + model: colormapModel + onActivated: + Main.setCPColorScale(model.get(index).value); + } } + } - Label { text: "Opacity:" } - Slider { - id: cpPlotOpacitySlider - tickmarksEnabled: true - stepSize: 0.1 - maximumValue: 1 - minimumValue: 0 - value: cpPlot.opacity - onValueChanged: cpPlot.opacity = this.value + GroupBox { + flat: true + title: "Glyphs" + + GridLayout { + columns: 2 + + Label { text: "Size:" } + SpinBox { + id: cpGlyphSizeSpinBox + maximumValue: 100 + minimumValue: 6 + decimals: 1 + stepSize: 1 + value: cpPlot.glyphSize + onValueChanged: cpPlot.glyphSize = this.value + } + + Label { text: "Opacity:" } + Slider { + id: cpPlotOpacitySlider + tickmarksEnabled: true + stepSize: 0.1 + maximumValue: 1 + minimumValue: 0 + value: cpPlot.opacity + onValueChanged: cpPlot.opacity = this.value + } } } } } - } - - GroupBox { - Layout.fillWidth: true - title: "Regular points" - checked: true - checkable: true - __checkbox.onClicked: { - rpPlot.visible = this.checked; - splat.visible = this.checked; - } - - ColumnLayout { - GroupBox { - flat: true - title: "Colors" - - GridLayout { - columns: 2 - Label { text: "Map to:" } - ComboBox { - id: rpPlotMetricComboBox - model: metricsModel - } - - Label { text: "Color map:" } - ComboBox { - id: rpPlotColormapCombo - model: colormapModel - onActivated: - Main.setRPColorScale(model.get(index).value); - } - } + GroupBox { + Layout.fillWidth: true + title: "Regular points" + checked: true + checkable: true + __checkbox.onClicked: { + rpPlot.visible = this.checked; + splat.visible = this.checked; } - GroupBox { - flat: true - title: "Splat" - - GridLayout { - columns: 2 - - Label { text: "Blur (α):" } - SpinBox { - id: alphaSpinBox - maximumValue: 100 - minimumValue: 1 - value: splat.alpha - decimals: 2 - stepSize: 1 - onValueChanged: splat.alpha = this.value + ColumnLayout { + GroupBox { + flat: true + title: "Colors" + + GridLayout { + columns: 2 + + Label { text: "Map to:" } + ComboBox { + id: rpPlotMetricComboBox + model: metricsModel + } + + Label { text: "Color map:" } + ComboBox { + id: rpPlotColormapCombo + model: colormapModel + onActivated: + Main.setRPColorScale(model.get(index).value); + } } + } - Label { text: "Radius (β):" } - SpinBox { - id: betaSpinBox - maximumValue: 100 - minimumValue: 1 - value: splat.beta - decimals: 2 - stepSize: 1 - onValueChanged: splat.beta = this.value + GroupBox { + flat: true + title: "Splat" + + GridLayout { + columns: 2 + + Label { text: "Blur (α):" } + SpinBox { + id: alphaSpinBox + maximumValue: 100 + minimumValue: 1 + value: splat.alpha + decimals: 2 + stepSize: 1 + onValueChanged: splat.alpha = this.value + } + + Label { text: "Radius (β):" } + SpinBox { + id: betaSpinBox + maximumValue: 100 + minimumValue: 1 + value: splat.beta + decimals: 2 + stepSize: 1 + onValueChanged: splat.beta = this.value + } + + Label { text: "Opacity:" } + Slider { + id: splatOpacitySlider + tickmarksEnabled: true + stepSize: 0.1 + maximumValue: 1 + minimumValue: 0 + value: splat.opacity + onValueChanged: splat.opacity = this.value + } } + } - Label { text: "Opacity:" } - Slider { - id: splatOpacitySlider - tickmarksEnabled: true - stepSize: 0.1 - maximumValue: 1 - minimumValue: 0 - value: splat.opacity - onValueChanged: splat.opacity = this.value + GroupBox { + flat: true + title: "Glyphs" + + GridLayout { + columns: 2 + + Label { text: "Size:" } + SpinBox { + id: rpGlyphSizeSpinBox + maximumValue: 100 + minimumValue: 2 + decimals: 1 + stepSize: 1 + value: rpPlot.glyphSize + onValueChanged: rpPlot.glyphSize = this.value + } + + Label { text: "Opacity:" } + Slider { + id: rpPlotOpacitySlider + tickmarksEnabled: true + stepSize: 0.1 + maximumValue: 1 + minimumValue: 0 + value: rpPlot.opacity + onValueChanged: rpPlot.opacity = this.value + } } } } + } - GroupBox { - flat: true - title: "Glyphs" - - GridLayout { - columns: 2 - - Label { text: "Size:" } - SpinBox { - id: rpGlyphSizeSpinBox - maximumValue: 100 - minimumValue: 2 - decimals: 1 - stepSize: 1 - value: rpPlot.glyphSize - onValueChanged: rpPlot.glyphSize = this.value + GroupBox { + Layout.fillWidth: true + id: metricsGroupBox + title: "Projection metrics" + property RadioButton current: currentMetricRadioButton + + Column { + ExclusiveGroup { id: wrtMetricsGroup } + + RadioButton { + id: currentMetricRadioButton + text: "Current" + exclusiveGroup: wrtMetricsGroup + checked: true + onClicked: { + if (!Main.setObserverType(Main.ObserverCurrent)) { + metricsGroupBox.current.checked = true; + } else { + metricsGroupBox.current = this; + } } - - Label { text: "Opacity:" } - Slider { - id: rpPlotOpacitySlider - tickmarksEnabled: true - stepSize: 0.1 - maximumValue: 1 - minimumValue: 0 - value: rpPlot.opacity - onValueChanged: rpPlot.opacity = this.value + } + RadioButton { + id: diffPreviousMetricRadioButton + text: "Diff. to previous" + exclusiveGroup: wrtMetricsGroup + onClicked: { + if (!Main.setObserverType(Main.ObserverDiffPrevious)) { + metricsGroupBox.current.checked = true; + } else { + metricsGroupBox.current = this; + } + } + } + RadioButton { + id: diffFirstMetricRadioButton + text: "Diff. to first" + exclusiveGroup: wrtMetricsGroup + onClicked: { + if (!Main.setObserverType(Main.ObserverDiffFirst)) { + metricsGroupBox.current.checked = true; + } else { + metricsGroupBox.current = this; + } } } } } } - GroupBox { - Layout.fillWidth: true - id: metricsGroupBox - title: "Projection metrics" - property RadioButton current: currentMetricRadioButton - - Column { - ExclusiveGroup { id: wrtMetricsGroup } - - RadioButton { - id: currentMetricRadioButton - text: "Current" - exclusiveGroup: wrtMetricsGroup - checked: true - onClicked: { - if (!Main.setObserverType(Main.ObserverCurrent)) { - metricsGroupBox.current.checked = true; - } else { - metricsGroupBox.current = this; + ColumnLayout { + Layout.alignment: Qt.AlignTop | Qt.AlignLeft + + GroupBox { + Layout.fillWidth: true + id: bundlingGroupBox + title: "Bundling" + checked: true + checkable: true + __checkbox.onClicked: { + bundlePlot.visible = this.checked; + } + + ColumnLayout { + GroupBox { + flat: true + title: "Main bundling" + + GridLayout { + columns: 2 + + Label { text: "Iterations:" } + SpinBox { + maximumValue: 100 + minimumValue: 0 + decimals: 0 + stepSize: 1 + value: bundlePlot.iterations + onValueChanged: bundlePlot.iterations = this.value + } + + Label { text: "Kernel size:" } + SpinBox { + maximumValue: 100 + minimumValue: 3 + decimals: 1 + stepSize: 1 + value: bundlePlot.kernelSize + onValueChanged: bundlePlot.kernelSize = this.value + } + + Label { text: "Smoothing factor:" } + Slider { + tickmarksEnabled: true + stepSize: 0.1 + maximumValue: 1 + minimumValue: 0 + value: bundlePlot.smoothingFactor + onValueChanged: bundlePlot.smoothingFactor = this.value + } + + Label { text: "Smoothing iterations:" } + SpinBox { + maximumValue: 100 + minimumValue: 0 + decimals: 0 + stepSize: 1 + value: bundlePlot.smoothingIterations + onValueChanged: bundlePlot.smoothingIterations = this.value + } } } - } - RadioButton { - id: diffPreviousMetricRadioButton - text: "Diff. to previous" - exclusiveGroup: wrtMetricsGroup - onClicked: { - if (!Main.setObserverType(Main.ObserverDiffPrevious)) { - metricsGroupBox.current.checked = true; - } else { - metricsGroupBox.current = this; + + GroupBox { + flat: true + title: "Ends bundling" + + GridLayout { + columns: 2 + + CheckBox { + Layout.columnSpan: 2 + text: "Block endpoints" + checked: bundlePlot.blockEndpoints + onClicked: bundlePlot.blockEndpoints = this.checked + } + + Label { text: "Iterations:" } + SpinBox { + maximumValue: 100 + minimumValue: 0 + decimals: 0 + stepSize: 1 + value: bundlePlot.endsIterations + onValueChanged: bundlePlot.endsIterations = this.value + } + + Label { text: "Kernel size:" } + SpinBox { + maximumValue: 100 + minimumValue: 3 + decimals: 1 + stepSize: 1 + value: bundlePlot.endsKernelSize + onValueChanged: bundlePlot.endsKernelSize = this.value + } + + Label { text: "Smoothing factor:" } + Slider { + tickmarksEnabled: true + stepSize: 0.1 + maximumValue: 1 + minimumValue: 0 + value: bundlePlot.endsSmoothingFactor + onValueChanged: bundlePlot.endsSmoothingFactor = this.value + } } } - } - RadioButton { - id: diffFirstMetricRadioButton - text: "Diff. to first" - exclusiveGroup: wrtMetricsGroup - onClicked: { - if (!Main.setObserverType(Main.ObserverDiffFirst)) { - metricsGroupBox.current.checked = true; - } else { - metricsGroupBox.current = this; + + GroupBox { + flat: true + title: "General" + + GridLayout { + columns: 2 + + Label { text: "Opacity:" } + Slider { + tickmarksEnabled: true + stepSize: 0.1 + maximumValue: 1 + minimumValue: 0 + value: bundlePlot.opacity + onValueChanged: bundlePlot.opacity = this.value + } + + Label { text: "Edge sampling:" } + SpinBox { + maximumValue: 100 + minimumValue: 3 + decimals: 1 + stepSize: 1 + value: bundlePlot.edgeSampling + onValueChanged: bundlePlot.edgeSampling = this.value + } + + Label { text: "Advection speed:" } + Slider { + tickmarksEnabled: true + stepSize: 0.1 + maximumValue: 1 + minimumValue: 0 + value: bundlePlot.advectionSpeed + onValueChanged: bundlePlot.advectionSpeed = this.value + } + + Label { text: "Density estimation:" } + RowLayout { + ExclusiveGroup { id: densityEstimationGroup } + RadioButton { + text: "Exact" + exclusiveGroup: densityEstimationGroup + } + RadioButton { + text: "Fast" + exclusiveGroup: densityEstimationGroup + checked: true + } + } + + Label { text: "Bundle shape:" } + RowLayout { + ExclusiveGroup { id: bundleShapeGroup } + RadioButton { + text: "FDEB" + exclusiveGroup: bundleShapeGroup + checked: true + } + RadioButton { + text: "HEB" + exclusiveGroup: bundleShapeGroup + } + } + + Label { text: "Relaxation:" } + Slider { + tickmarksEnabled: true + stepSize: 0.1 + maximumValue: 1 + minimumValue: 0 + value: bundlePlot.relaxation + onValueChanged: bundlePlot.relaxation = this.value + } + + CheckBox { + Layout.columnSpan: 2 + text: "Use GPU" + checked: bundlePlot.bundleGPU + onClicked: bundlePlot.bundleGPU = this.checked + } } } } @@ -561,6 +763,17 @@ ApplicationWindow { } } + Action { + id: toggleOptionsAction + text: "&Options" + shortcut: "Ctrl+O" + checkable: true + checked: true + onToggled: { + optionsPanel.visible = this.checked; + } + } + Action { id: selectCPsAction text: "&Control points" -- cgit v1.2.3