3 new lpe gadgets: sketch, knot and vonkoch.

(bzr r4842)

1 files changed, 347 insertions, 0 deletions

diff --git a/src/live_effects/lpe-sketch.cpp b/src/live_effects/lpe-sketch.cpp
new file mode 100644
index 000000000..9b49122fe
--- /dev/null
+++ b/src/live_effects/lpe-sketch.cpp
@@ -0,0 +1,347 @@
+#define INKSCAPE_LPE_SKETCH_CPP

+/** \file

+ * LPE <sketch> implementation

+ */

+/*

+ * Authors:

+ *   Johan Engelen

+*

+* Copyright (C) Johan Engelen 2007 <j.b.c.engelen@utwente.nl>

+ *

+ * Released under GNU GPL, read the file 'COPYING' for more information

+ */

+

+#include "live_effects/lpe-sketch.h"

+#include "display/curve.h"

+#include <libnr/n-art-bpath.h>

+

+// You might need to include other 2geom files. You can add them here:

+#include <2geom/path.h>

+#include <2geom/sbasis.h>

+#include <2geom/sbasis-geometric.h>

+#include <2geom/bezier-to-sbasis.h>

+#include <2geom/sbasis-to-bezier.h>

+#include <2geom/d2.h>

+#include <2geom/sbasis-math.h>

+#include <2geom/piecewise.h>

+#include <2geom/crossing.h>

+#include <2geom/path-intersection.h>

+

+namespace Inkscape {

+namespace LivePathEffect {

+

+LPESketch::LPESketch(LivePathEffectObject *lpeobject) :

+    Effect(lpeobject),

+    // initialise your parameters here:

+    //testpointA(_("Test Point A"), _("Test A"), "ptA", &wr, this, Geom::Point(100,100)),

+    nbiter_approxstrokes(_("Nb of iterations"), _("Draw that many approximating strokes sequences."), "nbiter_approxstrokes", &wr, this, 5),

+    strokelength(_("Max stroke length"), _("Maximal length of approximated strokes."), "strokelength", &wr, this, 100.),

+    strokelength_rdm(_("Randomness"), _("Random variation of stroke length (relative to max. length)."), "strokelength_rdm", &wr, this, .3),

+    strokeoverlap(_("Max. overlap"), _("How much successive strokes should overlap (relative to max. length)."), "strokeoverlap", &wr, this, .3),

+    strokeoverlap_rdm(_("Randomness"), _("Random variation of overlap (relative to max. overlap)"), "strokeoverlap_rdm", &wr, this, .3),

+    ends_tolerance(_("Max. ends tolerance"), _("Max. distance between original and approximated paths ends (relative to max. length)."), "ends_tolerance", &wr, this, .1),

+    parallel_offset(_("Average offset"), _("Average distance to original stroke(try 0.)."), "parallel_offset", &wr, this, 5.),

+    tremble_size(_("Max. tremble"), _("Maximal tremble magnitude."), "tremble_size", &wr, this, 5.),

+    tremble_frequency(_("Tremble frequency"), _("Typical nb of tremble 'period' in a stroke."), "tremble_frequency", &wr, this, 1.),

+    nbtangents(_("Nb of construction Lines"), _("How many construction lines (tangents) to draw?"), "nbtangents", &wr, this, 5),

+    tgtscale(_("Scale"), _("Scale factor relating curvature and length of construction lines(try 5*avarage offset) )"), "tgtscale", &wr, this, 10.0),

+    tgtlength(_("Max. length"), _("Max. length of construction lines."), "tgtlength", &wr, this, 100.0),

+    tgtlength_rdm(_("Randomness"), _("Random variation of construction lines length."), "tgtlength_rdm", &wr, this, .3)

+{

+    // register all your parameters here, so Inkscape knows which parameters this effect has:

+    //Add some comment in the UI:  *warning* the precise output of this effect might change in future releases!

+    //convert to path if you want to keep exact output unchanged in future releases...

+    //registerParameter( dynamic_cast<Parameter *>(&testpointA) );

+    registerParameter( dynamic_cast<Parameter *>(&nbiter_approxstrokes) );

+    registerParameter( dynamic_cast<Parameter *>(&strokelength) );

+    registerParameter( dynamic_cast<Parameter *>(&strokelength_rdm) );

+    registerParameter( dynamic_cast<Parameter *>(&strokeoverlap) );

+    registerParameter( dynamic_cast<Parameter *>(&strokeoverlap_rdm) );

+    registerParameter( dynamic_cast<Parameter *>(&ends_tolerance) );

+    registerParameter( dynamic_cast<Parameter *>(&parallel_offset) );

+    registerParameter( dynamic_cast<Parameter *>(&tremble_size) );

+    registerParameter( dynamic_cast<Parameter *>(&tremble_frequency) );

+    registerParameter( dynamic_cast<Parameter *>(&nbtangents) );

+    registerParameter( dynamic_cast<Parameter *>(&tgtscale) );

+    registerParameter( dynamic_cast<Parameter *>(&tgtlength) );

+    registerParameter( dynamic_cast<Parameter *>(&tgtlength_rdm) );

+

+

+    nbiter_approxstrokes.param_make_integer();

+    nbiter_approxstrokes.param_set_range(0, NR_HUGE);

+    strokelength.param_set_range(1, NR_HUGE);

+    strokelength.param_set_increments(1., 5.);

+    strokelength_rdm.param_set_range(0, 1.);

+    strokeoverlap.param_set_range(0, 1.);

+    strokeoverlap.param_set_increments(0.1, 0.30);

+    ends_tolerance.param_set_range(0., 1.);

+    parallel_offset.param_set_range(0, NR_HUGE);

+    tremble_frequency.param_set_range(0.01, 100.);

+    tremble_frequency.param_set_increments(.5, 1.5);

+    strokeoverlap_rdm.param_set_range(0, 1.);

+

+    nbtangents.param_make_integer();

+    nbtangents.param_set_range(0, NR_HUGE);

+    tgtscale.param_set_range(0, NR_HUGE);

+    tgtscale.param_set_increments(.1, .5);

+    tgtlength.param_set_range(0, NR_HUGE);

+    tgtlength.param_set_increments(1., 5.);

+    tgtlength_rdm.param_set_range(0, 1.);

+}

+

+LPESketch::~LPESketch()

+{

+

+}

+

+/*

+Geom::Piecewise<Geom::D2<Geom::SBasis> >

+addLinearEnds (Geom::Piecewise<Geom::D2<Geom::SBasis> > & m){

+    using namespace Geom;

+    Piecewise<D2<SBasis> > output;

+    Piecewise<D2<SBasis> > start;

+    Piecewise<D2<SBasis> > end;

+    double x,y,vx,vy;

+

+    x  = m.segs.front()[0].at0();

+    y  = m.segs.front()[1].at0();

+    vx = m.segs.front()[0][1][0]+Tri(m.segs.front()[0][0]);

+    vy = m.segs.front()[1][1][0]+Tri(m.segs.front()[1][0]);

+    start = Piecewise<D2<SBasis> >(D2<SBasis>(Linear (x-vx,x),Linear (y-vy,y)));

+    start.offsetDomain(m.cuts.front()-1.);

+

+    x  = m.segs.back()[0].at1();

+    y  = m.segs.back()[1].at1();

+    vx = -m.segs.back()[0][1][1]+Tri(m.segs.back()[0][0]);;

+    vy = -m.segs.back()[1][1][1]+Tri(m.segs.back()[1][0]);;

+    end = Piecewise<D2<SBasis> >(D2<SBasis>(Linear (x,x+vx),Linear (y,y+vy)));

+    //end.offsetDomain(m.cuts.back());

+

+    output = start;

+    output.concat(m);

+    output.concat(end);

+    return output;

+}

+*/

+

+//TODO: does this already exist in 2Geom? if not, move this there...

+std::vector<Geom::Piecewise<Geom::D2<Geom::SBasis> > > 

+split_at_discontinuities (Geom::Piecewise<Geom::D2<Geom::SBasis> > & pwsbin, double tol = .0001)

+{

+    using namespace Geom;

+    std::vector<Piecewise<D2<SBasis> > > ret;

+    unsigned piece_start = 0;

+    for (unsigned i=0; i<pwsbin.segs.size(); i++){

+        if (i==(pwsbin.segs.size()-1) || L2(pwsbin.segs[i].at1()- pwsbin.segs[i+1].at0()) > tol){

+            Piecewise<D2<SBasis> > piece;

+            piece.cuts.push_back(pwsbin.cuts[piece_start]);

+            for (unsigned j = piece_start; j<i+1; j++){

+                piece.segs.push_back(pwsbin.segs[j]);

+                piece.cuts.push_back(pwsbin.cuts[j+1]);                

+            }

+            ret.push_back(piece);

+            piece_start = i+1;

+        }

+    }

+    return ret;

+}

+

+//This returns a random perturbation. Notice the domain is [s0,s0+first multiple of period>s1]...

+Geom::Piecewise<Geom::D2<Geom::SBasis> > 

+LPESketch::computePerturbation (double s0, double s1){

+    using namespace Geom;

+    Piecewise<D2<SBasis> >res;

+    

+    //global offset for this stroke.

+    double offsetX = parallel_offset-parallel_offset.get_value();

+    double offsetY = parallel_offset-parallel_offset.get_value();

+    Point A,dA,B,dB,offset = Point(offsetX,offsetY);

+    //start point A

+    for (unsigned dim=0; dim<2; dim++){

+        A[dim]  = offset[dim] + 2*tremble_size-tremble_size.get_value();

+        dA[dim] = 2*tremble_size-tremble_size.get_value();

+    }

+    //compute howmany deg 3 sbasis to concat according to frequency.

+    unsigned count = unsigned((s1-s0)/strokelength*tremble_frequency)+1; 

+    for (unsigned i=0; i<count; i++){

+        D2<SBasis> perturb = D2<SBasis>();

+        for (unsigned dim=0; dim<2; dim++){

+            B[dim] = offset[dim] + 2*tremble_size-tremble_size.get_value();

+            perturb[dim].push_back(Linear(A[dim],B[dim]));

+            dA[dim] = dA[dim]-B[dim]+A[dim];

+            dB[dim] = 2*tremble_size-tremble_size.get_value();

+            perturb[dim].push_back(Linear(dA[dim],dB[dim]));

+        }

+        A = B;

+        dA = B-A-dB;

+        res.concat(Piecewise<D2<SBasis> >(perturb));

+    }

+    res.setDomain(Interval(s0,s0+count*strokelength/tremble_frequency));

+    return res;

+}

+

+

+// Main effect body...

+Geom::Piecewise<Geom::D2<Geom::SBasis> >

+LPESketch::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > & pwd2_in)

+{

+    using namespace Geom;

+    Piecewise<D2<SBasis> > output;

+

+

+    //init random parameters.

+    parallel_offset.resetRandomizer();

+    strokelength_rdm.resetRandomizer();

+    strokeoverlap_rdm.resetRandomizer();

+    tgtlength_rdm.resetRandomizer();

+

+    // some variables for futur use.

+    // notations will be : t = path time, s = distance from start along the path.

+    Piecewise<SBasis> pathlength;

+    std::vector<double> times;  

+    double total_length;

+

+    //TODO: split Construction Lines/Approximated Strokes into two separate effects?

+

+    //----- Approximated Strokes.

+    //TODO: choose length & offset according to curvature?

+    

+    //TODO: retrieve components from path, dont merge to separate afterward! + know if closed!

+    std::vector<Piecewise<D2<SBasis> > > pieces_in = split_at_discontinuities (pwd2_in);

+

+    //work separately on each component.

+    for (unsigned pieceidx = 0; pieceidx < pieces_in.size(); pieceidx++){

+

+        Piecewise<D2<SBasis> > piece = pieces_in[pieceidx];

+        Piecewise<SBasis> piecelength = arcLengthSb(piece,.1);

+        pathlength.concat(piecelength);

+        

+        total_length = piecelength.segs.back().at1()-piecelength.segs.front().at0();

+

+        //TODO: better check this on the Geom::Path.

+        bool closed = piece.segs.front().at0() == piece.segs.back().at1(); 

+        if (closed){ 

+            piece.concat(piece);

+            piecelength.concat(piecelength+total_length);

+        }

+

+        for (unsigned i = 0; i<nbiter_approxstrokes; i++){

+            //Basic steps: 

+            //- Choose a rdm seg [s0,s1], find coresponding [t0,t1], 

+            //- Pick a rdm perturbation delta(s), collect 'piece(t)+delta(s(t))' over [t0,t1] into output.

+

+            // pick a point where to start the stroke (s0 = dist from start).

+            double s1=0.,s0 = ends_tolerance*strokelength+0.0001;//the root finder might miss 0.  

+            double t1, t0;

+            double s0_initial = s0;

+            bool done = false;// was the end of the component reached?

+

+            while (!done){

+                // if the start point is already too far... do nothing. (this should not happen!)

+                assert (s0>=0);//this should not happen!!

+                if (!closed && s1>total_length - ends_tolerance.get_value()*strokelength) break;

+                if ( closed && s0>total_length + s0_initial) break;

+

+                times = roots(piecelength-s0);  

+                if (times.size()==0) break;//we should not be there.

+                t0 = times[0];

+                

+                // pick a new end point (s1 = s0 + strokelength).

+                s1 = s0 + strokelength*(1-strokelength_rdm);

+                // don't let it go beyond the end of the orgiginal path.

+                // TODO/FIXME: this might result in short strokes near the end...

+                if (!closed && s1>total_length-ends_tolerance.get_value()*strokelength){

+                    done = true;

+                    //!!the root solver might miss s1==total_length...

+                    if (s1>total_length){s1 = total_length - ends_tolerance*strokelength-0.0001;}

+                }

+                if (closed && s1>total_length + s0_initial){

+                    done = true;

+                    if (closed && s1>2*total_length){s1 = 2*total_length - strokeoverlap*(1-strokeoverlap_rdm)*strokelength-0.0001;}

+                }

+                times = roots(piecelength-s1);  

+                if (times.size()==0) break;//we should not be there.

+                t1 = times[0];

+                

+                //pick a rdm perturbation, and collect the perturbed piece into output.

+                Piecewise<D2<SBasis> > pwperturb = computePerturbation(s0,s1);

+                pwperturb = compose(pwperturb,portion(piecelength,t0,t1));

+                output.concat(portion(piece,t0,t1)+pwperturb);

+                

+                //step points: s0 = s1 - overlap.

+                //TODO: make sure this has to end?

+                s0 = s1 - strokeoverlap*(1-strokeoverlap_rdm)*strokelength;

+            }

+        }

+    }

+

+

+    //----- Construction lines.

+    //TODO: choose places according to curvature?.

+

+    //at this point we have:

+    //pathlength = arcLengthSb(pwd2_in,.1);

+    total_length = pathlength.segs.back().at1();

+    Piecewise<D2<SBasis> > m = pwd2_in;

+    Piecewise<D2<SBasis> > v = derivative(pwd2_in);

+    Piecewise<D2<SBasis> > a = derivative(v);

+    for (unsigned i=0; i<nbtangents; i++){

+        // pick a point where to draw a tangent (s = dist from start along path).

+        double s = total_length * ( i + tgtlength_rdm ) / (nbtangents+1.);

+        times = roots(pathlength-s);

+        assert(times.size()>0);//there should be one and only one solution!

+        double t = times[0];

+        Point m_t = m(t), v_t = v(t), a_t = a(t);

+        //Compute tgt length according to curvature (not exceeding tgtlength) so that  

+        //  dist to origninal curve ~ 4 * (parallel_offset+tremble_size).

+        //TODO: put this 4 as a parameter in the UI...

+        //TODO: what if with v=0?

+        double l = tgtlength*(1-tgtlength_rdm)/v_t.length();

+        double r = pow(v_t.length(),3)/cross(a_t,v_t);

+        r = sqrt((2*fabs(r)-tgtscale)*tgtscale)/v_t.length();

+        l=(r<l)?r:l;

+        //collect the tgt segment into output.

+        D2<SBasis> tgt = D2<SBasis>();

+        for (unsigned dim=0; dim<2; dim++){

+            tgt[dim] = SBasis(Linear(m_t[dim]-v_t[dim]*l, m_t[dim]+v_t[dim]*l));

+        }

+        output.concat(Piecewise<D2<SBasis> >(tgt));

+    }

+

+// // -------- Pleins et delies vs courbure ou direction...

+//     Piecewise<D2<SBasis> > a = derivative(v);

+//     Piecewise<SBasis> a_cross_n = cross(a,n);

+//     Piecewise<SBasis> v_dot_n = dot(v,n);

+//     //Piecewise<D2<SBasis> > rfrac = sectionize(D2<Piecewise<SBasis> >(a_cross_n,v_dot_n));

+//     //Piecewise<SBasis> h = atan2(rfrac)*para1;

+//     Piecewise<SBasis> h = reciprocal(curvature(piece))*para1;

+//

+// //    Piecewise<D2<SBasis> > dir = Piecewise<D2<SBasis> >(D2<SBasis>(Linear(0),Linear(-1)));

+// //    Piecewise<SBasis> h = dot(n,dir)+1.;

+// //    h *= h*(para1/4.);

+//

+//     n = rot90(n);

+//     output = piece+h*n;

+//     output.concat(piece-h*n);

+//

+// //-----------

+

+    //output.concat(m);

+    return output;

+}

+

+/* ######################## */

+

+} //namespace LivePathEffect (setq default-directory "c:/Documents And Settings/jf/Mes Documents/InkscapeSVN")

+} /* namespace Inkscape */

+

+/*

+  Local Variables:

+  mode:c++

+  c-file-style:"stroustrup"

+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))

+  indent-tabs-mode:nil

+  fill-column:99

+  End:

+*/

+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :