diff --git a/OpenBoard.pro b/OpenBoard.pro index 13b005e6..4558b666 100644 --- a/OpenBoard.pro +++ b/OpenBoard.pro @@ -66,9 +66,6 @@ INCLUDEPATH += src/pdf-merger include(src/pdf-merger/pdfMerger.pri) #ThirdParty -INCLUDEPATH += $$THIRD_PARTY_PATH/spline/ -INCLUDEPATH += $$THIRD_PARTY_PATH/alglib/ -include($$THIRD_PARTY_PATH/alglib/alglib.pri) DEPENDPATH += $$THIRD_PARTY_PATH/quazip/ INCLUDEPATH += $$THIRD_PARTY_PATH/quazip/ include($$THIRD_PARTY_PATH/quazip/quazip.pri) diff --git a/src/domain/UBGraphicsScene.cpp b/src/domain/UBGraphicsScene.cpp index d19a9457..b9d18043 100644 --- a/src/domain/UBGraphicsScene.cpp +++ b/src/domain/UBGraphicsScene.cpp @@ -630,30 +630,6 @@ bool UBGraphicsScene::inputDeviceRelease() mDrawWithCompass = false; } else if (mCurrentStroke){ - /* - // ------------------------------------------------------------------------- - // Replace the stroke by a smoother one - // ------------------------------------------------------------------------- - UBGraphicsStroke* smoothStroke = mCurrentStroke->smoothe(); - - foreach(UBGraphicsPolygonItem* poly, mCurrentStroke->polygons()){ - mPreviousPolygonItems.removeAll(poly); - removeItem(poly); - } - delete mCurrentStroke; - mCurrentStroke = smoothStroke; - - moveTo(smoothStroke->points()[0]); - for (int i(1); i < smoothStroke->points().size(); ++i) { - QPointF currentPoint = smoothStroke->points()[i]; - - drawLineTo(currentPoint, dc->currentToolWidth(), dc->currentToolWidth(), false); - moveTo(currentPoint); - } - - // ------------------------------------------------------------------------- - */ - UBGraphicsStrokesGroup* pStrokes = new UBGraphicsStrokesGroup(); // Remove the strokes that were just drawn here and replace them by a stroke item diff --git a/src/domain/UBGraphicsStroke.cpp b/src/domain/UBGraphicsStroke.cpp index 3553a465..6e28e9ca 100644 --- a/src/domain/UBGraphicsStroke.cpp +++ b/src/domain/UBGraphicsStroke.cpp @@ -88,7 +88,7 @@ QList UBGraphicsStroke::addPoint(const QPointF& point, UBInterpolator:: // We don't draw anything below the minimum distance. For performance reasons but also to make the curve // look smoother (e.g shaking slightly won't affect the curve). if (distance < MIN_DISTANCE) { - // we still keep track of that point to calculate the distance correctly next time around + // but we still keep track of that point to calculate the distance correctly next time around mLastReceivedPoint = point; return QList(); } @@ -123,59 +123,7 @@ QList UBGraphicsStroke::addPoint(const QPointF& point, UBInterpolator:: return newPoints; } - else { - - qreal MIN_INTERPOLATION_DISTANCE = 0; - - QPointF lastPoint; - if (!mDrawnPoints.isEmpty()) - lastPoint = mDrawnPoints.last(); - - QList newPoints; - - // Interpolation - if (n > 3 && QLineF(lastPoint, point).length() > MIN_INTERPOLATION_DISTANCE) { - - /* - UBSimpleSpline sp; - sp.setPoints(mDrawnPoints[n-2], mDrawnPoints[n-1], point); - */ - - // todo: better way of avoiding problems with equal x's (such as PCA). in the meantime this'll do. - qreal x0 = mDrawnPoints[n-3].x(); - qreal x1 = mDrawnPoints[n-2].x(); - qreal x2 = mDrawnPoints[n-1].x(); - qreal x3 = point.x(); - if (!(x0 == x1 || x0 == x2 || x0 == x3 || x1 == x2 || x1 == x3 || x2 == x3)) { - - UBCatmullRomSpline sp; - sp.setPoints(QList() << mDrawnPoints[n-3] << mDrawnPoints[n-2] << mDrawnPoints[n-1] << point); - - // get an extra 3 values in between the current point and last one - int n_points = 3; // number of points to interpolate - double interval = (point.x() - lastPoint.x())/double(n_points+1); - - qDebug() << "Interpolating between: " << lastPoint << " and " << point; - - for (int i(1); i <= n_points; ++i) { - double x = lastPoint.x() + i*interval; - QPointF newPoint(x, sp.y(x)); - qDebug() << newPoint; - - newPoints << newPoint; - mAllPoints << newPoint; - //qDebug() << "Got new point: " << newPoint; - } - } - - } - - newPoints << point; - mAllPoints << point; - mDrawnPoints << point; - - return newPoints; - } + return QList(); } bool UBGraphicsStroke::hasPressure() @@ -220,51 +168,3 @@ void UBGraphicsStroke::clear() mPolygons.clear(); } } - - -/** - * @brief Smoothe the curve, by interpolating extra points where needed. - * - * @return A new stroke based on the current one. - */ -UBGraphicsStroke* UBGraphicsStroke::smoothe() -{ - // Catmull-Rom spline interpolation - UBCatmullRomSpline sp; - - UBGraphicsStroke * smoothStroke = new UBGraphicsStroke(); - - smoothStroke->mAllPoints << mAllPoints[0]; - - for (int i(0); i < mAllPoints.size() - 3; ++i) { - QPointF p1, p2; - - p1 = mAllPoints[i+1]; - p2 = mAllPoints[i+2]; - - qreal x0 = mAllPoints[i].x(); - qreal x1 = p1.x(); - qreal x2 = p2.x(); - qreal x3 = mAllPoints[i+3].x(); - - if (!(x0 == x1 || x0 == x2 || x0 == x3 || x1 == x2 || x1 == x3 || x2 == x3)) { - sp.setPoints(QList() << mAllPoints[i] << mAllPoints[i+1] << mAllPoints[i+2] << mAllPoints[i+3]); - - smoothStroke->mAllPoints << mAllPoints[i+1]; - int n_points = 3; // number of points to interpolate - double interval = (p2.x() - p1.x())/double(n_points+1); - - for (int i(1); i <= n_points; ++i) { - double x = p1.x() + i*interval; - QPointF newPoint(x, sp.y(x)); - - smoothStroke->mAllPoints << newPoint; - } - } - - } - smoothStroke->mAllPoints << mAllPoints[mAllPoints.size() - 2] << mAllPoints[mAllPoints.size() - 1]; - - - return smoothStroke; -} diff --git a/src/domain/UBGraphicsStroke.h b/src/domain/UBGraphicsStroke.h index 5ef91507..860ab8f1 100644 --- a/src/domain/UBGraphicsStroke.h +++ b/src/domain/UBGraphicsStroke.h @@ -59,8 +59,6 @@ class UBGraphicsStroke QList addPoint(const QPointF& point, UBInterpolator::InterpolationMethod interpolationMethod = UBInterpolator::NoInterpolation); - UBGraphicsStroke* smoothe(); - const QList& points() { return mAllPoints; } protected: diff --git a/src/frameworks/UBInterpolator.cpp b/src/frameworks/UBInterpolator.cpp index bd40b038..b5777bcd 100644 --- a/src/frameworks/UBInterpolator.cpp +++ b/src/frameworks/UBInterpolator.cpp @@ -8,92 +8,6 @@ UBInterpolator::~UBInterpolator() { } - -UBSimpleSpline::UBSimpleSpline() -{ - -} - -void UBSimpleSpline::setPoints(QList points) -{ - setPoints(points[0], points[1], points[2]); -} - -void UBSimpleSpline::setPoints(QPointF p0, QPointF p1, QPointF p2) -{ - /* - p0 -= p0; - p1 -= p0; - p2 -= p0; - */ - long double x0, x1, x2, y0, y1, y2; - x0 = p0.x(); - x1 = p1.x(); - x2 = p2.x(); - y0 = p0.y(); - y1 = p1.y(); - y2 = p2.y(); - - long double k1 = (y2-y0)/(x2-x0); - - m_a = (y1-y2-k1*(x1-x2))/(pow(x1,3) - pow(x2,3) - 3*x2*(pow(x1,2)-pow(x2,2)) - - 3*(pow(x1,2) - 2*x1*x2)*(x1-x2)); - - m_b = -3*m_a*x2; - m_c = k1 - 3*m_a*pow(x1,2) - 2*m_b*x1; - m_d = y1 - m_a*pow(x1,3) - m_b*pow(x1,2) - m_c*x1; -} - -double UBSimpleSpline::y(double x) -{ - return m_a*pow(x, 3) + m_b*pow(x, 2) + m_c*x + m_d; -} - -UBCatmullRomSpline::UBCatmullRomSpline() -{ - mInterpolant = 0; -} - -UBCatmullRomSpline::~UBCatmullRomSpline() -{ - if (mInterpolant) - delete mInterpolant; -} - -void UBCatmullRomSpline::setPoints(QList points) -{ - // todo : basis change to avoid crashing when several X's are equal - mInterpolant = new alglib::spline1dinterpolant(); - - // alglib arrays are defined as strings - QString x = "["; - QString y = "["; - - foreach(QPointF point, points) { - x += (QString::number(point.x()) + QString(",")); - y += (QString::number(point.y()) + QString(",")); - } - - x.chop(1); - y.chop(1); - - x+="]"; - y+="]"; - - alglib::real_1d_array xArray = x.toLatin1().data(); - alglib::real_1d_array yArray = y.toLatin1().data(); - - alglib::spline1dbuildcatmullrom(xArray, yArray, *mInterpolant); - - -} - -double UBCatmullRomSpline::y(double x) -{ - return alglib::spline1dcalc(*mInterpolant, x); -} - - UBQuadraticBezier::UBQuadraticBezier() { mPath = 0; diff --git a/src/frameworks/UBInterpolator.h b/src/frameworks/UBInterpolator.h index 1a028523..9a714488 100644 --- a/src/frameworks/UBInterpolator.h +++ b/src/frameworks/UBInterpolator.h @@ -3,9 +3,6 @@ #include -#include "spline.h" -#include "interpolation.h" - class UBInterpolator { /* Abstract class representing an interpolator */ @@ -13,8 +10,8 @@ class UBInterpolator public: enum InterpolationMethod { NoInterpolation, - SimpleSpline, - CatmullRom, + //SimpleSpline, + //CatmullRom, Bezier }; @@ -22,58 +19,10 @@ public: virtual ~UBInterpolator(); virtual void setPoints(QList points) = 0; - virtual double y(double x) {} - -}; - - -class UBSimpleSpline : public UBInterpolator -{ - /* A basic cubic spline interpolator, that requires only three - * points to interpolate between the second and third one. - * To do so, the curvature at p2 is set to 0, so the resulting - * curve is not very smooth. - * However, it is better than linear interpolation and requires no - * "future" points, so it can be used seamlessly during drawing. - */ - -public: - UBSimpleSpline(); - virtual ~UBSimpleSpline() {} - - virtual void setPoints(QList points); - void setPoints(QPointF p0, QPointF p1, QPointF p2); - - virtual double y(double x); - -private: - long double m_a, - m_b, - m_c, - m_d; -}; - - -class UBCatmullRomSpline : public UBInterpolator -{ - /* Catmull-Rom spline, using AlgLib as backend - * - * This requires four points to interpolate between the middle two. - */ - -public: - UBCatmullRomSpline(); - virtual ~UBCatmullRomSpline(); - - virtual void setPoints(QList points); - virtual double y(double x); - -private: - alglib::spline1dinterpolant * mInterpolant; + //virtual double y(double x) {} }; - class UBQuadraticBezier : public UBInterpolator {